rmN4CJjQ

1/*! *****************************************************************************
2Copyright (c) Microsoft Corporation. All rights reserved. 
3Licensed under the Apache License, Version 2.0 (the "License"); you may not use
4this file except in compliance with the License. You may obtain a copy of the
5License at http://www.apache.org/licenses/LICENSE-2.0  
6 
7THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
8KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
9WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE, 
10MERCHANTABLITY OR NON-INFRINGEMENT. 
11 
12See the Apache Version 2.0 License for specific language governing permissions
13and limitations under the License.
14***************************************************************************** */
15
16
17
18/// <reference no-default-lib="true"/>
19
20
21/////////////////////////////
22/// DOM APIs
23/////////////////////////////
24
25interface Account {
26    displayName: string;
27    id: string;
28    imageURL?: string;
29    name?: string;
30    rpDisplayName: string;
31}
32
33interface AddEventListenerOptions extends EventListenerOptions {
34    once?: boolean;
35    passive?: boolean;
36}
37
38interface AesCbcParams extends Algorithm {
39    iv: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;
40}
41
42interface AesCtrParams extends Algorithm {
43    counter: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;
44    length: number;
45}
46
47interface AesDerivedKeyParams extends Algorithm {
48    length: number;
49}
50
51interface AesGcmParams extends Algorithm {
52    additionalData?: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;
53    iv: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;
54    tagLength?: number;
55}
56
57interface AesKeyAlgorithm extends KeyAlgorithm {
58    length: number;
59}
60
61interface AesKeyGenParams extends Algorithm {
62    length: number;
63}
64
65interface Algorithm {
66    name: string;
67}
68
69interface AnalyserOptions extends AudioNodeOptions {
70    fftSize?: number;
71    maxDecibels?: number;
72    minDecibels?: number;
73    smoothingTimeConstant?: number;
74}
75
76interface AnimationEventInit extends EventInit {
77    animationName?: string;
78    elapsedTime?: number;
79    pseudoElement?: string;
80}
81
82interface AnimationPlaybackEventInit extends EventInit {
83    currentTime?: number | null;
84    timelineTime?: number | null;
85}
86
87interface AssertionOptions {
88    allowList?: ScopedCredentialDescriptor[];
89    extensions?: WebAuthnExtensions;
90    rpId?: string;
91    timeoutSeconds?: number;
92}
93
94interface AssignedNodesOptions {
95    flatten?: boolean;
96}
97
98interface AudioBufferOptions {
99    length: number;
100    numberOfChannels?: number;
101    sampleRate: number;
102}
103
104interface AudioBufferSourceOptions {
105    buffer?: AudioBuffer | null;
106    detune?: number;
107    loop?: boolean;
108    loopEnd?: number;
109    loopStart?: number;
110    playbackRate?: number;
111}
112
113interface AudioContextInfo {
114    currentTime?: number;
115    sampleRate?: number;
116}
117
118interface AudioContextOptions {
119    latencyHint?: AudioContextLatencyCategory | number;
120    sampleRate?: number;
121}
122
123interface AudioNodeOptions {
124    channelCount?: number;
125    channelCountMode?: ChannelCountMode;
126    channelInterpretation?: ChannelInterpretation;
127}
128
129interface AudioParamDescriptor {
130    automationRate?: AutomationRate;
131    defaultValue?: number;
132    maxValue?: number;
133    minValue?: number;
134    name: string;
135}
136
137interface AudioProcessingEventInit extends EventInit {
138    inputBuffer: AudioBuffer;
139    outputBuffer: AudioBuffer;
140    playbackTime: number;
141}
142
143interface AudioTimestamp {
144    contextTime?: number;
145    performanceTime?: number;
146}
147
148interface AudioWorkletNodeOptions extends AudioNodeOptions {
149    numberOfInputs?: number;
150    numberOfOutputs?: number;
151    outputChannelCount?: number[];
152    parameterData?: Record<string, number>;
153    processorOptions?: any;
154}
155
156interface AuthenticationExtensionsClientInputs {
157    appid?: string;
158    authnSel?: AuthenticatorSelectionList;
159    exts?: boolean;
160    loc?: boolean;
161    txAuthGeneric?: txAuthGenericArg;
162    txAuthSimple?: string;
163    uvi?: boolean;
164    uvm?: boolean;
165}
166
167interface AuthenticationExtensionsClientOutputs {
168    appid?: boolean;
169    authnSel?: boolean;
170    exts?: AuthenticationExtensionsSupported;
171    loc?: Coordinates;
172    txAuthGeneric?: ArrayBuffer;
173    txAuthSimple?: string;
174    uvi?: ArrayBuffer;
175    uvm?: UvmEntries;
176}
177
178interface AuthenticatorSelectionCriteria {
179    authenticatorAttachment?: AuthenticatorAttachment;
180    requireResidentKey?: boolean;
181    userVerification?: UserVerificationRequirement;
182}
183
184interface BiquadFilterOptions extends AudioNodeOptions {
185    Q?: number;
186    detune?: number;
187    frequency?: number;
188    gain?: number;
189    type?: BiquadFilterType;
190}
191
192interface BlobPropertyBag {
193    endings?: EndingType;
194    type?: string;
195}
196
197interface ByteLengthChunk {
198    byteLength?: number;
199}
200
201interface CacheQueryOptions {
202    ignoreMethod?: boolean;
203    ignoreSearch?: boolean;
204    ignoreVary?: boolean;
205}
206
207interface CanvasRenderingContext2DSettings {
208    alpha?: boolean;
209    desynchronized?: boolean;
210}
211
212interface ChannelMergerOptions extends AudioNodeOptions {
213    numberOfInputs?: number;
214}
215
216interface ChannelSplitterOptions extends AudioNodeOptions {
217    numberOfOutputs?: number;
218}
219
220interface ClientData {
221    challenge: string;
222    extensions?: WebAuthnExtensions;
223    hashAlg: string | Algorithm;
224    origin: string;
225    rpId: string;
226    tokenBinding?: string;
227}
228
229interface ClientQueryOptions {
230    includeUncontrolled?: boolean;
231    type?: ClientTypes;
232}
233
234interface ClipboardEventInit extends EventInit {
235    clipboardData?: DataTransfer | null;
236}
237
238interface CloseEventInit extends EventInit {
239    code?: number;
240    reason?: string;
241    wasClean?: boolean;
242}
243
244interface CompositionEventInit extends UIEventInit {
245    data?: string;
246}
247
248interface ComputedEffectTiming extends EffectTiming {
249    activeDuration?: number;
250    currentIteration?: number | null;
251    endTime?: number;
252    localTime?: number | null;
253    progress?: number | null;
254}
255
256interface ComputedKeyframe {
257    composite: CompositeOperationOrAuto;
258    computedOffset: number;
259    easing: string;
260    offset: number | null;
261    [property: string]: string | number | null | undefined;
262}
263
264interface ConfirmSiteSpecificExceptionsInformation extends ExceptionInformation {
265    arrayOfDomainStrings?: string[];
266}
267
268interface ConstantSourceOptions {
269    offset?: number;
270}
271
272interface ConstrainBooleanParameters {
273    exact?: boolean;
274    ideal?: boolean;
275}
276
277interface ConstrainDOMStringParameters {
278    exact?: string | string[];
279    ideal?: string | string[];
280}
281
282interface ConstrainDoubleRange extends DoubleRange {
283    exact?: number;
284    ideal?: number;
285}
286
287interface ConstrainULongRange extends ULongRange {
288    exact?: number;
289    ideal?: number;
290}
291
292interface ConstrainVideoFacingModeParameters {
293    exact?: VideoFacingModeEnum | VideoFacingModeEnum[];
294    ideal?: VideoFacingModeEnum | VideoFacingModeEnum[];
295}
296
297interface ConvolverOptions extends AudioNodeOptions {
298    buffer?: AudioBuffer | null;
299    disableNormalization?: boolean;
300}
301
302interface CredentialCreationOptions {
303    publicKey?: PublicKeyCredentialCreationOptions;
304    signal?: AbortSignal;
305}
306
307interface CredentialRequestOptions {
308    mediation?: CredentialMediationRequirement;
309    publicKey?: PublicKeyCredentialRequestOptions;
310    signal?: AbortSignal;
311}
312
313interface CustomEventInit<T = any> extends EventInit {
314    detail?: T;
315}
316
317interface DOMMatrix2DInit {
318    a?: number;
319    b?: number;
320    c?: number;
321    d?: number;
322    e?: number;
323    f?: number;
324    m11?: number;
325    m12?: number;
326    m21?: number;
327    m22?: number;
328    m41?: number;
329    m42?: number;
330}
331
332interface DOMMatrixInit extends DOMMatrix2DInit {
333    is2D?: boolean;
334    m13?: number;
335    m14?: number;
336    m23?: number;
337    m24?: number;
338    m31?: number;
339    m32?: number;
340    m33?: number;
341    m34?: number;
342    m43?: number;
343    m44?: number;
344}
345
346interface DOMPointInit {
347    w?: number;
348    x?: number;
349    y?: number;
350    z?: number;
351}
352
353interface DOMQuadInit {
354    p1?: DOMPointInit;
355    p2?: DOMPointInit;
356    p3?: DOMPointInit;
357    p4?: DOMPointInit;
358}
359
360interface DOMRectInit {
361    height?: number;
362    width?: number;
363    x?: number;
364    y?: number;
365}
366
367interface DelayOptions extends AudioNodeOptions {
368    delayTime?: number;
369    maxDelayTime?: number;
370}
371
372interface DeviceLightEventInit extends EventInit {
373    value?: number;
374}
375
376interface DeviceMotionEventAccelerationInit {
377    x?: number | null;
378    y?: number | null;
379    z?: number | null;
380}
381
382interface DeviceMotionEventInit extends EventInit {
383    acceleration?: DeviceMotionEventAccelerationInit;
384    accelerationIncludingGravity?: DeviceMotionEventAccelerationInit;
385    interval?: number;
386    rotationRate?: DeviceMotionEventRotationRateInit;
387}
388
389interface DeviceMotionEventRotationRateInit {
390    alpha?: number | null;
391    beta?: number | null;
392    gamma?: number | null;
393}
394
395interface DeviceOrientationEventInit extends EventInit {
396    absolute?: boolean;
397    alpha?: number | null;
398    beta?: number | null;
399    gamma?: number | null;
400}
401
402interface DevicePermissionDescriptor extends PermissionDescriptor {
403    deviceId?: string;
404    name: "camera" | "microphone" | "speaker";
405}
406
407interface DocumentTimelineOptions {
408    originTime?: number;
409}
410
411interface DoubleRange {
412    max?: number;
413    min?: number;
414}
415
416interface DragEventInit extends MouseEventInit {
417    dataTransfer?: DataTransfer | null;
418}
419
420interface DynamicsCompressorOptions extends AudioNodeOptions {
421    attack?: number;
422    knee?: number;
423    ratio?: number;
424    release?: number;
425    threshold?: number;
426}
427
428interface EcKeyAlgorithm extends KeyAlgorithm {
429    namedCurve: NamedCurve;
430}
431
432interface EcKeyGenParams extends Algorithm {
433    namedCurve: NamedCurve;
434}
435
436interface EcKeyImportParams extends Algorithm {
437    namedCurve: NamedCurve;
438}
439
440interface EcdhKeyDeriveParams extends Algorithm {
441    public: CryptoKey;
442}
443
444interface EcdsaParams extends Algorithm {
445    hash: HashAlgorithmIdentifier;
446}
447
448interface EffectTiming {
449    delay?: number;
450    direction?: PlaybackDirection;
451    duration?: number | string;
452    easing?: string;
453    endDelay?: number;
454    fill?: FillMode;
455    iterationStart?: number;
456    iterations?: number;
457}
458
459interface ElementCreationOptions {
460    is?: string;
461}
462
463interface ElementDefinitionOptions {
464    extends?: string;
465}
466
467interface ErrorEventInit extends EventInit {
468    colno?: number;
469    error?: any;
470    filename?: string;
471    lineno?: number;
472    message?: string;
473}
474
475interface EventInit {
476    bubbles?: boolean;
477    cancelable?: boolean;
478    composed?: boolean;
479}
480
481interface EventListenerOptions {
482    capture?: boolean;
483}
484
485interface EventModifierInit extends UIEventInit {
486    altKey?: boolean;
487    ctrlKey?: boolean;
488    metaKey?: boolean;
489    modifierAltGraph?: boolean;
490    modifierCapsLock?: boolean;
491    modifierFn?: boolean;
492    modifierFnLock?: boolean;
493    modifierHyper?: boolean;
494    modifierNumLock?: boolean;
495    modifierScrollLock?: boolean;
496    modifierSuper?: boolean;
497    modifierSymbol?: boolean;
498    modifierSymbolLock?: boolean;
499    shiftKey?: boolean;
500}
501
502interface EventSourceInit {
503    withCredentials?: boolean;
504}
505
506interface ExceptionInformation {
507    domain?: string | null;
508}
509
510interface FilePropertyBag extends BlobPropertyBag {
511    lastModified?: number;
512}
513
514interface FocusEventInit extends UIEventInit {
515    relatedTarget?: EventTarget | null;
516}
517
518interface FocusNavigationEventInit extends EventInit {
519    navigationReason?: string | null;
520    originHeight?: number;
521    originLeft?: number;
522    originTop?: number;
523    originWidth?: number;
524}
525
526interface FocusNavigationOrigin {
527    originHeight?: number;
528    originLeft?: number;
529    originTop?: number;
530    originWidth?: number;
531}
532
533interface FocusOptions {
534    preventScroll?: boolean;
535}
536
537interface FullscreenOptions {
538    navigationUI?: FullscreenNavigationUI;
539}
540
541interface GainOptions extends AudioNodeOptions {
542    gain?: number;
543}
544
545interface GamepadEventInit extends EventInit {
546    gamepad: Gamepad;
547}
548
549interface GetNotificationOptions {
550    tag?: string;
551}
552
553interface GetRootNodeOptions {
554    composed?: boolean;
555}
556
557interface HashChangeEventInit extends EventInit {
558    newURL?: string;
559    oldURL?: string;
560}
561
562interface HkdfParams extends Algorithm {
563    hash: HashAlgorithmIdentifier;
564    info: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;
565    salt: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;
566}
567
568interface HmacImportParams extends Algorithm {
569    hash: HashAlgorithmIdentifier;
570    length?: number;
571}
572
573interface HmacKeyAlgorithm extends KeyAlgorithm {
574    hash: KeyAlgorithm;
575    length: number;
576}
577
578interface HmacKeyGenParams extends Algorithm {
579    hash: HashAlgorithmIdentifier;
580    length?: number;
581}
582
583interface IDBIndexParameters {
584    multiEntry?: boolean;
585    unique?: boolean;
586}
587
588interface IDBObjectStoreParameters {
589    autoIncrement?: boolean;
590    keyPath?: string | string[] | null;
591}
592
593interface IDBVersionChangeEventInit extends EventInit {
594    newVersion?: number | null;
595    oldVersion?: number;
596}
597
598interface IIRFilterOptions extends AudioNodeOptions {
599    feedback: number[];
600    feedforward: number[];
601}
602
603interface ImageBitmapRenderingContextSettings {
604    alpha?: boolean;
605}
606
607interface ImageEncodeOptions {
608    quality?: number;
609    type?: string;
610}
611
612interface InputEventInit extends UIEventInit {
613    data?: string | null;
614    inputType?: string;
615    isComposing?: boolean;
616}
617
618interface IntersectionObserverEntryInit {
619    boundingClientRect: DOMRectInit;
620    intersectionRatio: number;
621    intersectionRect: DOMRectInit;
622    isIntersecting: boolean;
623    rootBounds: DOMRectInit | null;
624    target: Element;
625    time: number;
626}
627
628interface IntersectionObserverInit {
629    root?: Element | null;
630    rootMargin?: string;
631    threshold?: number | number[];
632}
633
634interface JsonWebKey {
635    alg?: string;
636    crv?: string;
637    d?: string;
638    dp?: string;
639    dq?: string;
640    e?: string;
641    ext?: boolean;
642    k?: string;
643    key_ops?: string[];
644    kty?: string;
645    n?: string;
646    oth?: RsaOtherPrimesInfo[];
647    p?: string;
648    q?: string;
649    qi?: string;
650    use?: string;
651    x?: string;
652    y?: string;
653}
654
655interface KeyAlgorithm {
656    name: string;
657}
658
659interface KeyboardEventInit extends EventModifierInit {
660    code?: string;
661    isComposing?: boolean;
662    key?: string;
663    location?: number;
664    repeat?: boolean;
665}
666
667interface Keyframe {
668    composite?: CompositeOperationOrAuto;
669    easing?: string;
670    offset?: number | null;
671    [property: string]: string | number | null | undefined;
672}
673
674interface KeyframeAnimationOptions extends KeyframeEffectOptions {
675    id?: string;
676}
677
678interface KeyframeEffectOptions extends EffectTiming {
679    composite?: CompositeOperation;
680    iterationComposite?: IterationCompositeOperation;
681}
682
683interface MediaElementAudioSourceOptions {
684    mediaElement: HTMLMediaElement;
685}
686
687interface MediaEncryptedEventInit extends EventInit {
688    initData?: ArrayBuffer | null;
689    initDataType?: string;
690}
691
692interface MediaKeyMessageEventInit extends EventInit {
693    message: ArrayBuffer;
694    messageType: MediaKeyMessageType;
695}
696
697interface MediaKeySystemConfiguration {
698    audioCapabilities?: MediaKeySystemMediaCapability[];
699    distinctiveIdentifier?: MediaKeysRequirement;
700    initDataTypes?: string[];
701    label?: string;
702    persistentState?: MediaKeysRequirement;
703    sessionTypes?: string[];
704    videoCapabilities?: MediaKeySystemMediaCapability[];
705}
706
707interface MediaKeySystemMediaCapability {
708    contentType?: string;
709    robustness?: string;
710}
711
712interface MediaQueryListEventInit extends EventInit {
713    matches?: boolean;
714    media?: string;
715}
716
717interface MediaStreamAudioSourceOptions {
718    mediaStream: MediaStream;
719}
720
721interface MediaStreamConstraints {
722    audio?: boolean | MediaTrackConstraints;
723    peerIdentity?: string;
724    video?: boolean | MediaTrackConstraints;
725}
726
727interface MediaStreamErrorEventInit extends EventInit {
728    error?: MediaStreamError | null;
729}
730
731interface MediaStreamEventInit extends EventInit {
732    stream?: MediaStream;
733}
734
735interface MediaStreamTrackAudioSourceOptions {
736    mediaStreamTrack: MediaStreamTrack;
737}
738
739interface MediaStreamTrackEventInit extends EventInit {
740    track: MediaStreamTrack;
741}
742
743interface MediaTrackCapabilities {
744    aspectRatio?: DoubleRange;
745    autoGainControl?: boolean[];
746    channelCount?: ULongRange;
747    deviceId?: string;
748    echoCancellation?: boolean[];
749    facingMode?: string[];
750    frameRate?: DoubleRange;
751    groupId?: string;
752    height?: ULongRange;
753    latency?: DoubleRange;
754    noiseSuppression?: boolean[];
755    resizeMode?: string[];
756    sampleRate?: ULongRange;
757    sampleSize?: ULongRange;
758    width?: ULongRange;
759}
760
761interface MediaTrackConstraintSet {
762    aspectRatio?: ConstrainDouble;
763    autoGainControl?: ConstrainBoolean;
764    channelCount?: ConstrainULong;
765    deviceId?: ConstrainDOMString;
766    echoCancellation?: ConstrainBoolean;
767    facingMode?: ConstrainDOMString;
768    frameRate?: ConstrainDouble;
769    groupId?: ConstrainDOMString;
770    height?: ConstrainULong;
771    latency?: ConstrainDouble;
772    noiseSuppression?: ConstrainBoolean;
773    resizeMode?: ConstrainDOMString;
774    sampleRate?: ConstrainULong;
775    sampleSize?: ConstrainULong;
776    width?: ConstrainULong;
777}
778
779interface MediaTrackConstraints extends MediaTrackConstraintSet {
780    advanced?: MediaTrackConstraintSet[];
781}
782
783interface MediaTrackSettings {
784    aspectRatio?: number;
785    autoGainControl?: boolean;
786    channelCount?: number;
787    deviceId?: string;
788    echoCancellation?: boolean;
789    facingMode?: string;
790    frameRate?: number;
791    groupId?: string;
792    height?: number;
793    latency?: number;
794    noiseSuppression?: boolean;
795    resizeMode?: string;
796    sampleRate?: number;
797    sampleSize?: number;
798    width?: number;
799}
800
801interface MediaTrackSupportedConstraints {
802    aspectRatio?: boolean;
803    autoGainControl?: boolean;
804    channelCount?: boolean;
805    deviceId?: boolean;
806    echoCancellation?: boolean;
807    facingMode?: boolean;
808    frameRate?: boolean;
809    groupId?: boolean;
810    height?: boolean;
811    latency?: boolean;
812    noiseSuppression?: boolean;
813    resizeMode?: boolean;
814    sampleRate?: boolean;
815    sampleSize?: boolean;
816    width?: boolean;
817}
818
819interface MessageEventInit extends EventInit {
820    data?: any;
821    lastEventId?: string;
822    origin?: string;
823    ports?: MessagePort[];
824    source?: MessageEventSource | null;
825}
826
827interface MidiPermissionDescriptor extends PermissionDescriptor {
828    name: "midi";
829    sysex?: boolean;
830}
831
832interface MouseEventInit extends EventModifierInit {
833    button?: number;
834    buttons?: number;
835    clientX?: number;
836    clientY?: number;
837    movementX?: number;
838    movementY?: number;
839    relatedTarget?: EventTarget | null;
840    screenX?: number;
841    screenY?: number;
842}
843
844interface MultiCacheQueryOptions extends CacheQueryOptions {
845    cacheName?: string;
846}
847
848interface MutationObserverInit {
849    /**
850     * Set to a list of attribute local names (without namespace) if not all attribute mutations need to be observed and attributes is true or omitted.
851     */
852    attributeFilter?: string[];
853    /**
854     * Set to true if attributes is true or omitted and target's attribute value before the mutation needs to be recorded.
855     */
856    attributeOldValue?: boolean;
857    /**
858     * Set to true if mutations to target's attributes are to be observed. Can be omitted if attributeOldValue or attributeFilter is specified.
859     */
860    attributes?: boolean;
861    /**
862     * Set to true if mutations to target's data are to be observed. Can be omitted if characterDataOldValue is specified.
863     */
864    characterData?: boolean;
865    /**
866     * Set to true if characterData is set to true or omitted and target's data before the mutation needs to be recorded.
867     */
868    characterDataOldValue?: boolean;
869    /**
870     * Set to true if mutations to target's children are to be observed.
871     */
872    childList?: boolean;
873    /**
874     * Set to true if mutations to not just target, but also target's descendants are to be observed.
875     */
876    subtree?: boolean;
877}
878
879interface NavigationPreloadState {
880    enabled?: boolean;
881    headerValue?: string;
882}
883
884interface NotificationAction {
885    action: string;
886    icon?: string;
887    title: string;
888}
889
890interface NotificationOptions {
891    actions?: NotificationAction[];
892    badge?: string;
893    body?: string;
894    data?: any;
895    dir?: NotificationDirection;
896    icon?: string;
897    image?: string;
898    lang?: string;
899    renotify?: boolean;
900    requireInteraction?: boolean;
901    silent?: boolean;
902    tag?: string;
903    timestamp?: number;
904    vibrate?: VibratePattern;
905}
906
907interface OfflineAudioCompletionEventInit extends EventInit {
908    renderedBuffer: AudioBuffer;
909}
910
911interface OfflineAudioContextOptions {
912    length: number;
913    numberOfChannels?: number;
914    sampleRate: number;
915}
916
917interface OptionalEffectTiming {
918    delay?: number;
919    direction?: PlaybackDirection;
920    duration?: number | string;
921    easing?: string;
922    endDelay?: number;
923    fill?: FillMode;
924    iterationStart?: number;
925    iterations?: number;
926}
927
928interface OscillatorOptions extends AudioNodeOptions {
929    detune?: number;
930    frequency?: number;
931    periodicWave?: PeriodicWave;
932    type?: OscillatorType;
933}
934
935interface PannerOptions extends AudioNodeOptions {
936    coneInnerAngle?: number;
937    coneOuterAngle?: number;
938    coneOuterGain?: number;
939    distanceModel?: DistanceModelType;
940    maxDistance?: number;
941    orientationX?: number;
942    orientationY?: number;
943    orientationZ?: number;
944    panningModel?: PanningModelType;
945    positionX?: number;
946    positionY?: number;
947    positionZ?: number;
948    refDistance?: number;
949    rolloffFactor?: number;
950}
951
952interface PaymentCurrencyAmount {
953    currency: string;
954    currencySystem?: string;
955    value: string;
956}
957
958interface PaymentDetailsBase {
959    displayItems?: PaymentItem[];
960    modifiers?: PaymentDetailsModifier[];
961    shippingOptions?: PaymentShippingOption[];
962}
963
964interface PaymentDetailsInit extends PaymentDetailsBase {
965    id?: string;
966    total: PaymentItem;
967}
968
969interface PaymentDetailsModifier {
970    additionalDisplayItems?: PaymentItem[];
971    data?: any;
972    supportedMethods: string | string[];
973    total?: PaymentItem;
974}
975
976interface PaymentDetailsUpdate extends PaymentDetailsBase {
977    error?: string;
978    total?: PaymentItem;
979}
980
981interface PaymentItem {
982    amount: PaymentCurrencyAmount;
983    label: string;
984    pending?: boolean;
985}
986
987interface PaymentMethodData {
988    data?: any;
989    supportedMethods: string | string[];
990}
991
992interface PaymentOptions {
993    requestPayerEmail?: boolean;
994    requestPayerName?: boolean;
995    requestPayerPhone?: boolean;
996    requestShipping?: boolean;
997    shippingType?: string;
998}
999
1000interface PaymentRequestUpdateEventInit extends EventInit {
1001}
1002
1003interface PaymentShippingOption {
1004    amount: PaymentCurrencyAmount;
1005    id: string;
1006    label: string;
1007    selected?: boolean;
1008}
1009
1010interface Pbkdf2Params extends Algorithm {
1011    hash: HashAlgorithmIdentifier;
1012    iterations: number;
1013    salt: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;
1014}
1015
1016interface PerformanceObserverInit {
1017    buffered?: boolean;
1018    entryTypes?: string[];
1019    type?: string;
1020}
1021
1022interface PeriodicWaveConstraints {
1023    disableNormalization?: boolean;
1024}
1025
1026interface PeriodicWaveOptions extends PeriodicWaveConstraints {
1027    imag?: number[] | Float32Array;
1028    real?: number[] | Float32Array;
1029}
1030
1031interface PermissionDescriptor {
1032    name: PermissionName;
1033}
1034
1035interface PipeOptions {
1036    preventAbort?: boolean;
1037    preventCancel?: boolean;
1038    preventClose?: boolean;
1039    signal?: AbortSignal;
1040}
1041
1042interface PointerEventInit extends MouseEventInit {
1043    height?: number;
1044    isPrimary?: boolean;
1045    pointerId?: number;
1046    pointerType?: string;
1047    pressure?: number;
1048    tangentialPressure?: number;
1049    tiltX?: number;
1050    tiltY?: number;
1051    twist?: number;
1052    width?: number;
1053}
1054
1055interface PopStateEventInit extends EventInit {
1056    state?: any;
1057}
1058
1059interface PositionOptions {
1060    enableHighAccuracy?: boolean;
1061    maximumAge?: number;
1062    timeout?: number;
1063}
1064
1065interface PostMessageOptions {
1066    transfer?: any[];
1067}
1068
1069interface ProgressEventInit extends EventInit {
1070    lengthComputable?: boolean;
1071    loaded?: number;
1072    total?: number;
1073}
1074
1075interface PromiseRejectionEventInit extends EventInit {
1076    promise: Promise<any>;
1077    reason?: any;
1078}
1079
1080interface PropertyIndexedKeyframes {
1081    composite?: CompositeOperationOrAuto | CompositeOperationOrAuto[];
1082    easing?: string | string[];
1083    offset?: number | (number | null)[];
1084    [property: string]: string | string[] | number | null | (number | null)[] | undefined;
1085}
1086
1087interface PublicKeyCredentialCreationOptions {
1088    attestation?: AttestationConveyancePreference;
1089    authenticatorSelection?: AuthenticatorSelectionCriteria;
1090    challenge: BufferSource;
1091    excludeCredentials?: PublicKeyCredentialDescriptor[];
1092    extensions?: AuthenticationExtensionsClientInputs;
1093    pubKeyCredParams: PublicKeyCredentialParameters[];
1094    rp: PublicKeyCredentialRpEntity;
1095    timeout?: number;
1096    user: PublicKeyCredentialUserEntity;
1097}
1098
1099interface PublicKeyCredentialDescriptor {
1100    id: BufferSource;
1101    transports?: AuthenticatorTransport[];
1102    type: PublicKeyCredentialType;
1103}
1104
1105interface PublicKeyCredentialEntity {
1106    icon?: string;
1107    name: string;
1108}
1109
1110interface PublicKeyCredentialParameters {
1111    alg: COSEAlgorithmIdentifier;
1112    type: PublicKeyCredentialType;
1113}
1114
1115interface PublicKeyCredentialRequestOptions {
1116    allowCredentials?: PublicKeyCredentialDescriptor[];
1117    challenge: BufferSource;
1118    extensions?: AuthenticationExtensionsClientInputs;
1119    rpId?: string;
1120    timeout?: number;
1121    userVerification?: UserVerificationRequirement;
1122}
1123
1124interface PublicKeyCredentialRpEntity extends PublicKeyCredentialEntity {
1125    id?: string;
1126}
1127
1128interface PublicKeyCredentialUserEntity extends PublicKeyCredentialEntity {
1129    displayName: string;
1130    id: BufferSource;
1131}
1132
1133interface PushPermissionDescriptor extends PermissionDescriptor {
1134    name: "push";
1135    userVisibleOnly?: boolean;
1136}
1137
1138interface PushSubscriptionJSON {
1139    endpoint?: string;
1140    expirationTime?: number | null;
1141    keys?: Record<string, string>;
1142}
1143
1144interface PushSubscriptionOptionsInit {
1145    applicationServerKey?: BufferSource | string | null;
1146    userVisibleOnly?: boolean;
1147}
1148
1149interface QueuingStrategy<T = any> {
1150    highWaterMark?: number;
1151    size?: QueuingStrategySizeCallback<T>;
1152}
1153
1154interface RTCAnswerOptions extends RTCOfferAnswerOptions {
1155}
1156
1157interface RTCCertificateExpiration {
1158    expires?: number;
1159}
1160
1161interface RTCConfiguration {
1162    bundlePolicy?: RTCBundlePolicy;
1163    certificates?: RTCCertificate[];
1164    iceCandidatePoolSize?: number;
1165    iceServers?: RTCIceServer[];
1166    iceTransportPolicy?: RTCIceTransportPolicy;
1167    peerIdentity?: string;
1168    rtcpMuxPolicy?: RTCRtcpMuxPolicy;
1169}
1170
1171interface RTCDTMFToneChangeEventInit extends EventInit {
1172    tone: string;
1173}
1174
1175interface RTCDataChannelEventInit extends EventInit {
1176    channel: RTCDataChannel;
1177}
1178
1179interface RTCDataChannelInit {
1180    id?: number;
1181    maxPacketLifeTime?: number;
1182    maxRetransmits?: number;
1183    negotiated?: boolean;
1184    ordered?: boolean;
1185    priority?: RTCPriorityType;
1186    protocol?: string;
1187}
1188
1189interface RTCDtlsFingerprint {
1190    algorithm?: string;
1191    value?: string;
1192}
1193
1194interface RTCDtlsParameters {
1195    fingerprints?: RTCDtlsFingerprint[];
1196    role?: RTCDtlsRole;
1197}
1198
1199interface RTCErrorEventInit extends EventInit {
1200    error?: RTCError | null;
1201}
1202
1203interface RTCIceCandidateAttributes extends RTCStats {
1204    addressSourceUrl?: string;
1205    candidateType?: RTCStatsIceCandidateType;
1206    ipAddress?: string;
1207    portNumber?: number;
1208    priority?: number;
1209    transport?: string;
1210}
1211
1212interface RTCIceCandidateComplete {
1213}
1214
1215interface RTCIceCandidateDictionary {
1216    foundation?: string;
1217    ip?: string;
1218    msMTurnSessionId?: string;
1219    port?: number;
1220    priority?: number;
1221    protocol?: RTCIceProtocol;
1222    relatedAddress?: string;
1223    relatedPort?: number;
1224    tcpType?: RTCIceTcpCandidateType;
1225    type?: RTCIceCandidateType;
1226}
1227
1228interface RTCIceCandidateInit {
1229    candidate?: string;
1230    sdpMLineIndex?: number | null;
1231    sdpMid?: string | null;
1232    usernameFragment?: string;
1233}
1234
1235interface RTCIceCandidatePair {
1236    local?: RTCIceCandidate;
1237    remote?: RTCIceCandidate;
1238}
1239
1240interface RTCIceCandidatePairStats extends RTCStats {
1241    availableIncomingBitrate?: number;
1242    availableOutgoingBitrate?: number;
1243    bytesReceived?: number;
1244    bytesSent?: number;
1245    localCandidateId?: string;
1246    nominated?: boolean;
1247    priority?: number;
1248    readable?: boolean;
1249    remoteCandidateId?: string;
1250    roundTripTime?: number;
1251    state?: RTCStatsIceCandidatePairState;
1252    transportId?: string;
1253    writable?: boolean;
1254}
1255
1256interface RTCIceGatherOptions {
1257    gatherPolicy?: RTCIceGatherPolicy;
1258    iceservers?: RTCIceServer[];
1259}
1260
1261interface RTCIceParameters {
1262    password?: string;
1263    usernameFragment?: string;
1264}
1265
1266interface RTCIceServer {
1267    credential?: string | RTCOAuthCredential;
1268    credentialType?: RTCIceCredentialType;
1269    urls: string | string[];
1270    username?: string;
1271}
1272
1273interface RTCIdentityProviderOptions {
1274    peerIdentity?: string;
1275    protocol?: string;
1276    usernameHint?: string;
1277}
1278
1279interface RTCInboundRTPStreamStats extends RTCRTPStreamStats {
1280    bytesReceived?: number;
1281    fractionLost?: number;
1282    jitter?: number;
1283    packetsLost?: number;
1284    packetsReceived?: number;
1285}
1286
1287interface RTCMediaStreamTrackStats extends RTCStats {
1288    audioLevel?: number;
1289    echoReturnLoss?: number;
1290    echoReturnLossEnhancement?: number;
1291    frameHeight?: number;
1292    frameWidth?: number;
1293    framesCorrupted?: number;
1294    framesDecoded?: number;
1295    framesDropped?: number;
1296    framesPerSecond?: number;
1297    framesReceived?: number;
1298    framesSent?: number;
1299    remoteSource?: boolean;
1300    ssrcIds?: string[];
1301    trackIdentifier?: string;
1302}
1303
1304interface RTCOAuthCredential {
1305    accessToken: string;
1306    macKey: string;
1307}
1308
1309interface RTCOfferAnswerOptions {
1310    voiceActivityDetection?: boolean;
1311}
1312
1313interface RTCOfferOptions extends RTCOfferAnswerOptions {
1314    iceRestart?: boolean;
1315    offerToReceiveAudio?: boolean;
1316    offerToReceiveVideo?: boolean;
1317}
1318
1319interface RTCOutboundRTPStreamStats extends RTCRTPStreamStats {
1320    bytesSent?: number;
1321    packetsSent?: number;
1322    roundTripTime?: number;
1323    targetBitrate?: number;
1324}
1325
1326interface RTCPeerConnectionIceErrorEventInit extends EventInit {
1327    errorCode: number;
1328    hostCandidate?: string;
1329    statusText?: string;
1330    url?: string;
1331}
1332
1333interface RTCPeerConnectionIceEventInit extends EventInit {
1334    candidate?: RTCIceCandidate | null;
1335    url?: string | null;
1336}
1337
1338interface RTCRTPStreamStats extends RTCStats {
1339    associateStatsId?: string;
1340    codecId?: string;
1341    firCount?: number;
1342    isRemote?: boolean;
1343    mediaTrackId?: string;
1344    mediaType?: string;
1345    nackCount?: number;
1346    pliCount?: number;
1347    sliCount?: number;
1348    ssrc?: string;
1349    transportId?: string;
1350}
1351
1352interface RTCRtcpFeedback {
1353    parameter?: string;
1354    type?: string;
1355}
1356
1357interface RTCRtcpParameters {
1358    cname?: string;
1359    reducedSize?: boolean;
1360}
1361
1362interface RTCRtpCapabilities {
1363    codecs: RTCRtpCodecCapability[];
1364    headerExtensions: RTCRtpHeaderExtensionCapability[];
1365}
1366
1367interface RTCRtpCodecCapability {
1368    channels?: number;
1369    clockRate: number;
1370    mimeType: string;
1371    sdpFmtpLine?: string;
1372}
1373
1374interface RTCRtpCodecParameters {
1375    channels?: number;
1376    clockRate: number;
1377    mimeType: string;
1378    payloadType: number;
1379    sdpFmtpLine?: string;
1380}
1381
1382interface RTCRtpCodingParameters {
1383    rid?: string;
1384}
1385
1386interface RTCRtpContributingSource {
1387    audioLevel?: number;
1388    source: number;
1389    timestamp: number;
1390}
1391
1392interface RTCRtpDecodingParameters extends RTCRtpCodingParameters {
1393}
1394
1395interface RTCRtpEncodingParameters extends RTCRtpCodingParameters {
1396    active?: boolean;
1397    codecPayloadType?: number;
1398    dtx?: RTCDtxStatus;
1399    maxBitrate?: number;
1400    maxFramerate?: number;
1401    priority?: RTCPriorityType;
1402    ptime?: number;
1403    scaleResolutionDownBy?: number;
1404}
1405
1406interface RTCRtpFecParameters {
1407    mechanism?: string;
1408    ssrc?: number;
1409}
1410
1411interface RTCRtpHeaderExtension {
1412    kind?: string;
1413    preferredEncrypt?: boolean;
1414    preferredId?: number;
1415    uri?: string;
1416}
1417
1418interface RTCRtpHeaderExtensionCapability {
1419    uri?: string;
1420}
1421
1422interface RTCRtpHeaderExtensionParameters {
1423    encrypted?: boolean;
1424    id: number;
1425    uri: string;
1426}
1427
1428interface RTCRtpParameters {
1429    codecs: RTCRtpCodecParameters[];
1430    headerExtensions: RTCRtpHeaderExtensionParameters[];
1431    rtcp: RTCRtcpParameters;
1432}
1433
1434interface RTCRtpReceiveParameters extends RTCRtpParameters {
1435    encodings: RTCRtpDecodingParameters[];
1436}
1437
1438interface RTCRtpRtxParameters {
1439    ssrc?: number;
1440}
1441
1442interface RTCRtpSendParameters extends RTCRtpParameters {
1443    degradationPreference?: RTCDegradationPreference;
1444    encodings: RTCRtpEncodingParameters[];
1445    transactionId: string;
1446}
1447
1448interface RTCRtpSynchronizationSource extends RTCRtpContributingSource {
1449    voiceActivityFlag?: boolean;
1450}
1451
1452interface RTCRtpTransceiverInit {
1453    direction?: RTCRtpTransceiverDirection;
1454    sendEncodings?: RTCRtpEncodingParameters[];
1455    streams?: MediaStream[];
1456}
1457
1458interface RTCRtpUnhandled {
1459    muxId?: string;
1460    payloadType?: number;
1461    ssrc?: number;
1462}
1463
1464interface RTCSessionDescriptionInit {
1465    sdp?: string;
1466    type: RTCSdpType;
1467}
1468
1469interface RTCSrtpKeyParam {
1470    keyMethod?: string;
1471    keySalt?: string;
1472    lifetime?: string;
1473    mkiLength?: number;
1474    mkiValue?: number;
1475}
1476
1477interface RTCSrtpSdesParameters {
1478    cryptoSuite?: string;
1479    keyParams?: RTCSrtpKeyParam[];
1480    sessionParams?: string[];
1481    tag?: number;
1482}
1483
1484interface RTCSsrcRange {
1485    max?: number;
1486    min?: number;
1487}
1488
1489interface RTCStats {
1490    id: string;
1491    timestamp: number;
1492    type: RTCStatsType;
1493}
1494
1495interface RTCStatsEventInit extends EventInit {
1496    report: RTCStatsReport;
1497}
1498
1499interface RTCStatsReport {
1500}
1501
1502interface RTCTrackEventInit extends EventInit {
1503    receiver: RTCRtpReceiver;
1504    streams?: MediaStream[];
1505    track: MediaStreamTrack;
1506    transceiver: RTCRtpTransceiver;
1507}
1508
1509interface RTCTransportStats extends RTCStats {
1510    activeConnection?: boolean;
1511    bytesReceived?: number;
1512    bytesSent?: number;
1513    localCertificateId?: string;
1514    remoteCertificateId?: string;
1515    rtcpTransportStatsId?: string;
1516    selectedCandidatePairId?: string;
1517}
1518
1519interface RegistrationOptions {
1520    scope?: string;
1521    type?: WorkerType;
1522    updateViaCache?: ServiceWorkerUpdateViaCache;
1523}
1524
1525interface RequestInit {
1526    /**
1527     * A BodyInit object or null to set request's body.
1528     */
1529    body?: BodyInit | null;
1530    /**
1531     * A string indicating how the request will interact with the browser's cache to set request's cache.
1532     */
1533    cache?: RequestCache;
1534    /**
1535     * A string indicating whether credentials will be sent with the request always, never, or only when sent to a same-origin URL. Sets request's credentials.
1536     */
1537    credentials?: RequestCredentials;
1538    /**
1539     * A Headers object, an object literal, or an array of two-item arrays to set request's headers.
1540     */
1541    headers?: HeadersInit;
1542    /**
1543     * A cryptographic hash of the resource to be fetched by request. Sets request's integrity.
1544     */
1545    integrity?: string;
1546    /**
1547     * A boolean to set request's keepalive.
1548     */
1549    keepalive?: boolean;
1550    /**
1551     * A string to set request's method.
1552     */
1553    method?: string;
1554    /**
1555     * A string to indicate whether the request will use CORS, or will be restricted to same-origin URLs. Sets request's mode.
1556     */
1557    mode?: RequestMode;
1558    /**
1559     * A string indicating whether request follows redirects, results in an error upon encountering a redirect, or returns the redirect (in an opaque fashion). Sets request's redirect.
1560     */
1561    redirect?: RequestRedirect;
1562    /**
1563     * A string whose value is a same-origin URL, "about:client", or the empty string, to set request's referrer.
1564     */
1565    referrer?: string;
1566    /**
1567     * A referrer policy to set request's referrerPolicy.
1568     */
1569    referrerPolicy?: ReferrerPolicy;
1570    /**
1571     * An AbortSignal to set request's signal.
1572     */
1573    signal?: AbortSignal | null;
1574    /**
1575     * Can only be null. Used to disassociate request from any Window.
1576     */
1577    window?: any;
1578}
1579
1580interface ResponseInit {
1581    headers?: HeadersInit;
1582    status?: number;
1583    statusText?: string;
1584}
1585
1586interface RsaHashedImportParams extends Algorithm {
1587    hash: HashAlgorithmIdentifier;
1588}
1589
1590interface RsaHashedKeyAlgorithm extends RsaKeyAlgorithm {
1591    hash: KeyAlgorithm;
1592}
1593
1594interface RsaHashedKeyGenParams extends RsaKeyGenParams {
1595    hash: HashAlgorithmIdentifier;
1596}
1597
1598interface RsaKeyAlgorithm extends KeyAlgorithm {
1599    modulusLength: number;
1600    publicExponent: BigInteger;
1601}
1602
1603interface RsaKeyGenParams extends Algorithm {
1604    modulusLength: number;
1605    publicExponent: BigInteger;
1606}
1607
1608interface RsaOaepParams extends Algorithm {
1609    label?: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;
1610}
1611
1612interface RsaOtherPrimesInfo {
1613    d?: string;
1614    r?: string;
1615    t?: string;
1616}
1617
1618interface RsaPssParams extends Algorithm {
1619    saltLength: number;
1620}
1621
1622interface SVGBoundingBoxOptions {
1623    clipped?: boolean;
1624    fill?: boolean;
1625    markers?: boolean;
1626    stroke?: boolean;
1627}
1628
1629interface ScopedCredentialDescriptor {
1630    id: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer | null;
1631    transports?: Transport[];
1632    type: ScopedCredentialType;
1633}
1634
1635interface ScopedCredentialOptions {
1636    excludeList?: ScopedCredentialDescriptor[];
1637    extensions?: WebAuthnExtensions;
1638    rpId?: string;
1639    timeoutSeconds?: number;
1640}
1641
1642interface ScopedCredentialParameters {
1643    algorithm: string | Algorithm;
1644    type: ScopedCredentialType;
1645}
1646
1647interface ScrollIntoViewOptions extends ScrollOptions {
1648    block?: ScrollLogicalPosition;
1649    inline?: ScrollLogicalPosition;
1650}
1651
1652interface ScrollOptions {
1653    behavior?: ScrollBehavior;
1654}
1655
1656interface ScrollToOptions extends ScrollOptions {
1657    left?: number;
1658    top?: number;
1659}
1660
1661interface SecurityPolicyViolationEventInit extends EventInit {
1662    blockedURI?: string;
1663    columnNumber?: number;
1664    documentURI?: string;
1665    effectiveDirective?: string;
1666    lineNumber?: number;
1667    originalPolicy?: string;
1668    referrer?: string;
1669    sourceFile?: string;
1670    statusCode?: number;
1671    violatedDirective?: string;
1672}
1673
1674interface ServiceWorkerMessageEventInit extends EventInit {
1675    data?: any;
1676    lastEventId?: string;
1677    origin?: string;
1678    ports?: MessagePort[] | null;
1679    source?: ServiceWorker | MessagePort | null;
1680}
1681
1682interface ShadowRootInit {
1683    delegatesFocus?: boolean;
1684    mode: ShadowRootMode;
1685}
1686
1687interface StereoPannerOptions extends AudioNodeOptions {
1688    pan?: number;
1689}
1690
1691interface StorageEstimate {
1692    quota?: number;
1693    usage?: number;
1694}
1695
1696interface StorageEventInit extends EventInit {
1697    key?: string | null;
1698    newValue?: string | null;
1699    oldValue?: string | null;
1700    storageArea?: Storage | null;
1701    url?: string;
1702}
1703
1704interface StoreExceptionsInformation extends ExceptionInformation {
1705    detailURI?: string | null;
1706    explanationString?: string | null;
1707    siteName?: string | null;
1708}
1709
1710interface StoreSiteSpecificExceptionsInformation extends StoreExceptionsInformation {
1711    arrayOfDomainStrings?: string[];
1712}
1713
1714interface TextDecodeOptions {
1715    stream?: boolean;
1716}
1717
1718interface TextDecoderOptions {
1719    fatal?: boolean;
1720    ignoreBOM?: boolean;
1721}
1722
1723interface TextEncoderEncodeIntoResult {
1724    read?: number;
1725    written?: number;
1726}
1727
1728interface TouchEventInit extends EventModifierInit {
1729    changedTouches?: Touch[];
1730    targetTouches?: Touch[];
1731    touches?: Touch[];
1732}
1733
1734interface TouchInit {
1735    altitudeAngle?: number;
1736    azimuthAngle?: number;
1737    clientX?: number;
1738    clientY?: number;
1739    force?: number;
1740    identifier: number;
1741    pageX?: number;
1742    pageY?: number;
1743    radiusX?: number;
1744    radiusY?: number;
1745    rotationAngle?: number;
1746    screenX?: number;
1747    screenY?: number;
1748    target: EventTarget;
1749    touchType?: TouchType;
1750}
1751
1752interface TrackEventInit extends EventInit {
1753    track?: VideoTrack | AudioTrack | TextTrack | null;
1754}
1755
1756interface Transformer<I = any, O = any> {
1757    flush?: TransformStreamDefaultControllerCallback<O>;
1758    readableType?: undefined;
1759    start?: TransformStreamDefaultControllerCallback<O>;
1760    transform?: TransformStreamDefaultControllerTransformCallback<I, O>;
1761    writableType?: undefined;
1762}
1763
1764interface TransitionEventInit extends EventInit {
1765    elapsedTime?: number;
1766    propertyName?: string;
1767    pseudoElement?: string;
1768}
1769
1770interface UIEventInit extends EventInit {
1771    detail?: number;
1772    view?: Window | null;
1773}
1774
1775interface ULongRange {
1776    max?: number;
1777    min?: number;
1778}
1779
1780interface UnderlyingByteSource {
1781    autoAllocateChunkSize?: number;
1782    cancel?: ReadableStreamErrorCallback;
1783    pull?: ReadableByteStreamControllerCallback;
1784    start?: ReadableByteStreamControllerCallback;
1785    type: "bytes";
1786}
1787
1788interface UnderlyingSink<W = any> {
1789    abort?: WritableStreamErrorCallback;
1790    close?: WritableStreamDefaultControllerCloseCallback;
1791    start?: WritableStreamDefaultControllerStartCallback;
1792    type?: undefined;
1793    write?: WritableStreamDefaultControllerWriteCallback<W>;
1794}
1795
1796interface UnderlyingSource<R = any> {
1797    cancel?: ReadableStreamErrorCallback;
1798    pull?: ReadableStreamDefaultControllerCallback<R>;
1799    start?: ReadableStreamDefaultControllerCallback<R>;
1800    type?: undefined;
1801}
1802
1803interface VRDisplayEventInit extends EventInit {
1804    display: VRDisplay;
1805    reason?: VRDisplayEventReason;
1806}
1807
1808interface VRLayer {
1809    leftBounds?: number[] | Float32Array | null;
1810    rightBounds?: number[] | Float32Array | null;
1811    source?: HTMLCanvasElement | null;
1812}
1813
1814interface VRStageParameters {
1815    sittingToStandingTransform?: Float32Array;
1816    sizeX?: number;
1817    sizeY?: number;
1818}
1819
1820interface WaveShaperOptions extends AudioNodeOptions {
1821    curve?: number[] | Float32Array;
1822    oversample?: OverSampleType;
1823}
1824
1825interface WebAuthnExtensions {
1826}
1827
1828interface WebGLContextAttributes {
1829    alpha?: boolean;
1830    antialias?: boolean;
1831    depth?: boolean;
1832    desynchronized?: boolean;
1833    failIfMajorPerformanceCaveat?: boolean;
1834    powerPreference?: WebGLPowerPreference;
1835    premultipliedAlpha?: boolean;
1836    preserveDrawingBuffer?: boolean;
1837    stencil?: boolean;
1838}
1839
1840interface WebGLContextEventInit extends EventInit {
1841    statusMessage?: string;
1842}
1843
1844interface WheelEventInit extends MouseEventInit {
1845    deltaMode?: number;
1846    deltaX?: number;
1847    deltaY?: number;
1848    deltaZ?: number;
1849}
1850
1851interface WorkerOptions {
1852    credentials?: RequestCredentials;
1853    name?: string;
1854    type?: WorkerType;
1855}
1856
1857interface WorkletOptions {
1858    credentials?: RequestCredentials;
1859}
1860
1861interface txAuthGenericArg {
1862    content: ArrayBuffer;
1863    contentType: string;
1864}
1865
1866interface EventListener {
1867    (evt: Event): void;
1868}
1869
1870type XPathNSResolver = ((prefix: string | null) => string | null) | { lookupNamespaceURI(prefix: string | null): string | null; };
1871
1872/** The ANGLE_instanced_arrays extension is part of the WebGL API and allows to draw the same object, or groups of similar objects multiple times, if they share the same vertex data, primitive count and type. */
1873interface ANGLE_instanced_arrays {
1874    drawArraysInstancedANGLE(mode: GLenum, first: GLint, count: GLsizei, primcount: GLsizei): void;
1875    drawElementsInstancedANGLE(mode: GLenum, count: GLsizei, type: GLenum, offset: GLintptr, primcount: GLsizei): void;
1876    vertexAttribDivisorANGLE(index: GLuint, divisor: GLuint): void;
1877    readonly VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE: GLenum;
1878}
1879
1880/** A controller object that allows you to abort one or more DOM requests as and when desired. */
1881interface AbortController {
1882    /**
1883     * Returns the AbortSignal object associated with this object.
1884     */
1885    readonly signal: AbortSignal;
1886    /**
1887     * Invoking this method will set this object's AbortSignal's aborted flag and signal to any observers that the associated activity is to be aborted.
1888     */
1889    abort(): void;
1890}
1891
1892declare var AbortController: {
1893    prototype: AbortController;
1894    new(): AbortController;
1895};
1896
1897interface AbortSignalEventMap {
1898    "abort": Event;
1899}
1900
1901/** A signal object that allows you to communicate with a DOM request (such as a Fetch) and abort it if required via an AbortController object. */
1902interface AbortSignal extends EventTarget {
1903    /**
1904     * Returns true if this AbortSignal's AbortController has signaled to abort, and false otherwise.
1905     */
1906    readonly aborted: boolean;
1907    onabort: ((this: AbortSignal, ev: Event) => any) | null;
1908    addEventListener<K extends keyof AbortSignalEventMap>(type: K, listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
1909    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
1910    removeEventListener<K extends keyof AbortSignalEventMap>(type: K, listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
1911    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
1912}
1913
1914declare var AbortSignal: {
1915    prototype: AbortSignal;
1916    new(): AbortSignal;
1917};
1918
1919interface AbstractRange {
1920    /**
1921     * Returns true if range is collapsed, and false otherwise.
1922     */
1923    readonly collapsed: boolean;
1924    /**
1925     * Returns range's end node.
1926     */
1927    readonly endContainer: Node;
1928    /**
1929     * Returns range's end offset.
1930     */
1931    readonly endOffset: number;
1932    /**
1933     * Returns range's start node.
1934     */
1935    readonly startContainer: Node;
1936    /**
1937     * Returns range's start offset.
1938     */
1939    readonly startOffset: number;
1940}
1941
1942declare var AbstractRange: {
1943    prototype: AbstractRange;
1944    new(): AbstractRange;
1945};
1946
1947interface AbstractWorkerEventMap {
1948    "error": ErrorEvent;
1949}
1950
1951interface AbstractWorker {
1952    onerror: ((this: AbstractWorker, ev: ErrorEvent) => any) | null;
1953    addEventListener<K extends keyof AbstractWorkerEventMap>(type: K, listener: (this: AbstractWorker, ev: AbstractWorkerEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
1954    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
1955    removeEventListener<K extends keyof AbstractWorkerEventMap>(type: K, listener: (this: AbstractWorker, ev: AbstractWorkerEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
1956    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
1957}
1958
1959interface AesCfbParams extends Algorithm {
1960    iv: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;
1961}
1962
1963interface AesCmacParams extends Algorithm {
1964    length: number;
1965}
1966
1967/** A node able to provide real-time frequency and time-domain analysis information. It is an AudioNode that passes the audio stream unchanged from the input to the output, but allows you to take the generated data, process it, and create audio visualizations. */
1968interface AnalyserNode extends AudioNode {
1969    fftSize: number;
1970    readonly frequencyBinCount: number;
1971    maxDecibels: number;
1972    minDecibels: number;
1973    smoothingTimeConstant: number;
1974    getByteFrequencyData(array: Uint8Array): void;
1975    getByteTimeDomainData(array: Uint8Array): void;
1976    getFloatFrequencyData(array: Float32Array): void;
1977    getFloatTimeDomainData(array: Float32Array): void;
1978}
1979
1980declare var AnalyserNode: {
1981    prototype: AnalyserNode;
1982    new(context: BaseAudioContext, options?: AnalyserOptions): AnalyserNode;
1983};
1984
1985interface Animatable {
1986    animate(keyframes: Keyframe[] | PropertyIndexedKeyframes | null, options?: number | KeyframeAnimationOptions): Animation;
1987    getAnimations(): Animation[];
1988}
1989
1990interface AnimationEventMap {
1991    "cancel": AnimationPlaybackEvent;
1992    "finish": AnimationPlaybackEvent;
1993}
1994
1995interface Animation extends EventTarget {
1996    currentTime: number | null;
1997    effect: AnimationEffect | null;
1998    readonly finished: Promise<Animation>;
1999    id: string;
2000    oncancel: ((this: Animation, ev: AnimationPlaybackEvent) => any) | null;
2001    onfinish: ((this: Animation, ev: AnimationPlaybackEvent) => any) | null;
2002    readonly pending: boolean;
2003    readonly playState: AnimationPlayState;
2004    playbackRate: number;
2005    readonly ready: Promise<Animation>;
2006    startTime: number | null;
2007    timeline: AnimationTimeline | null;
2008    cancel(): void;
2009    finish(): void;
2010    pause(): void;
2011    play(): void;
2012    reverse(): void;
2013    updatePlaybackRate(playbackRate: number): void;
2014    addEventListener<K extends keyof AnimationEventMap>(type: K, listener: (this: Animation, ev: AnimationEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
2015    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
2016    removeEventListener<K extends keyof AnimationEventMap>(type: K, listener: (this: Animation, ev: AnimationEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
2017    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
2018}
2019
2020declare var Animation: {
2021    prototype: Animation;
2022    new(effect?: AnimationEffect | null, timeline?: AnimationTimeline | null): Animation;
2023};
2024
2025interface AnimationEffect {
2026    getComputedTiming(): ComputedEffectTiming;
2027    getTiming(): EffectTiming;
2028    updateTiming(timing?: OptionalEffectTiming): void;
2029}
2030
2031declare var AnimationEffect: {
2032    prototype: AnimationEffect;
2033    new(): AnimationEffect;
2034};
2035
2036/** Events providing information related to animations. */
2037interface AnimationEvent extends Event {
2038    readonly animationName: string;
2039    readonly elapsedTime: number;
2040    readonly pseudoElement: string;
2041}
2042
2043declare var AnimationEvent: {
2044    prototype: AnimationEvent;
2045    new(type: string, animationEventInitDict?: AnimationEventInit): AnimationEvent;
2046};
2047
2048interface AnimationFrameProvider {
2049    cancelAnimationFrame(handle: number): void;
2050    requestAnimationFrame(callback: FrameRequestCallback): number;
2051}
2052
2053interface AnimationPlaybackEvent extends Event {
2054    readonly currentTime: number | null;
2055    readonly timelineTime: number | null;
2056}
2057
2058declare var AnimationPlaybackEvent: {
2059    prototype: AnimationPlaybackEvent;
2060    new(type: string, eventInitDict?: AnimationPlaybackEventInit): AnimationPlaybackEvent;
2061};
2062
2063interface AnimationTimeline {
2064    readonly currentTime: number | null;
2065}
2066
2067declare var AnimationTimeline: {
2068    prototype: AnimationTimeline;
2069    new(): AnimationTimeline;
2070};
2071
2072interface ApplicationCacheEventMap {
2073    "cached": Event;
2074    "checking": Event;
2075    "downloading": Event;
2076    "error": Event;
2077    "noupdate": Event;
2078    "obsolete": Event;
2079    "progress": ProgressEvent<ApplicationCache>;
2080    "updateready": Event;
2081}
2082
2083interface ApplicationCache extends EventTarget {
2084    /** @deprecated */
2085    oncached: ((this: ApplicationCache, ev: Event) => any) | null;
2086    /** @deprecated */
2087    onchecking: ((this: ApplicationCache, ev: Event) => any) | null;
2088    /** @deprecated */
2089    ondownloading: ((this: ApplicationCache, ev: Event) => any) | null;
2090    /** @deprecated */
2091    onerror: ((this: ApplicationCache, ev: Event) => any) | null;
2092    /** @deprecated */
2093    onnoupdate: ((this: ApplicationCache, ev: Event) => any) | null;
2094    /** @deprecated */
2095    onobsolete: ((this: ApplicationCache, ev: Event) => any) | null;
2096    /** @deprecated */
2097    onprogress: ((this: ApplicationCache, ev: ProgressEvent<ApplicationCache>) => any) | null;
2098    /** @deprecated */
2099    onupdateready: ((this: ApplicationCache, ev: Event) => any) | null;
2100    /** @deprecated */
2101    readonly status: number;
2102    /** @deprecated */
2103    abort(): void;
2104    /** @deprecated */
2105    swapCache(): void;
2106    /** @deprecated */
2107    update(): void;
2108    readonly CHECKING: number;
2109    readonly DOWNLOADING: number;
2110    readonly IDLE: number;
2111    readonly OBSOLETE: number;
2112    readonly UNCACHED: number;
2113    readonly UPDATEREADY: number;
2114    addEventListener<K extends keyof ApplicationCacheEventMap>(type: K, listener: (this: ApplicationCache, ev: ApplicationCacheEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
2115    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
2116    removeEventListener<K extends keyof ApplicationCacheEventMap>(type: K, listener: (this: ApplicationCache, ev: ApplicationCacheEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
2117    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
2118}
2119
2120declare var ApplicationCache: {
2121    prototype: ApplicationCache;
2122    new(): ApplicationCache;
2123    readonly CHECKING: number;
2124    readonly DOWNLOADING: number;
2125    readonly IDLE: number;
2126    readonly OBSOLETE: number;
2127    readonly UNCACHED: number;
2128    readonly UPDATEREADY: number;
2129};
2130
2131/** A DOM element's attribute as an object. In most DOM methods, you will probably directly retrieve the attribute as a string (e.g., Element.getAttribute(), but certain functions (e.g., Element.getAttributeNode()) or means of iterating give Attr types. */
2132interface Attr extends Node {
2133    readonly localName: string;
2134    readonly name: string;
2135    readonly namespaceURI: string | null;
2136    readonly ownerElement: Element | null;
2137    readonly prefix: string | null;
2138    readonly specified: boolean;
2139    value: string;
2140}
2141
2142declare var Attr: {
2143    prototype: Attr;
2144    new(): Attr;
2145};
2146
2147/** A short audio asset residing in memory, created from an audio file using the AudioContext.decodeAudioData() method, or from raw data using AudioContext.createBuffer(). Once put into an AudioBuffer, the audio can then be played by being passed into an AudioBufferSourceNode. */
2148interface AudioBuffer {
2149    readonly duration: number;
2150    readonly length: number;
2151    readonly numberOfChannels: number;
2152    readonly sampleRate: number;
2153    copyFromChannel(destination: Float32Array, channelNumber: number, startInChannel?: number): void;
2154    copyToChannel(source: Float32Array, channelNumber: number, startInChannel?: number): void;
2155    getChannelData(channel: number): Float32Array;
2156}
2157
2158declare var AudioBuffer: {
2159    prototype: AudioBuffer;
2160    new(options: AudioBufferOptions): AudioBuffer;
2161};
2162
2163/** An AudioScheduledSourceNode which represents an audio source consisting of in-memory audio data, stored in an AudioBuffer. It's especially useful for playing back audio which has particularly stringent timing accuracy requirements, such as for sounds that must match a specific rhythm and can be kept in memory rather than being played from disk or the network. */
2164interface AudioBufferSourceNode extends AudioScheduledSourceNode {
2165    buffer: AudioBuffer | null;
2166    readonly detune: AudioParam;
2167    loop: boolean;
2168    loopEnd: number;
2169    loopStart: number;
2170    readonly playbackRate: AudioParam;
2171    start(when?: number, offset?: number, duration?: number): void;
2172    addEventListener<K extends keyof AudioScheduledSourceNodeEventMap>(type: K, listener: (this: AudioBufferSourceNode, ev: AudioScheduledSourceNodeEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
2173    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
2174    removeEventListener<K extends keyof AudioScheduledSourceNodeEventMap>(type: K, listener: (this: AudioBufferSourceNode, ev: AudioScheduledSourceNodeEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
2175    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
2176}
2177
2178declare var AudioBufferSourceNode: {
2179    prototype: AudioBufferSourceNode;
2180    new(context: BaseAudioContext, options?: AudioBufferSourceOptions): AudioBufferSourceNode;
2181};
2182
2183/** An audio-processing graph built from audio modules linked together, each represented by an AudioNode. */
2184interface AudioContext extends BaseAudioContext {
2185    readonly baseLatency: number;
2186    readonly outputLatency: number;
2187    close(): Promise<void>;
2188    createMediaElementSource(mediaElement: HTMLMediaElement): MediaElementAudioSourceNode;
2189    createMediaStreamDestination(): MediaStreamAudioDestinationNode;
2190    createMediaStreamSource(mediaStream: MediaStream): MediaStreamAudioSourceNode;
2191    createMediaStreamTrackSource(mediaStreamTrack: MediaStreamTrack): MediaStreamTrackAudioSourceNode;
2192    getOutputTimestamp(): AudioTimestamp;
2193    resume(): Promise<void>;
2194    suspend(): Promise<void>;
2195    addEventListener<K extends keyof BaseAudioContextEventMap>(type: K, listener: (this: AudioContext, ev: BaseAudioContextEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
2196    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
2197    removeEventListener<K extends keyof BaseAudioContextEventMap>(type: K, listener: (this: AudioContext, ev: BaseAudioContextEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
2198    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
2199}
2200
2201declare var AudioContext: {
2202    prototype: AudioContext;
2203    new(contextOptions?: AudioContextOptions): AudioContext;
2204};
2205
2206/** AudioDestinationNode has no output (as it is the output, no more AudioNode can be linked after it in the audio graph) and one input. The number of channels in the input must be between 0 and the maxChannelCount value or an exception is raised. */
2207interface AudioDestinationNode extends AudioNode {
2208    readonly maxChannelCount: number;
2209}
2210
2211declare var AudioDestinationNode: {
2212    prototype: AudioDestinationNode;
2213    new(): AudioDestinationNode;
2214};
2215
2216/** The position and orientation of the unique person listening to the audio scene, and is used in audio spatialization. All PannerNodes spatialize in relation to the AudioListener stored in the BaseAudioContext.listener attribute. */
2217interface AudioListener {
2218    readonly forwardX: AudioParam;
2219    readonly forwardY: AudioParam;
2220    readonly forwardZ: AudioParam;
2221    readonly positionX: AudioParam;
2222    readonly positionY: AudioParam;
2223    readonly positionZ: AudioParam;
2224    readonly upX: AudioParam;
2225    readonly upY: AudioParam;
2226    readonly upZ: AudioParam;
2227    /** @deprecated */
2228    setOrientation(x: number, y: number, z: number, xUp: number, yUp: number, zUp: number): void;
2229    /** @deprecated */
2230    setPosition(x: number, y: number, z: number): void;
2231}
2232
2233declare var AudioListener: {
2234    prototype: AudioListener;
2235    new(): AudioListener;
2236};
2237
2238/** A generic interface for representing an audio processing module. Examples include: */
2239interface AudioNode extends EventTarget {
2240    channelCount: number;
2241    channelCountMode: ChannelCountMode;
2242    channelInterpretation: ChannelInterpretation;
2243    readonly context: BaseAudioContext;
2244    readonly numberOfInputs: number;
2245    readonly numberOfOutputs: number;
2246    connect(destinationNode: AudioNode, output?: number, input?: number): AudioNode;
2247    connect(destinationParam: AudioParam, output?: number): void;
2248    disconnect(): void;
2249    disconnect(output: number): void;
2250    disconnect(destinationNode: AudioNode): void;
2251    disconnect(destinationNode: AudioNode, output: number): void;
2252    disconnect(destinationNode: AudioNode, output: number, input: number): void;
2253    disconnect(destinationParam: AudioParam): void;
2254    disconnect(destinationParam: AudioParam, output: number): void;
2255}
2256
2257declare var AudioNode: {
2258    prototype: AudioNode;
2259    new(): AudioNode;
2260};
2261
2262/** The Web Audio API's AudioParam interface represents an audio-related parameter, usually a parameter of an AudioNode (such as GainNode.gain). */
2263interface AudioParam {
2264    automationRate: AutomationRate;
2265    readonly defaultValue: number;
2266    readonly maxValue: number;
2267    readonly minValue: number;
2268    value: number;
2269    cancelAndHoldAtTime(cancelTime: number): AudioParam;
2270    cancelScheduledValues(cancelTime: number): AudioParam;
2271    exponentialRampToValueAtTime(value: number, endTime: number): AudioParam;
2272    linearRampToValueAtTime(value: number, endTime: number): AudioParam;
2273    setTargetAtTime(target: number, startTime: number, timeConstant: number): AudioParam;
2274    setValueAtTime(value: number, startTime: number): AudioParam;
2275    setValueCurveAtTime(values: number[] | Float32Array, startTime: number, duration: number): AudioParam;
2276}
2277
2278declare var AudioParam: {
2279    prototype: AudioParam;
2280    new(): AudioParam;
2281};
2282
2283interface AudioParamMap {
2284    forEach(callbackfn: (value: AudioParam, key: string, parent: AudioParamMap) => void, thisArg?: any): void;
2285}
2286
2287declare var AudioParamMap: {
2288    prototype: AudioParamMap;
2289    new(): AudioParamMap;
2290};
2291
2292/** The Web Audio API events that occur when a ScriptProcessorNode input buffer is ready to be processed. */
2293interface AudioProcessingEvent extends Event {
2294    readonly inputBuffer: AudioBuffer;
2295    readonly outputBuffer: AudioBuffer;
2296    readonly playbackTime: number;
2297}
2298
2299declare var AudioProcessingEvent: {
2300    prototype: AudioProcessingEvent;
2301    new(type: string, eventInitDict: AudioProcessingEventInit): AudioProcessingEvent;
2302};
2303
2304interface AudioScheduledSourceNodeEventMap {
2305    "ended": Event;
2306}
2307
2308interface AudioScheduledSourceNode extends AudioNode {
2309    onended: ((this: AudioScheduledSourceNode, ev: Event) => any) | null;
2310    start(when?: number): void;
2311    stop(when?: number): void;
2312    addEventListener<K extends keyof AudioScheduledSourceNodeEventMap>(type: K, listener: (this: AudioScheduledSourceNode, ev: AudioScheduledSourceNodeEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
2313    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
2314    removeEventListener<K extends keyof AudioScheduledSourceNodeEventMap>(type: K, listener: (this: AudioScheduledSourceNode, ev: AudioScheduledSourceNodeEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
2315    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
2316}
2317
2318declare var AudioScheduledSourceNode: {
2319    prototype: AudioScheduledSourceNode;
2320    new(): AudioScheduledSourceNode;
2321};
2322
2323/** A single audio track from one of the HTML media elements, <audio> or <video>.  */
2324interface AudioTrack {
2325    enabled: boolean;
2326    readonly id: string;
2327    kind: string;
2328    readonly label: string;
2329    language: string;
2330    readonly sourceBuffer: SourceBuffer | null;
2331}
2332
2333declare var AudioTrack: {
2334    prototype: AudioTrack;
2335    new(): AudioTrack;
2336};
2337
2338interface AudioTrackListEventMap {
2339    "addtrack": TrackEvent;
2340    "change": Event;
2341    "removetrack": TrackEvent;
2342}
2343
2344/** Used to represent a list of the audio tracks contained within a given HTML media element, with each track represented by a separate AudioTrack object in the list. */
2345interface AudioTrackList extends EventTarget {
2346    readonly length: number;
2347    onaddtrack: ((this: AudioTrackList, ev: TrackEvent) => any) | null;
2348    onchange: ((this: AudioTrackList, ev: Event) => any) | null;
2349    onremovetrack: ((this: AudioTrackList, ev: TrackEvent) => any) | null;
2350    getTrackById(id: string): AudioTrack | null;
2351    item(index: number): AudioTrack;
2352    addEventListener<K extends keyof AudioTrackListEventMap>(type: K, listener: (this: AudioTrackList, ev: AudioTrackListEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
2353    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
2354    removeEventListener<K extends keyof AudioTrackListEventMap>(type: K, listener: (this: AudioTrackList, ev: AudioTrackListEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
2355    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
2356    [index: number]: AudioTrack;
2357}
2358
2359declare var AudioTrackList: {
2360    prototype: AudioTrackList;
2361    new(): AudioTrackList;
2362};
2363
2364interface AudioWorklet extends Worklet {
2365}
2366
2367declare var AudioWorklet: {
2368    prototype: AudioWorklet;
2369    new(): AudioWorklet;
2370};
2371
2372interface AudioWorkletNodeEventMap {
2373    "processorerror": Event;
2374}
2375
2376interface AudioWorkletNode extends AudioNode {
2377    onprocessorerror: ((this: AudioWorkletNode, ev: Event) => any) | null;
2378    readonly parameters: AudioParamMap;
2379    readonly port: MessagePort;
2380    addEventListener<K extends keyof AudioWorkletNodeEventMap>(type: K, listener: (this: AudioWorkletNode, ev: AudioWorkletNodeEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
2381    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
2382    removeEventListener<K extends keyof AudioWorkletNodeEventMap>(type: K, listener: (this: AudioWorkletNode, ev: AudioWorkletNodeEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
2383    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
2384}
2385
2386declare var AudioWorkletNode: {
2387    prototype: AudioWorkletNode;
2388    new(context: BaseAudioContext, name: string, options?: AudioWorkletNodeOptions): AudioWorkletNode;
2389};
2390
2391interface AuthenticatorAssertionResponse extends AuthenticatorResponse {
2392    readonly authenticatorData: ArrayBuffer;
2393    readonly signature: ArrayBuffer;
2394    readonly userHandle: ArrayBuffer | null;
2395}
2396
2397declare var AuthenticatorAssertionResponse: {
2398    prototype: AuthenticatorAssertionResponse;
2399    new(): AuthenticatorAssertionResponse;
2400};
2401
2402interface AuthenticatorAttestationResponse extends AuthenticatorResponse {
2403    readonly attestationObject: ArrayBuffer;
2404}
2405
2406declare var AuthenticatorAttestationResponse: {
2407    prototype: AuthenticatorAttestationResponse;
2408    new(): AuthenticatorAttestationResponse;
2409};
2410
2411interface AuthenticatorResponse {
2412    readonly clientDataJSON: ArrayBuffer;
2413}
2414
2415declare var AuthenticatorResponse: {
2416    prototype: AuthenticatorResponse;
2417    new(): AuthenticatorResponse;
2418};
2419
2420interface BarProp {
2421    readonly visible: boolean;
2422}
2423
2424declare var BarProp: {
2425    prototype: BarProp;
2426    new(): BarProp;
2427};
2428
2429interface BaseAudioContextEventMap {
2430    "statechange": Event;
2431}
2432
2433interface BaseAudioContext extends EventTarget {
2434    readonly audioWorklet: AudioWorklet;
2435    readonly currentTime: number;
2436    readonly destination: AudioDestinationNode;
2437    readonly listener: AudioListener;
2438    onstatechange: ((this: BaseAudioContext, ev: Event) => any) | null;
2439    readonly sampleRate: number;
2440    readonly state: AudioContextState;
2441    createAnalyser(): AnalyserNode;
2442    createBiquadFilter(): BiquadFilterNode;
2443    createBuffer(numberOfChannels: number, length: number, sampleRate: number): AudioBuffer;
2444    createBufferSource(): AudioBufferSourceNode;
2445    createChannelMerger(numberOfInputs?: number): ChannelMergerNode;
2446    createChannelSplitter(numberOfOutputs?: number): ChannelSplitterNode;
2447    createConstantSource(): ConstantSourceNode;
2448    createConvolver(): ConvolverNode;
2449    createDelay(maxDelayTime?: number): DelayNode;
2450    createDynamicsCompressor(): DynamicsCompressorNode;
2451    createGain(): GainNode;
2452    createIIRFilter(feedforward: number[], feedback: number[]): IIRFilterNode;
2453    createOscillator(): OscillatorNode;
2454    createPanner(): PannerNode;
2455    createPeriodicWave(real: number[] | Float32Array, imag: number[] | Float32Array, constraints?: PeriodicWaveConstraints): PeriodicWave;
2456    createScriptProcessor(bufferSize?: number, numberOfInputChannels?: number, numberOfOutputChannels?: number): ScriptProcessorNode;
2457    createStereoPanner(): StereoPannerNode;
2458    createWaveShaper(): WaveShaperNode;
2459    decodeAudioData(audioData: ArrayBuffer, successCallback?: DecodeSuccessCallback | null, errorCallback?: DecodeErrorCallback | null): Promise<AudioBuffer>;
2460    addEventListener<K extends keyof BaseAudioContextEventMap>(type: K, listener: (this: BaseAudioContext, ev: BaseAudioContextEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
2461    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
2462    removeEventListener<K extends keyof BaseAudioContextEventMap>(type: K, listener: (this: BaseAudioContext, ev: BaseAudioContextEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
2463    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
2464}
2465
2466declare var BaseAudioContext: {
2467    prototype: BaseAudioContext;
2468    new(): BaseAudioContext;
2469};
2470
2471/** The beforeunload event is fired when the window, the document and its resources are about to be unloaded. */
2472interface BeforeUnloadEvent extends Event {
2473    returnValue: any;
2474}
2475
2476declare var BeforeUnloadEvent: {
2477    prototype: BeforeUnloadEvent;
2478    new(): BeforeUnloadEvent;
2479};
2480
2481interface BhxBrowser {
2482    readonly lastError: DOMException;
2483    checkMatchesGlobExpression(pattern: string, value: string): boolean;
2484    checkMatchesUriExpression(pattern: string, value: string): boolean;
2485    clearLastError(): void;
2486    currentWindowId(): number;
2487    fireExtensionApiTelemetry(functionName: string, isSucceeded: boolean, isSupported: boolean, errorString: string): void;
2488    genericFunction(functionId: number, destination: any, parameters?: string, callbackId?: number): void;
2489    genericSynchronousFunction(functionId: number, parameters?: string): string;
2490    getExtensionId(): string;
2491    getThisAddress(): any;
2492    registerGenericFunctionCallbackHandler(callbackHandler: Function): void;
2493    registerGenericListenerHandler(eventHandler: Function): void;
2494    setLastError(parameters: string): void;
2495    webPlatformGenericFunction(destination: any, parameters?: string, callbackId?: number): void;
2496}
2497
2498declare var BhxBrowser: {
2499    prototype: BhxBrowser;
2500    new(): BhxBrowser;
2501};
2502
2503/** A simple low-order filter, and is created using the AudioContext.createBiquadFilter() method. It is an AudioNode that can represent different kinds of filters, tone control devices, and graphic equalizers. */
2504interface BiquadFilterNode extends AudioNode {
2505    readonly Q: AudioParam;
2506    readonly detune: AudioParam;
2507    readonly frequency: AudioParam;
2508    readonly gain: AudioParam;
2509    type: BiquadFilterType;
2510    getFrequencyResponse(frequencyHz: Float32Array, magResponse: Float32Array, phaseResponse: Float32Array): void;
2511}
2512
2513declare var BiquadFilterNode: {
2514    prototype: BiquadFilterNode;
2515    new(context: BaseAudioContext, options?: BiquadFilterOptions): BiquadFilterNode;
2516};
2517
2518/** A file-like object of immutable, raw data. Blobs represent data that isn't necessarily in a JavaScript-native format. The File interface is based on Blob, inheriting blob functionality and expanding it to support files on the user's system. */
2519interface Blob {
2520    readonly size: number;
2521    readonly type: string;
2522    slice(start?: number, end?: number, contentType?: string): Blob;
2523}
2524
2525declare var Blob: {
2526    prototype: Blob;
2527    new(blobParts?: BlobPart[], options?: BlobPropertyBag): Blob;
2528};
2529
2530interface Body {
2531    readonly body: ReadableStream<Uint8Array> | null;
2532    readonly bodyUsed: boolean;
2533    arrayBuffer(): Promise<ArrayBuffer>;
2534    blob(): Promise<Blob>;
2535    formData(): Promise<FormData>;
2536    json(): Promise<any>;
2537    text(): Promise<string>;
2538}
2539
2540interface BroadcastChannelEventMap {
2541    "message": MessageEvent;
2542    "messageerror": MessageEvent;
2543}
2544
2545interface BroadcastChannel extends EventTarget {
2546    /**
2547     * Returns the channel name (as passed to the constructor).
2548     */
2549    readonly name: string;
2550    onmessage: ((this: BroadcastChannel, ev: MessageEvent) => any) | null;
2551    onmessageerror: ((this: BroadcastChannel, ev: MessageEvent) => any) | null;
2552    /**
2553     * Closes the BroadcastChannel object, opening it up to garbage collection.
2554     */
2555    close(): void;
2556    /**
2557     * Sends the given message to other BroadcastChannel objects set up for this channel. Messages can be structured objects, e.g. nested objects and arrays.
2558     */
2559    postMessage(message: any): void;
2560    addEventListener<K extends keyof BroadcastChannelEventMap>(type: K, listener: (this: BroadcastChannel, ev: BroadcastChannelEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
2561    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
2562    removeEventListener<K extends keyof BroadcastChannelEventMap>(type: K, listener: (this: BroadcastChannel, ev: BroadcastChannelEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
2563    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
2564}
2565
2566declare var BroadcastChannel: {
2567    prototype: BroadcastChannel;
2568    new(name: string): BroadcastChannel;
2569};
2570
2571/** This Streams API interface provides a built-in byte length queuing strategy that can be used when constructing streams. */
2572interface ByteLengthQueuingStrategy extends QueuingStrategy<ArrayBufferView> {
2573    highWaterMark: number;
2574    size(chunk: ArrayBufferView): number;
2575}
2576
2577declare var ByteLengthQueuingStrategy: {
2578    prototype: ByteLengthQueuingStrategy;
2579    new(options: { highWaterMark: number }): ByteLengthQueuingStrategy;
2580};
2581
2582/** A CDATA section that can be used within XML to include extended portions of unescaped text. The symbols < and & don’t need escaping as they normally do when inside a CDATA section. */
2583interface CDATASection extends Text {
2584}
2585
2586declare var CDATASection: {
2587    prototype: CDATASection;
2588    new(): CDATASection;
2589};
2590
2591/** Holds useful CSS-related methods. No object with this interface are implemented: it contains only static methods and therefore is a utilitarian interface. */
2592interface CSS {
2593    escape(value: string): string;
2594    supports(property: string, value?: string): boolean;
2595}
2596declare var CSS: CSS;
2597
2598/** A single condition CSS at-rule, which consists of a condition and a statement block. It is a child of CSSGroupingRule. */
2599interface CSSConditionRule extends CSSGroupingRule {
2600    conditionText: string;
2601}
2602
2603declare var CSSConditionRule: {
2604    prototype: CSSConditionRule;
2605    new(): CSSConditionRule;
2606};
2607
2608interface CSSFontFaceRule extends CSSRule {
2609    readonly style: CSSStyleDeclaration;
2610}
2611
2612declare var CSSFontFaceRule: {
2613    prototype: CSSFontFaceRule;
2614    new(): CSSFontFaceRule;
2615};
2616
2617/** Any CSS at-rule that contains other rules nested within it. */
2618interface CSSGroupingRule extends CSSRule {
2619    readonly cssRules: CSSRuleList;
2620    deleteRule(index: number): void;
2621    insertRule(rule: string, index: number): number;
2622}
2623
2624declare var CSSGroupingRule: {
2625    prototype: CSSGroupingRule;
2626    new(): CSSGroupingRule;
2627};
2628
2629interface CSSImportRule extends CSSRule {
2630    readonly href: string;
2631    readonly media: MediaList;
2632    readonly styleSheet: CSSStyleSheet;
2633}
2634
2635declare var CSSImportRule: {
2636    prototype: CSSImportRule;
2637    new(): CSSImportRule;
2638};
2639
2640/** An object representing a set of style for a given keyframe. It corresponds to the contains of a single keyframe of a @keyframes at-rule. It implements the CSSRule interface with a type value of 8 (CSSRule.KEYFRAME_RULE). */
2641interface CSSKeyframeRule extends CSSRule {
2642    keyText: string;
2643    readonly style: CSSStyleDeclaration;
2644}
2645
2646declare var CSSKeyframeRule: {
2647    prototype: CSSKeyframeRule;
2648    new(): CSSKeyframeRule;
2649};
2650
2651/** An object representing a complete set of keyframes for a CSS animation. It corresponds to the contains of a whole @keyframes at-rule. It implements the CSSRule interface with a type value of 7 (CSSRule.KEYFRAMES_RULE). */
2652interface CSSKeyframesRule extends CSSRule {
2653    readonly cssRules: CSSRuleList;
2654    name: string;
2655    appendRule(rule: string): void;
2656    deleteRule(select: string): void;
2657    findRule(select: string): CSSKeyframeRule | null;
2658}
2659
2660declare var CSSKeyframesRule: {
2661    prototype: CSSKeyframesRule;
2662    new(): CSSKeyframesRule;
2663};
2664
2665/** A single CSS @media rule. It implements the CSSConditionRule interface, and therefore the CSSGroupingRule and the CSSRule interface with a type value of 4 (CSSRule.MEDIA_RULE). */
2666interface CSSMediaRule extends CSSConditionRule {
2667    readonly media: MediaList;
2668}
2669
2670declare var CSSMediaRule: {
2671    prototype: CSSMediaRule;
2672    new(): CSSMediaRule;
2673};
2674
2675/** An object representing a single CSS @namespace at-rule. It implements the CSSRule interface, with a type value of 10 (CSSRule.NAMESPACE_RULE). */
2676interface CSSNamespaceRule extends CSSRule {
2677    readonly namespaceURI: string;
2678    readonly prefix: string;
2679}
2680
2681declare var CSSNamespaceRule: {
2682    prototype: CSSNamespaceRule;
2683    new(): CSSNamespaceRule;
2684};
2685
2686/** CSSPageRule is an interface representing a single CSS @page rule. It implements the CSSRule interface with a type value of 6 (CSSRule.PAGE_RULE). */
2687interface CSSPageRule extends CSSRule {
2688    readonly pseudoClass: string;
2689    readonly selector: string;
2690    selectorText: string;
2691    readonly style: CSSStyleDeclaration;
2692}
2693
2694declare var CSSPageRule: {
2695    prototype: CSSPageRule;
2696    new(): CSSPageRule;
2697};
2698
2699/** A single CSS rule. There are several types of rules, listed in the Type constants section below. */
2700interface CSSRule {
2701    cssText: string;
2702    readonly parentRule: CSSRule | null;
2703    readonly parentStyleSheet: CSSStyleSheet | null;
2704    readonly type: number;
2705    readonly CHARSET_RULE: number;
2706    readonly FONT_FACE_RULE: number;
2707    readonly IMPORT_RULE: number;
2708    readonly KEYFRAMES_RULE: number;
2709    readonly KEYFRAME_RULE: number;
2710    readonly MEDIA_RULE: number;
2711    readonly NAMESPACE_RULE: number;
2712    readonly PAGE_RULE: number;
2713    readonly STYLE_RULE: number;
2714    readonly SUPPORTS_RULE: number;
2715    readonly UNKNOWN_RULE: number;
2716    readonly VIEWPORT_RULE: number;
2717}
2718
2719declare var CSSRule: {
2720    prototype: CSSRule;
2721    new(): CSSRule;
2722    readonly CHARSET_RULE: number;
2723    readonly FONT_FACE_RULE: number;
2724    readonly IMPORT_RULE: number;
2725    readonly KEYFRAMES_RULE: number;
2726    readonly KEYFRAME_RULE: number;
2727    readonly MEDIA_RULE: number;
2728    readonly NAMESPACE_RULE: number;
2729    readonly PAGE_RULE: number;
2730    readonly STYLE_RULE: number;
2731    readonly SUPPORTS_RULE: number;
2732    readonly UNKNOWN_RULE: number;
2733    readonly VIEWPORT_RULE: number;
2734};
2735
2736/** A CSSRuleList is an (indirect-modify only) array-like object containing an ordered collection of CSSRule objects. */
2737interface CSSRuleList {
2738    readonly length: number;
2739    item(index: number): CSSRule | null;
2740    [index: number]: CSSRule;
2741}
2742
2743declare var CSSRuleList: {
2744    prototype: CSSRuleList;
2745    new(): CSSRuleList;
2746};
2747
2748/** An object that is a CSS declaration block, and exposes style information and various style-related methods and properties. */
2749interface CSSStyleDeclaration {
2750    alignContent: string;
2751    alignItems: string;
2752    alignSelf: string;
2753    alignmentBaseline: string;
2754    animation: string;
2755    animationDelay: string;
2756    animationDirection: string;
2757    animationDuration: string;
2758    animationFillMode: string;
2759    animationIterationCount: string;
2760    animationName: string;
2761    animationPlayState: string;
2762    animationTimingFunction: string;
2763    backfaceVisibility: string;
2764    background: string;
2765    backgroundAttachment: string;
2766    backgroundClip: string;
2767    backgroundColor: string;
2768    backgroundImage: string;
2769    backgroundOrigin: string;
2770    backgroundPosition: string;
2771    backgroundPositionX: string;
2772    backgroundPositionY: string;
2773    backgroundRepeat: string;
2774    backgroundSize: string;
2775    baselineShift: string;
2776    blockSize: string;
2777    border: string;
2778    borderBlockEnd: string;
2779    borderBlockEndColor: string;
2780    borderBlockEndStyle: string;
2781    borderBlockEndWidth: string;
2782    borderBlockStart: string;
2783    borderBlockStartColor: string;
2784    borderBlockStartStyle: string;
2785    borderBlockStartWidth: string;
2786    borderBottom: string;
2787    borderBottomColor: string;
2788    borderBottomLeftRadius: string;
2789    borderBottomRightRadius: string;
2790    borderBottomStyle: string;
2791    borderBottomWidth: string;
2792    borderCollapse: string;
2793    borderColor: string;
2794    borderImage: string;
2795    borderImageOutset: string;
2796    borderImageRepeat: string;
2797    borderImageSlice: string;
2798    borderImageSource: string;
2799    borderImageWidth: string;
2800    borderInlineEnd: string;
2801    borderInlineEndColor: string;
2802    borderInlineEndStyle: string;
2803    borderInlineEndWidth: string;
2804    borderInlineStart: string;
2805    borderInlineStartColor: string;
2806    borderInlineStartStyle: string;
2807    borderInlineStartWidth: string;
2808    borderLeft: string;
2809    borderLeftColor: string;
2810    borderLeftStyle: string;
2811    borderLeftWidth: string;
2812    borderRadius: string;
2813    borderRight: string;
2814    borderRightColor: string;
2815    borderRightStyle: string;
2816    borderRightWidth: string;
2817    borderSpacing: string;
2818    borderStyle: string;
2819    borderTop: string;
2820    borderTopColor: string;
2821    borderTopLeftRadius: string;
2822    borderTopRightRadius: string;
2823    borderTopStyle: string;
2824    borderTopWidth: string;
2825    borderWidth: string;
2826    bottom: string;
2827    boxShadow: string;
2828    boxSizing: string;
2829    breakAfter: string;
2830    breakBefore: string;
2831    breakInside: string;
2832    captionSide: string;
2833    caretColor: string;
2834    clear: string;
2835    clip: string;
2836    clipPath: string;
2837    clipRule: string;
2838    color: string | null;
2839    colorInterpolation: string;
2840    colorInterpolationFilters: string;
2841    columnCount: string;
2842    columnFill: string;
2843    columnGap: string;
2844    columnRule: string;
2845    columnRuleColor: string;
2846    columnRuleStyle: string;
2847    columnRuleWidth: string;
2848    columnSpan: string;
2849    columnWidth: string;
2850    columns: string;
2851    content: string;
2852    counterIncrement: string;
2853    counterReset: string;
2854    cssFloat: string | null;
2855    cssText: string;
2856    cursor: string;
2857    direction: string;
2858    display: string;
2859    dominantBaseline: string;
2860    emptyCells: string;
2861    enableBackground: string | null;
2862    fill: string;
2863    fillOpacity: string;
2864    fillRule: string;
2865    filter: string;
2866    flex: string;
2867    flexBasis: string;
2868    flexDirection: string;
2869    flexFlow: string;
2870    flexGrow: string;
2871    flexShrink: string;
2872    flexWrap: string;
2873    float: string;
2874    floodColor: string;
2875    floodOpacity: string;
2876    font: string;
2877    fontFamily: string;
2878    fontFeatureSettings: string;
2879    fontKerning: string;
2880    fontSize: string;
2881    fontSizeAdjust: string;
2882    fontStretch: string;
2883    fontStyle: string;
2884    fontSynthesis: string;
2885    fontVariant: string;
2886    fontVariantCaps: string;
2887    fontVariantEastAsian: string;
2888    fontVariantLigatures: string;
2889    fontVariantNumeric: string;
2890    fontVariantPosition: string;
2891    fontWeight: string;
2892    gap: string;
2893    glyphOrientationHorizontal: string | null;
2894    glyphOrientationVertical: string;
2895    grid: string;
2896    gridArea: string;
2897    gridAutoColumns: string;
2898    gridAutoFlow: string;
2899    gridAutoRows: string;
2900    gridColumn: string;
2901    gridColumnEnd: string;
2902    gridColumnGap: string;
2903    gridColumnStart: string;
2904    gridGap: string;
2905    gridRow: string;
2906    gridRowEnd: string;
2907    gridRowGap: string;
2908    gridRowStart: string;
2909    gridTemplate: string;
2910    gridTemplateAreas: string;
2911    gridTemplateColumns: string;
2912    gridTemplateRows: string;
2913    height: string;
2914    hyphens: string;
2915    imageOrientation: string;
2916    imageRendering: string;
2917    imeMode: string | null;
2918    inlineSize: string;
2919    justifyContent: string;
2920    justifyItems: string;
2921    justifySelf: string;
2922    kerning: string | null;
2923    layoutGrid: string | null;
2924    layoutGridChar: string | null;
2925    layoutGridLine: string | null;
2926    layoutGridMode: string | null;
2927    layoutGridType: string | null;
2928    left: string;
2929    readonly length: number;
2930    letterSpacing: string;
2931    lightingColor: string;
2932    lineBreak: string;
2933    lineHeight: string;
2934    listStyle: string;
2935    listStyleImage: string;
2936    listStylePosition: string;
2937    listStyleType: string;
2938    margin: string;
2939    marginBlockEnd: string;
2940    marginBlockStart: string;
2941    marginBottom: string;
2942    marginInlineEnd: string;
2943    marginInlineStart: string;
2944    marginLeft: string;
2945    marginRight: string;
2946    marginTop: string;
2947    marker: string;
2948    markerEnd: string;
2949    markerMid: string;
2950    markerStart: string;
2951    mask: string;
2952    maskComposite: string;
2953    maskImage: string;
2954    maskPosition: string;
2955    maskRepeat: string;
2956    maskSize: string;
2957    maskType: string;
2958    maxBlockSize: string;
2959    maxHeight: string;
2960    maxInlineSize: string;
2961    maxWidth: string;
2962    minBlockSize: string;
2963    minHeight: string;
2964    minInlineSize: string;
2965    minWidth: string;
2966    msContentZoomChaining: string | null;
2967    msContentZoomLimit: string | null;
2968    msContentZoomLimitMax: any;
2969    msContentZoomLimitMin: any;
2970    msContentZoomSnap: string | null;
2971    msContentZoomSnapPoints: string | null;
2972    msContentZoomSnapType: string | null;
2973    msContentZooming: string | null;
2974    msFlowFrom: string | null;
2975    msFlowInto: string | null;
2976    msFontFeatureSettings: string | null;
2977    msGridColumn: any;
2978    msGridColumnAlign: string | null;
2979    msGridColumnSpan: any;
2980    msGridColumns: string | null;
2981    msGridRow: any;
2982    msGridRowAlign: string | null;
2983    msGridRowSpan: any;
2984    msGridRows: string | null;
2985    msHighContrastAdjust: string | null;
2986    msHyphenateLimitChars: string | null;
2987    msHyphenateLimitLines: any;
2988    msHyphenateLimitZone: any;
2989    msHyphens: string | null;
2990    msImeAlign: string | null;
2991    msOverflowStyle: string | null;
2992    msScrollChaining: string | null;
2993    msScrollLimit: string | null;
2994    msScrollLimitXMax: any;
2995    msScrollLimitXMin: any;
2996    msScrollLimitYMax: any;
2997    msScrollLimitYMin: any;
2998    msScrollRails: string | null;
2999    msScrollSnapPointsX: string | null;
3000    msScrollSnapPointsY: string | null;
3001    msScrollSnapType: string | null;
3002    msScrollSnapX: string | null;
3003    msScrollSnapY: string | null;
3004    msScrollTranslation: string | null;
3005    msTextCombineHorizontal: string | null;
3006    msTextSizeAdjust: any;
3007    msTouchAction: string | null;
3008    msTouchSelect: string | null;
3009    msUserSelect: string | null;
3010    msWrapFlow: string;
3011    msWrapMargin: any;
3012    msWrapThrough: string;
3013    objectFit: string;
3014    objectPosition: string;
3015    opacity: string | null;
3016    order: string;
3017    orphans: string;
3018    outline: string;
3019    outlineColor: string;
3020    outlineOffset: string;
3021    outlineStyle: string;
3022    outlineWidth: string;
3023    overflow: string;
3024    overflowAnchor: string;
3025    overflowWrap: string;
3026    overflowX: string;
3027    overflowY: string;
3028    padding: string;
3029    paddingBlockEnd: string;
3030    paddingBlockStart: string;
3031    paddingBottom: string;
3032    paddingInlineEnd: string;
3033    paddingInlineStart: string;
3034    paddingLeft: string;
3035    paddingRight: string;
3036    paddingTop: string;
3037    pageBreakAfter: string;
3038    pageBreakBefore: string;
3039    pageBreakInside: string;
3040    paintOrder: string;
3041    readonly parentRule: CSSRule;
3042    penAction: string | null;
3043    perspective: string;
3044    perspectiveOrigin: string;
3045    placeContent: string;
3046    placeItems: string;
3047    placeSelf: string;
3048    pointerEvents: string | null;
3049    position: string;
3050    quotes: string;
3051    resize: string;
3052    right: string;
3053    rotate: string;
3054    rowGap: string;
3055    rubyAlign: string | null;
3056    rubyOverhang: string | null;
3057    rubyPosition: string | null;
3058    scale: string;
3059    scrollBehavior: string;
3060    shapeRendering: string;
3061    stopColor: string | null;
3062    stopOpacity: string | null;
3063    stroke: string;
3064    strokeDasharray: string;
3065    strokeDashoffset: string;
3066    strokeLinecap: string;
3067    strokeLinejoin: string;
3068    strokeMiterlimit: string;
3069    strokeOpacity: string;
3070    strokeWidth: string;
3071    tabSize: string;
3072    tableLayout: string;
3073    textAlign: string;
3074    textAlignLast: string;
3075    textAnchor: string | null;
3076    textCombineUpright: string;
3077    textDecoration: string;
3078    textDecorationColor: string;
3079    textDecorationLine: string;
3080    textDecorationStyle: string;
3081    textEmphasis: string;
3082    textEmphasisColor: string;
3083    textEmphasisPosition: string;
3084    textEmphasisStyle: string;
3085    textIndent: string;
3086    textJustify: string;
3087    textKashida: string | null;
3088    textKashidaSpace: string | null;
3089    textOrientation: string;
3090    textOverflow: string;
3091    textRendering: string;
3092    textShadow: string;
3093    textTransform: string;
3094    textUnderlinePosition: string;
3095    top: string;
3096    touchAction: string;
3097    transform: string;
3098    transformBox: string;
3099    transformOrigin: string;
3100    transformStyle: string;
3101    transition: string;
3102    transitionDelay: string;
3103    transitionDuration: string;
3104    transitionProperty: string;
3105    transitionTimingFunction: string;
3106    translate: string;
3107    unicodeBidi: string;
3108    userSelect: string;
3109    verticalAlign: string;
3110    visibility: string;
3111    /** @deprecated */
3112    webkitAlignContent: string;
3113    /** @deprecated */
3114    webkitAlignItems: string;
3115    /** @deprecated */
3116    webkitAlignSelf: string;
3117    /** @deprecated */
3118    webkitAnimation: string;
3119    /** @deprecated */
3120    webkitAnimationDelay: string;
3121    /** @deprecated */
3122    webkitAnimationDirection: string;
3123    /** @deprecated */
3124    webkitAnimationDuration: string;
3125    /** @deprecated */
3126    webkitAnimationFillMode: string;
3127    /** @deprecated */
3128    webkitAnimationIterationCount: string;
3129    /** @deprecated */
3130    webkitAnimationName: string;
3131    /** @deprecated */
3132    webkitAnimationPlayState: string;
3133    /** @deprecated */
3134    webkitAnimationTimingFunction: string;
3135    /** @deprecated */
3136    webkitAppearance: string;
3137    /** @deprecated */
3138    webkitBackfaceVisibility: string;
3139    /** @deprecated */
3140    webkitBackgroundClip: string;
3141    /** @deprecated */
3142    webkitBackgroundOrigin: string;
3143    /** @deprecated */
3144    webkitBackgroundSize: string;
3145    /** @deprecated */
3146    webkitBorderBottomLeftRadius: string;
3147    /** @deprecated */
3148    webkitBorderBottomRightRadius: string;
3149    webkitBorderImage: string | null;
3150    /** @deprecated */
3151    webkitBorderRadius: string;
3152    /** @deprecated */
3153    webkitBorderTopLeftRadius: string;
3154    /** @deprecated */
3155    webkitBorderTopRightRadius: string;
3156    /** @deprecated */
3157    webkitBoxAlign: string;
3158    webkitBoxDirection: string | null;
3159    /** @deprecated */
3160    webkitBoxFlex: string;
3161    /** @deprecated */
3162    webkitBoxOrdinalGroup: string;
3163    webkitBoxOrient: string | null;
3164    /** @deprecated */
3165    webkitBoxPack: string;
3166    /** @deprecated */
3167    webkitBoxShadow: string;
3168    /** @deprecated */
3169    webkitBoxSizing: string;
3170    webkitColumnBreakAfter: string | null;
3171    webkitColumnBreakBefore: string | null;
3172    webkitColumnBreakInside: string | null;
3173    webkitColumnCount: any;
3174    webkitColumnGap: any;
3175    webkitColumnRule: string | null;
3176    webkitColumnRuleColor: any;
3177    webkitColumnRuleStyle: string | null;
3178    webkitColumnRuleWidth: any;
3179    webkitColumnSpan: string | null;
3180    webkitColumnWidth: any;
3181    webkitColumns: string | null;
3182    /** @deprecated */
3183    webkitFilter: string;
3184    /** @deprecated */
3185    webkitFlex: string;
3186    /** @deprecated */
3187    webkitFlexBasis: string;
3188    /** @deprecated */
3189    webkitFlexDirection: string;
3190    /** @deprecated */
3191    webkitFlexFlow: string;
3192    /** @deprecated */
3193    webkitFlexGrow: string;
3194    /** @deprecated */
3195    webkitFlexShrink: string;
3196    /** @deprecated */
3197    webkitFlexWrap: string;
3198    /** @deprecated */
3199    webkitJustifyContent: string;
3200    webkitLineClamp: string;
3201    /** @deprecated */
3202    webkitMask: string;
3203    /** @deprecated */
3204    webkitMaskBoxImage: string;
3205    /** @deprecated */
3206    webkitMaskBoxImageOutset: string;
3207    /** @deprecated */
3208    webkitMaskBoxImageRepeat: string;
3209    /** @deprecated */
3210    webkitMaskBoxImageSlice: string;
3211    /** @deprecated */
3212    webkitMaskBoxImageSource: string;
3213    /** @deprecated */
3214    webkitMaskBoxImageWidth: string;
3215    /** @deprecated */
3216    webkitMaskClip: string;
3217    /** @deprecated */
3218    webkitMaskComposite: string;
3219    /** @deprecated */
3220    webkitMaskImage: string;
3221    /** @deprecated */
3222    webkitMaskOrigin: string;
3223    /** @deprecated */
3224    webkitMaskPosition: string;
3225    /** @deprecated */
3226    webkitMaskRepeat: string;
3227    /** @deprecated */
3228    webkitMaskSize: string;
3229    /** @deprecated */
3230    webkitOrder: string;
3231    /** @deprecated */
3232    webkitPerspective: string;
3233    /** @deprecated */
3234    webkitPerspectiveOrigin: string;
3235    webkitTapHighlightColor: string | null;
3236    /** @deprecated */
3237    webkitTextFillColor: string;
3238    /** @deprecated */
3239    webkitTextSizeAdjust: string;
3240    /** @deprecated */
3241    webkitTextStroke: string;
3242    /** @deprecated */
3243    webkitTextStrokeColor: string;
3244    /** @deprecated */
3245    webkitTextStrokeWidth: string;
3246    /** @deprecated */
3247    webkitTransform: string;
3248    /** @deprecated */
3249    webkitTransformOrigin: string;
3250    /** @deprecated */
3251    webkitTransformStyle: string;
3252    /** @deprecated */
3253    webkitTransition: string;
3254    /** @deprecated */
3255    webkitTransitionDelay: string;
3256    /** @deprecated */
3257    webkitTransitionDuration: string;
3258    /** @deprecated */
3259    webkitTransitionProperty: string;
3260    /** @deprecated */
3261    webkitTransitionTimingFunction: string;
3262    webkitUserModify: string | null;
3263    webkitUserSelect: string | null;
3264    webkitWritingMode: string | null;
3265    whiteSpace: string;
3266    widows: string;
3267    width: string;
3268    willChange: string;
3269    wordBreak: string;
3270    wordSpacing: string;
3271    wordWrap: string;
3272    writingMode: string;
3273    zIndex: string;
3274    zoom: string | null;
3275    getPropertyPriority(propertyName: string): string;
3276    getPropertyValue(propertyName: string): string;
3277    item(index: number): string;
3278    removeProperty(propertyName: string): string;
3279    setProperty(propertyName: string, value: string | null, priority?: string | null): void;
3280    [index: number]: string;
3281}
3282
3283declare var CSSStyleDeclaration: {
3284    prototype: CSSStyleDeclaration;
3285    new(): CSSStyleDeclaration;
3286};
3287
3288/** CSSStyleRule represents a single CSS style rule. It implements the CSSRule interface with a type value of 1 (CSSRule.STYLE_RULE). */
3289interface CSSStyleRule extends CSSRule {
3290    selectorText: string;
3291    readonly style: CSSStyleDeclaration;
3292}
3293
3294declare var CSSStyleRule: {
3295    prototype: CSSStyleRule;
3296    new(): CSSStyleRule;
3297};
3298
3299/** A single CSS style sheet. It inherits properties and methods from its parent, StyleSheet. */
3300interface CSSStyleSheet extends StyleSheet {
3301    readonly cssRules: CSSRuleList;
3302    /** @deprecated */
3303    cssText: string;
3304    /** @deprecated */
3305    readonly id: string;
3306    /** @deprecated */
3307    readonly imports: StyleSheetList;
3308    /** @deprecated */
3309    readonly isAlternate: boolean;
3310    /** @deprecated */
3311    readonly isPrefAlternate: boolean;
3312    readonly ownerRule: CSSRule | null;
3313    /** @deprecated */
3314    readonly owningElement: Element;
3315    /** @deprecated */
3316    readonly pages: any;
3317    /** @deprecated */
3318    readonly readOnly: boolean;
3319    readonly rules: CSSRuleList;
3320    /** @deprecated */
3321    addImport(bstrURL: string, lIndex?: number): number;
3322    /** @deprecated */
3323    addPageRule(bstrSelector: string, bstrStyle: string, lIndex?: number): number;
3324    addRule(bstrSelector: string, bstrStyle?: string, lIndex?: number): number;
3325    deleteRule(index?: number): void;
3326    insertRule(rule: string, index?: number): number;
3327    /** @deprecated */
3328    removeImport(lIndex: number): void;
3329    removeRule(lIndex: number): void;
3330}
3331
3332declare var CSSStyleSheet: {
3333    prototype: CSSStyleSheet;
3334    new(): CSSStyleSheet;
3335};
3336
3337/** An object representing a single CSS @supports at-rule. It implements the CSSConditionRule interface, and therefore the CSSRule and CSSGroupingRule interfaces with a type value of 12 (CSSRule.SUPPORTS_RULE). */
3338interface CSSSupportsRule extends CSSConditionRule {
3339}
3340
3341declare var CSSSupportsRule: {
3342    prototype: CSSSupportsRule;
3343    new(): CSSSupportsRule;
3344};
3345
3346/** Provides a storage mechanism for Request / Response object pairs that are cached, for example as part of the ServiceWorker life cycle. Note that the Cache interface is exposed to windowed scopes as well as workers. You don't have to use it in conjunction with service workers, even though it is defined in the service worker spec. */
3347interface Cache {
3348    add(request: RequestInfo): Promise<void>;
3349    addAll(requests: RequestInfo[]): Promise<void>;
3350    delete(request: RequestInfo, options?: CacheQueryOptions): Promise<boolean>;
3351    keys(request?: RequestInfo, options?: CacheQueryOptions): Promise<ReadonlyArray<Request>>;
3352    match(request: RequestInfo, options?: CacheQueryOptions): Promise<Response | undefined>;
3353    matchAll(request?: RequestInfo, options?: CacheQueryOptions): Promise<ReadonlyArray<Response>>;
3354    put(request: RequestInfo, response: Response): Promise<void>;
3355}
3356
3357declare var Cache: {
3358    prototype: Cache;
3359    new(): Cache;
3360};
3361
3362/** The storage for Cache objects. */
3363interface CacheStorage {
3364    delete(cacheName: string): Promise<boolean>;
3365    has(cacheName: string): Promise<boolean>;
3366    keys(): Promise<string[]>;
3367    match(request: RequestInfo, options?: CacheQueryOptions): Promise<Response | undefined>;
3368    open(cacheName: string): Promise<Cache>;
3369}
3370
3371declare var CacheStorage: {
3372    prototype: CacheStorage;
3373    new(): CacheStorage;
3374};
3375
3376interface CanvasCompositing {
3377    globalAlpha: number;
3378    globalCompositeOperation: string;
3379}
3380
3381interface CanvasDrawImage {
3382    drawImage(image: CanvasImageSource, dx: number, dy: number): void;
3383    drawImage(image: CanvasImageSource, dx: number, dy: number, dw: number, dh: number): void;
3384    drawImage(image: CanvasImageSource, sx: number, sy: number, sw: number, sh: number, dx: number, dy: number, dw: number, dh: number): void;
3385}
3386
3387interface CanvasDrawPath {
3388    beginPath(): void;
3389    clip(fillRule?: CanvasFillRule): void;
3390    clip(path: Path2D, fillRule?: CanvasFillRule): void;
3391    fill(fillRule?: CanvasFillRule): void;
3392    fill(path: Path2D, fillRule?: CanvasFillRule): void;
3393    isPointInPath(x: number, y: number, fillRule?: CanvasFillRule): boolean;
3394    isPointInPath(path: Path2D, x: number, y: number, fillRule?: CanvasFillRule): boolean;
3395    isPointInStroke(x: number, y: number): boolean;
3396    isPointInStroke(path: Path2D, x: number, y: number): boolean;
3397    stroke(): void;
3398    stroke(path: Path2D): void;
3399}
3400
3401interface CanvasFillStrokeStyles {
3402    fillStyle: string | CanvasGradient | CanvasPattern;
3403    strokeStyle: string | CanvasGradient | CanvasPattern;
3404    createLinearGradient(x0: number, y0: number, x1: number, y1: number): CanvasGradient;
3405    createPattern(image: CanvasImageSource, repetition: string): CanvasPattern | null;
3406    createRadialGradient(x0: number, y0: number, r0: number, x1: number, y1: number, r1: number): CanvasGradient;
3407}
3408
3409interface CanvasFilters {
3410    filter: string;
3411}
3412
3413/** An opaque object describing a gradient. It is returned by the methods CanvasRenderingContext2D.createLinearGradient() or CanvasRenderingContext2D.createRadialGradient(). */
3414interface CanvasGradient {
3415    /**
3416     * Adds a color stop with the given color to the gradient at the given offset. 0.0 is the offset at one end of the gradient, 1.0 is the offset at the other end.
3417     * 
3418     * Throws an "IndexSizeError" DOMException if the offset is out of range. Throws a "SyntaxError" DOMException if the color cannot be parsed.
3419     */
3420    addColorStop(offset: number, color: string): void;
3421}
3422
3423declare var CanvasGradient: {
3424    prototype: CanvasGradient;
3425    new(): CanvasGradient;
3426};
3427
3428interface CanvasImageData {
3429    createImageData(sw: number, sh: number): ImageData;
3430    createImageData(imagedata: ImageData): ImageData;
3431    getImageData(sx: number, sy: number, sw: number, sh: number): ImageData;
3432    putImageData(imagedata: ImageData, dx: number, dy: number): void;
3433    putImageData(imagedata: ImageData, dx: number, dy: number, dirtyX: number, dirtyY: number, dirtyWidth: number, dirtyHeight: number): void;
3434}
3435
3436interface CanvasImageSmoothing {
3437    imageSmoothingEnabled: boolean;
3438    imageSmoothingQuality: ImageSmoothingQuality;
3439}
3440
3441interface CanvasPath {
3442    arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, anticlockwise?: boolean): void;
3443    arcTo(x1: number, y1: number, x2: number, y2: number, radius: number): void;
3444    bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number): void;
3445    closePath(): void;
3446    ellipse(x: number, y: number, radiusX: number, radiusY: number, rotation: number, startAngle: number, endAngle: number, anticlockwise?: boolean): void;
3447    lineTo(x: number, y: number): void;
3448    moveTo(x: number, y: number): void;
3449    quadraticCurveTo(cpx: number, cpy: number, x: number, y: number): void;
3450    rect(x: number, y: number, w: number, h: number): void;
3451}
3452
3453interface CanvasPathDrawingStyles {
3454    lineCap: CanvasLineCap;
3455    lineDashOffset: number;
3456    lineJoin: CanvasLineJoin;
3457    lineWidth: number;
3458    miterLimit: number;
3459    getLineDash(): number[];
3460    setLineDash(segments: number[]): void;
3461}
3462
3463/** An opaque object describing a pattern, based on an image, a canvas, or a video, created by the CanvasRenderingContext2D.createPattern() method. */
3464interface CanvasPattern {
3465    /**
3466     * Sets the transformation matrix that will be used when rendering the pattern during a fill or stroke painting operation.
3467     */
3468    setTransform(transform?: DOMMatrix2DInit): void;
3469}
3470
3471declare var CanvasPattern: {
3472    prototype: CanvasPattern;
3473    new(): CanvasPattern;
3474};
3475
3476interface CanvasRect {
3477    clearRect(x: number, y: number, w: number, h: number): void;
3478    fillRect(x: number, y: number, w: number, h: number): void;
3479    strokeRect(x: number, y: number, w: number, h: number): void;
3480}
3481
3482/** The CanvasRenderingContext2D interface, part of the Canvas API, provides the 2D rendering context for the drawing surface of a <canvas> element. It is used for drawing shapes, text, images, and other objects. */
3483interface CanvasRenderingContext2D extends CanvasCompositing, CanvasDrawImage, CanvasDrawPath, CanvasFillStrokeStyles, CanvasFilters, CanvasImageData, CanvasImageSmoothing, CanvasPath, CanvasPathDrawingStyles, CanvasRect, CanvasShadowStyles, CanvasState, CanvasText, CanvasTextDrawingStyles, CanvasTransform, CanvasUserInterface {
3484    readonly canvas: HTMLCanvasElement;
3485}
3486
3487declare var CanvasRenderingContext2D: {
3488    prototype: CanvasRenderingContext2D;
3489    new(): CanvasRenderingContext2D;
3490};
3491
3492interface CanvasShadowStyles {
3493    shadowBlur: number;
3494    shadowColor: string;
3495    shadowOffsetX: number;
3496    shadowOffsetY: number;
3497}
3498
3499interface CanvasState {
3500    restore(): void;
3501    save(): void;
3502}
3503
3504interface CanvasText {
3505    fillText(text: string, x: number, y: number, maxWidth?: number): void;
3506    measureText(text: string): TextMetrics;
3507    strokeText(text: string, x: number, y: number, maxWidth?: number): void;
3508}
3509
3510interface CanvasTextDrawingStyles {
3511    direction: CanvasDirection;
3512    font: string;
3513    textAlign: CanvasTextAlign;
3514    textBaseline: CanvasTextBaseline;
3515}
3516
3517interface CanvasTransform {
3518    getTransform(): DOMMatrix;
3519    resetTransform(): void;
3520    rotate(angle: number): void;
3521    scale(x: number, y: number): void;
3522    setTransform(a: number, b: number, c: number, d: number, e: number, f: number): void;
3523    setTransform(transform?: DOMMatrix2DInit): void;
3524    transform(a: number, b: number, c: number, d: number, e: number, f: number): void;
3525    translate(x: number, y: number): void;
3526}
3527
3528interface CanvasUserInterface {
3529    drawFocusIfNeeded(element: Element): void;
3530    drawFocusIfNeeded(path: Path2D, element: Element): void;
3531    scrollPathIntoView(): void;
3532    scrollPathIntoView(path: Path2D): void;
3533}
3534
3535interface CaretPosition {
3536    readonly offset: number;
3537    readonly offsetNode: Node;
3538    getClientRect(): DOMRect | null;
3539}
3540
3541declare var CaretPosition: {
3542    prototype: CaretPosition;
3543    new(): CaretPosition;
3544};
3545
3546/** The ChannelMergerNode interface, often used in conjunction with its opposite, ChannelSplitterNode, reunites different mono inputs into a single output. Each input is used to fill a channel of the output. This is useful for accessing each channels separately, e.g. for performing channel mixing where gain must be separately controlled on each channel. */
3547interface ChannelMergerNode extends AudioNode {
3548}
3549
3550declare var ChannelMergerNode: {
3551    prototype: ChannelMergerNode;
3552    new(context: BaseAudioContext, options?: ChannelMergerOptions): ChannelMergerNode;
3553};
3554
3555/** The ChannelSplitterNode interface, often used in conjunction with its opposite, ChannelMergerNode, separates the different channels of an audio source into a set of mono outputs. This is useful for accessing each channel separately, e.g. for performing channel mixing where gain must be separately controlled on each channel. */
3556interface ChannelSplitterNode extends AudioNode {
3557}
3558
3559declare var ChannelSplitterNode: {
3560    prototype: ChannelSplitterNode;
3561    new(context: BaseAudioContext, options?: ChannelSplitterOptions): ChannelSplitterNode;
3562};
3563
3564/** The CharacterData abstract interface represents a Node object that contains characters. This is an abstract interface, meaning there aren't any object of type CharacterData: it is implemented by other interfaces, like Text, Comment, or ProcessingInstruction which aren't abstract. */
3565interface CharacterData extends Node, ChildNode, NonDocumentTypeChildNode {
3566    data: string;
3567    readonly length: number;
3568    appendData(data: string): void;
3569    deleteData(offset: number, count: number): void;
3570    insertData(offset: number, data: string): void;
3571    replaceData(offset: number, count: number, data: string): void;
3572    substringData(offset: number, count: number): string;
3573}
3574
3575declare var CharacterData: {
3576    prototype: CharacterData;
3577    new(): CharacterData;
3578};
3579
3580interface ChildNode extends Node {
3581    /**
3582     * Inserts nodes just after node, while replacing strings in nodes with equivalent Text nodes.
3583     * 
3584     * Throws a "HierarchyRequestError" DOMException if the constraints of the node tree are violated.
3585     */
3586    after(...nodes: (Node | string)[]): void;
3587    /**
3588     * Inserts nodes just before node, while replacing strings in nodes with equivalent Text nodes.
3589     * 
3590     * Throws a "HierarchyRequestError" DOMException if the constraints of the node tree are violated.
3591     */
3592    before(...nodes: (Node | string)[]): void;
3593    /**
3594     * Removes node.
3595     */
3596    remove(): void;
3597    /**
3598     * Replaces node with nodes, while replacing strings in nodes with equivalent Text nodes.
3599     * 
3600     * Throws a "HierarchyRequestError" DOMException if the constraints of the node tree are violated.
3601     */
3602    replaceWith(...nodes: (Node | string)[]): void;
3603}
3604
3605interface ClientRect {
3606    bottom: number;
3607    readonly height: number;
3608    left: number;
3609    right: number;
3610    top: number;
3611    readonly width: number;
3612}
3613
3614declare var ClientRect: {
3615    prototype: ClientRect;
3616    new(): ClientRect;
3617};
3618
3619interface ClientRectList {
3620    readonly length: number;
3621    item(index: number): ClientRect;
3622    [index: number]: ClientRect;
3623}
3624
3625declare var ClientRectList: {
3626    prototype: ClientRectList;
3627    new(): ClientRectList;
3628};
3629
3630interface Clipboard extends EventTarget {
3631    readText(): Promise<string>;
3632    writeText(data: string): Promise<void>;
3633}
3634
3635declare var Clipboard: {
3636    prototype: Clipboard;
3637    new(): Clipboard;
3638};
3639
3640/** Events providing information related to modification of the clipboard, that is cut, copy, and paste events. */
3641interface ClipboardEvent extends Event {
3642    readonly clipboardData: DataTransfer | null;
3643}
3644
3645declare var ClipboardEvent: {
3646    prototype: ClipboardEvent;
3647    new(type: string, eventInitDict?: ClipboardEventInit): ClipboardEvent;
3648};
3649
3650/** A CloseEvent is sent to clients using WebSockets when the connection is closed. This is delivered to the listener indicated by the WebSocket object's onclose attribute. */
3651interface CloseEvent extends Event {
3652    readonly code: number;
3653    readonly reason: string;
3654    readonly wasClean: boolean;
3655    /** @deprecated */
3656    initCloseEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, wasCleanArg: boolean, codeArg: number, reasonArg: string): void;
3657}
3658
3659declare var CloseEvent: {
3660    prototype: CloseEvent;
3661    new(type: string, eventInitDict?: CloseEventInit): CloseEvent;
3662};
3663
3664/** Textual notations within markup; although it is generally not visually shown, such comments are available to be read in the source view. */
3665interface Comment extends CharacterData {
3666}
3667
3668declare var Comment: {
3669    prototype: Comment;
3670    new(data?: string): Comment;
3671};
3672
3673/** The DOM CompositionEvent represents events that occur due to the user indirectly entering text. */
3674interface CompositionEvent extends UIEvent {
3675    readonly data: string;
3676}
3677
3678declare var CompositionEvent: {
3679    prototype: CompositionEvent;
3680    new(type: string, eventInitDict?: CompositionEventInit): CompositionEvent;
3681};
3682
3683interface ConcatParams extends Algorithm {
3684    algorithmId: Uint8Array;
3685    hash?: string | Algorithm;
3686    partyUInfo: Uint8Array;
3687    partyVInfo: Uint8Array;
3688    privateInfo?: Uint8Array;
3689    publicInfo?: Uint8Array;
3690}
3691
3692/** Provides access to the browser's debugging console (e.g. the Web Console in Firefox). The specifics of how it works varies from browser to browser, but there is a de facto set of features that are typically provided. */
3693interface Console {
3694    memory: any;
3695    assert(condition?: boolean, message?: string, ...data: any[]): void;
3696    clear(): void;
3697    count(label?: string): void;
3698    debug(message?: any, ...optionalParams: any[]): void;
3699    dir(value?: any, ...optionalParams: any[]): void;
3700    dirxml(value: any): void;
3701    error(message?: any, ...optionalParams: any[]): void;
3702    exception(message?: string, ...optionalParams: any[]): void;
3703    group(groupTitle?: string, ...optionalParams: any[]): void;
3704    groupCollapsed(groupTitle?: string, ...optionalParams: any[]): void;
3705    groupEnd(): void;
3706    info(message?: any, ...optionalParams: any[]): void;
3707    log(message?: any, ...optionalParams: any[]): void;
3708    markTimeline(label?: string): void;
3709    profile(reportName?: string): void;
3710    profileEnd(reportName?: string): void;
3711    table(...tabularData: any[]): void;
3712    time(label?: string): void;
3713    timeEnd(label?: string): void;
3714    timeStamp(label?: string): void;
3715    timeline(label?: string): void;
3716    timelineEnd(label?: string): void;
3717    trace(message?: any, ...optionalParams: any[]): void;
3718    warn(message?: any, ...optionalParams: any[]): void;
3719}
3720
3721declare var Console: {
3722    prototype: Console;
3723    new(): Console;
3724};
3725
3726interface ConstantSourceNode extends AudioScheduledSourceNode {
3727    readonly offset: AudioParam;
3728    addEventListener<K extends keyof AudioScheduledSourceNodeEventMap>(type: K, listener: (this: ConstantSourceNode, ev: AudioScheduledSourceNodeEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
3729    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
3730    removeEventListener<K extends keyof AudioScheduledSourceNodeEventMap>(type: K, listener: (this: ConstantSourceNode, ev: AudioScheduledSourceNodeEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
3731    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
3732}
3733
3734declare var ConstantSourceNode: {
3735    prototype: ConstantSourceNode;
3736    new(context: BaseAudioContext, options?: ConstantSourceOptions): ConstantSourceNode;
3737};
3738
3739/** An AudioNode that performs a Linear Convolution on a given AudioBuffer, often used to achieve a reverb effect. A ConvolverNode always has exactly one input and one output. */
3740interface ConvolverNode extends AudioNode {
3741    buffer: AudioBuffer | null;
3742    normalize: boolean;
3743}
3744
3745declare var ConvolverNode: {
3746    prototype: ConvolverNode;
3747    new(context: BaseAudioContext, options?: ConvolverOptions): ConvolverNode;
3748};
3749
3750/** The position and altitude of the device on Earth, as well as the accuracy with which these properties are calculated. */
3751interface Coordinates {
3752    readonly accuracy: number;
3753    readonly altitude: number | null;
3754    readonly altitudeAccuracy: number | null;
3755    readonly heading: number | null;
3756    readonly latitude: number;
3757    readonly longitude: number;
3758    readonly speed: number | null;
3759}
3760
3761/** This Streams API interface provides a built-in byte length queuing strategy that can be used when constructing streams. */
3762interface CountQueuingStrategy extends QueuingStrategy {
3763    highWaterMark: number;
3764    size(chunk: any): 1;
3765}
3766
3767declare var CountQueuingStrategy: {
3768    prototype: CountQueuingStrategy;
3769    new(options: { highWaterMark: number }): CountQueuingStrategy;
3770};
3771
3772interface Credential {
3773    readonly id: string;
3774    readonly type: string;
3775}
3776
3777declare var Credential: {
3778    prototype: Credential;
3779    new(): Credential;
3780};
3781
3782interface CredentialsContainer {
3783    create(options?: CredentialCreationOptions): Promise<Credential | null>;
3784    get(options?: CredentialRequestOptions): Promise<Credential | null>;
3785    preventSilentAccess(): Promise<void>;
3786    store(credential: Credential): Promise<Credential>;
3787}
3788
3789declare var CredentialsContainer: {
3790    prototype: CredentialsContainer;
3791    new(): CredentialsContainer;
3792};
3793
3794/** Basic cryptography features available in the current context. It allows access to a cryptographically strong random number generator and to cryptographic primitives. */
3795interface Crypto {
3796    readonly subtle: SubtleCrypto;
3797    getRandomValues<T extends Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | null>(array: T): T;
3798}
3799
3800declare var Crypto: {
3801    prototype: Crypto;
3802    new(): Crypto;
3803};
3804
3805/** The CryptoKey dictionary of the Web Crypto API represents a cryptographic key. */
3806interface CryptoKey {
3807    readonly algorithm: KeyAlgorithm;
3808    readonly extractable: boolean;
3809    readonly type: KeyType;
3810    readonly usages: KeyUsage[];
3811}
3812
3813declare var CryptoKey: {
3814    prototype: CryptoKey;
3815    new(): CryptoKey;
3816};
3817
3818/** The CryptoKeyPair dictionary of the Web Crypto API represents a key pair for an asymmetric cryptography algorithm, also known as a public-key algorithm. */
3819interface CryptoKeyPair {
3820    privateKey: CryptoKey;
3821    publicKey: CryptoKey;
3822}
3823
3824declare var CryptoKeyPair: {
3825    prototype: CryptoKeyPair;
3826    new(): CryptoKeyPair;
3827};
3828
3829interface CustomElementRegistry {
3830    define(name: string, constructor: Function, options?: ElementDefinitionOptions): void;
3831    get(name: string): any;
3832    upgrade(root: Node): void;
3833    whenDefined(name: string): Promise<void>;
3834}
3835
3836declare var CustomElementRegistry: {
3837    prototype: CustomElementRegistry;
3838    new(): CustomElementRegistry;
3839};
3840
3841interface CustomEvent<T = any> extends Event {
3842    /**
3843     * Returns any custom data event was created with. Typically used for synthetic events.
3844     */
3845    readonly detail: T;
3846    initCustomEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, detailArg: T): void;
3847}
3848
3849declare var CustomEvent: {
3850    prototype: CustomEvent;
3851    new<T>(typeArg: string, eventInitDict?: CustomEventInit<T>): CustomEvent<T>;
3852};
3853
3854/** An error object that contains an error name. */
3855interface DOMError {
3856    readonly name: string;
3857    toString(): string;
3858}
3859
3860declare var DOMError: {
3861    prototype: DOMError;
3862    new(): DOMError;
3863};
3864
3865/** An abnormal event (called an exception) which occurs as a result of calling a method or accessing a property of a web API. */
3866interface DOMException {
3867    readonly code: number;
3868    readonly message: string;
3869    readonly name: string;
3870    readonly ABORT_ERR: number;
3871    readonly DATA_CLONE_ERR: number;
3872    readonly DOMSTRING_SIZE_ERR: number;
3873    readonly HIERARCHY_REQUEST_ERR: number;
3874    readonly INDEX_SIZE_ERR: number;
3875    readonly INUSE_ATTRIBUTE_ERR: number;
3876    readonly INVALID_ACCESS_ERR: number;
3877    readonly INVALID_CHARACTER_ERR: number;
3878    readonly INVALID_MODIFICATION_ERR: number;
3879    readonly INVALID_NODE_TYPE_ERR: number;
3880    readonly INVALID_STATE_ERR: number;
3881    readonly NAMESPACE_ERR: number;
3882    readonly NETWORK_ERR: number;
3883    readonly NOT_FOUND_ERR: number;
3884    readonly NOT_SUPPORTED_ERR: number;
3885    readonly NO_DATA_ALLOWED_ERR: number;
3886    readonly NO_MODIFICATION_ALLOWED_ERR: number;
3887    readonly QUOTA_EXCEEDED_ERR: number;
3888    readonly SECURITY_ERR: number;
3889    readonly SYNTAX_ERR: number;
3890    readonly TIMEOUT_ERR: number;
3891    readonly TYPE_MISMATCH_ERR: number;
3892    readonly URL_MISMATCH_ERR: number;
3893    readonly VALIDATION_ERR: number;
3894    readonly WRONG_DOCUMENT_ERR: number;
3895}
3896
3897declare var DOMException: {
3898    prototype: DOMException;
3899    new(message?: string, name?: string): DOMException;
3900    readonly ABORT_ERR: number;
3901    readonly DATA_CLONE_ERR: number;
3902    readonly DOMSTRING_SIZE_ERR: number;
3903    readonly HIERARCHY_REQUEST_ERR: number;
3904    readonly INDEX_SIZE_ERR: number;
3905    readonly INUSE_ATTRIBUTE_ERR: number;
3906    readonly INVALID_ACCESS_ERR: number;
3907    readonly INVALID_CHARACTER_ERR: number;
3908    readonly INVALID_MODIFICATION_ERR: number;
3909    readonly INVALID_NODE_TYPE_ERR: number;
3910    readonly INVALID_STATE_ERR: number;
3911    readonly NAMESPACE_ERR: number;
3912    readonly NETWORK_ERR: number;
3913    readonly NOT_FOUND_ERR: number;
3914    readonly NOT_SUPPORTED_ERR: number;
3915    readonly NO_DATA_ALLOWED_ERR: number;
3916    readonly NO_MODIFICATION_ALLOWED_ERR: number;
3917    readonly QUOTA_EXCEEDED_ERR: number;
3918    readonly SECURITY_ERR: number;
3919    readonly SYNTAX_ERR: number;
3920    readonly TIMEOUT_ERR: number;
3921    readonly TYPE_MISMATCH_ERR: number;
3922    readonly URL_MISMATCH_ERR: number;
3923    readonly VALIDATION_ERR: number;
3924    readonly WRONG_DOCUMENT_ERR: number;
3925};
3926
3927/** An object providing methods which are not dependent on any particular document. Such an object is returned by the Document.implementation property. */
3928interface DOMImplementation {
3929    createDocument(namespaceURI: string | null, qualifiedName: string | null, doctype: DocumentType | null): Document;
3930    createDocumentType(qualifiedName: string, publicId: string, systemId: string): DocumentType;
3931    createHTMLDocument(title?: string): Document;
3932    /** @deprecated */
3933    hasFeature(...args: any[]): true;
3934}
3935
3936declare var DOMImplementation: {
3937    prototype: DOMImplementation;
3938    new(): DOMImplementation;
3939};
3940
3941interface DOML2DeprecatedColorProperty {
3942    color: string;
3943}
3944
3945interface DOMMatrix extends DOMMatrixReadOnly {
3946    a: number;
3947    b: number;
3948    c: number;
3949    d: number;
3950    e: number;
3951    f: number;
3952    m11: number;
3953    m12: number;
3954    m13: number;
3955    m14: number;
3956    m21: number;
3957    m22: number;
3958    m23: number;
3959    m24: number;
3960    m31: number;
3961    m32: number;
3962    m33: number;
3963    m34: number;
3964    m41: number;
3965    m42: number;
3966    m43: number;
3967    m44: number;
3968    invertSelf(): DOMMatrix;
3969    multiplySelf(other?: DOMMatrixInit): DOMMatrix;
3970    preMultiplySelf(other?: DOMMatrixInit): DOMMatrix;
3971    rotateAxisAngleSelf(x?: number, y?: number, z?: number, angle?: number): DOMMatrix;
3972    rotateFromVectorSelf(x?: number, y?: number): DOMMatrix;
3973    rotateSelf(rotX?: number, rotY?: number, rotZ?: number): DOMMatrix;
3974    scale3dSelf(scale?: number, originX?: number, originY?: number, originZ?: number): DOMMatrix;
3975    scaleSelf(scaleX?: number, scaleY?: number, scaleZ?: number, originX?: number, originY?: number, originZ?: number): DOMMatrix;
3976    setMatrixValue(transformList: string): DOMMatrix;
3977    skewXSelf(sx?: number): DOMMatrix;
3978    skewYSelf(sy?: number): DOMMatrix;
3979    translateSelf(tx?: number, ty?: number, tz?: number): DOMMatrix;
3980}
3981
3982declare var DOMMatrix: {
3983    prototype: DOMMatrix;
3984    new(init?: string | number[]): DOMMatrix;
3985    fromFloat32Array(array32: Float32Array): DOMMatrix;
3986    fromFloat64Array(array64: Float64Array): DOMMatrix;
3987    fromMatrix(other?: DOMMatrixInit): DOMMatrix;
3988};
3989
3990type SVGMatrix = DOMMatrix;
3991declare var SVGMatrix: typeof DOMMatrix;
3992
3993type WebKitCSSMatrix = DOMMatrix;
3994declare var WebKitCSSMatrix: typeof DOMMatrix;
3995
3996interface DOMMatrixReadOnly {
3997    readonly a: number;
3998    readonly b: number;
3999    readonly c: number;
4000    readonly d: number;
4001    readonly e: number;
4002    readonly f: number;
4003    readonly is2D: boolean;
4004    readonly isIdentity: boolean;
4005    readonly m11: number;
4006    readonly m12: number;
4007    readonly m13: number;
4008    readonly m14: number;
4009    readonly m21: number;
4010    readonly m22: number;
4011    readonly m23: number;
4012    readonly m24: number;
4013    readonly m31: number;
4014    readonly m32: number;
4015    readonly m33: number;
4016    readonly m34: number;
4017    readonly m41: number;
4018    readonly m42: number;
4019    readonly m43: number;
4020    readonly m44: number;
4021    flipX(): DOMMatrix;
4022    flipY(): DOMMatrix;
4023    inverse(): DOMMatrix;
4024    multiply(other?: DOMMatrixInit): DOMMatrix;
4025    rotate(rotX?: number, rotY?: number, rotZ?: number): DOMMatrix;
4026    rotateAxisAngle(x?: number, y?: number, z?: number, angle?: number): DOMMatrix;
4027    rotateFromVector(x?: number, y?: number): DOMMatrix;
4028    scale(scaleX?: number, scaleY?: number, scaleZ?: number, originX?: number, originY?: number, originZ?: number): DOMMatrix;
4029    scale3d(scale?: number, originX?: number, originY?: number, originZ?: number): DOMMatrix;
4030    /** @deprecated */
4031    scaleNonUniform(scaleX?: number, scaleY?: number): DOMMatrix;
4032    skewX(sx?: number): DOMMatrix;
4033    skewY(sy?: number): DOMMatrix;
4034    toFloat32Array(): Float32Array;
4035    toFloat64Array(): Float64Array;
4036    toJSON(): any;
4037    transformPoint(point?: DOMPointInit): DOMPoint;
4038    translate(tx?: number, ty?: number, tz?: number): DOMMatrix;
4039}
4040
4041declare var DOMMatrixReadOnly: {
4042    prototype: DOMMatrixReadOnly;
4043    new(init?: string | number[]): DOMMatrixReadOnly;
4044    fromFloat32Array(array32: Float32Array): DOMMatrixReadOnly;
4045    fromFloat64Array(array64: Float64Array): DOMMatrixReadOnly;
4046    fromMatrix(other?: DOMMatrixInit): DOMMatrixReadOnly;
4047};
4048
4049/** Provides the ability to parse XML or HTML source code from a string into a DOM Document. */
4050interface DOMParser {
4051    parseFromString(str: string, type: SupportedType): Document;
4052}
4053
4054declare var DOMParser: {
4055    prototype: DOMParser;
4056    new(): DOMParser;
4057};
4058
4059interface DOMPoint extends DOMPointReadOnly {
4060    w: number;
4061    x: number;
4062    y: number;
4063    z: number;
4064}
4065
4066declare var DOMPoint: {
4067    prototype: DOMPoint;
4068    new(x?: number, y?: number, z?: number, w?: number): DOMPoint;
4069    fromPoint(other?: DOMPointInit): DOMPoint;
4070};
4071
4072type SVGPoint = DOMPoint;
4073declare var SVGPoint: typeof DOMPoint;
4074
4075interface DOMPointReadOnly {
4076    readonly w: number;
4077    readonly x: number;
4078    readonly y: number;
4079    readonly z: number;
4080    matrixTransform(matrix?: DOMMatrixInit): DOMPoint;
4081    toJSON(): any;
4082}
4083
4084declare var DOMPointReadOnly: {
4085    prototype: DOMPointReadOnly;
4086    new(x?: number, y?: number, z?: number, w?: number): DOMPointReadOnly;
4087    fromPoint(other?: DOMPointInit): DOMPointReadOnly;
4088};
4089
4090interface DOMQuad {
4091    readonly p1: DOMPoint;
4092    readonly p2: DOMPoint;
4093    readonly p3: DOMPoint;
4094    readonly p4: DOMPoint;
4095    getBounds(): DOMRect;
4096    toJSON(): any;
4097}
4098
4099declare var DOMQuad: {
4100    prototype: DOMQuad;
4101    new(p1?: DOMPointInit, p2?: DOMPointInit, p3?: DOMPointInit, p4?: DOMPointInit): DOMQuad;
4102    fromQuad(other?: DOMQuadInit): DOMQuad;
4103    fromRect(other?: DOMRectInit): DOMQuad;
4104};
4105
4106interface DOMRect extends DOMRectReadOnly {
4107    height: number;
4108    width: number;
4109    x: number;
4110    y: number;
4111}
4112
4113declare var DOMRect: {
4114    prototype: DOMRect;
4115    new(x?: number, y?: number, width?: number, height?: number): DOMRect;
4116    fromRect(other?: DOMRectInit): DOMRect;
4117};
4118
4119type SVGRect = DOMRect;
4120declare var SVGRect: typeof DOMRect;
4121
4122interface DOMRectList {
4123    readonly length: number;
4124    item(index: number): DOMRect | null;
4125    [index: number]: DOMRect;
4126}
4127
4128declare var DOMRectList: {
4129    prototype: DOMRectList;
4130    new(): DOMRectList;
4131};
4132
4133interface DOMRectReadOnly {
4134    readonly bottom: number;
4135    readonly height: number;
4136    readonly left: number;
4137    readonly right: number;
4138    readonly top: number;
4139    readonly width: number;
4140    readonly x: number;
4141    readonly y: number;
4142    toJSON(): any;
4143}
4144
4145declare var DOMRectReadOnly: {
4146    prototype: DOMRectReadOnly;
4147    new(x?: number, y?: number, width?: number, height?: number): DOMRectReadOnly;
4148    fromRect(other?: DOMRectInit): DOMRectReadOnly;
4149};
4150
4151interface DOMSettableTokenList extends DOMTokenList {
4152    value: string;
4153}
4154
4155declare var DOMSettableTokenList: {
4156    prototype: DOMSettableTokenList;
4157    new(): DOMSettableTokenList;
4158};
4159
4160/** A type returned by some APIs which contains a list of DOMString (strings). */
4161interface DOMStringList {
4162    /**
4163     * Returns the number of strings in strings.
4164     */
4165    readonly length: number;
4166    /**
4167     * Returns true if strings contains string, and false otherwise.
4168     */
4169    contains(string: string): boolean;
4170    /**
4171     * Returns the string with index index from strings.
4172     */
4173    item(index: number): string | null;
4174    [index: number]: string;
4175}
4176
4177declare var DOMStringList: {
4178    prototype: DOMStringList;
4179    new(): DOMStringList;
4180};
4181
4182/** Used by the dataset HTML attribute to represent data for custom attributes added to elements. */
4183interface DOMStringMap {
4184    [name: string]: string | undefined;
4185}
4186
4187declare var DOMStringMap: {
4188    prototype: DOMStringMap;
4189    new(): DOMStringMap;
4190};
4191
4192/** A set of space-separated tokens. Such a set is returned by Element.classList, HTMLLinkElement.relList, HTMLAnchorElement.relList, HTMLAreaElement.relList, HTMLIframeElement.sandbox, or HTMLOutputElement.htmlFor. It is indexed beginning with 0 as with JavaScript Array objects. DOMTokenList is always case-sensitive. */
4193interface DOMTokenList {
4194    /**
4195     * Returns the number of tokens.
4196     */
4197    readonly length: number;
4198    /**
4199     * Returns the associated set as string.
4200     * 
4201     * Can be set, to change the associated attribute.
4202     */
4203    value: string;
4204    /**
4205     * Adds all arguments passed, except those already present.
4206     * 
4207     * Throws a "SyntaxError" DOMException if one of the arguments is the empty string.
4208     * 
4209     * Throws an "InvalidCharacterError" DOMException if one of the arguments contains any ASCII whitespace.
4210     */
4211    add(...tokens: string[]): void;
4212    /**
4213     * Returns true if token is present, and false otherwise.
4214     */
4215    contains(token: string): boolean;
4216    /**
4217     * Returns the token with index index.
4218     */
4219    item(index: number): string | null;
4220    /**
4221     * Removes arguments passed, if they are present.
4222     * 
4223     * Throws a "SyntaxError" DOMException if one of the arguments is the empty string.
4224     * 
4225     * Throws an "InvalidCharacterError" DOMException if one of the arguments contains any ASCII whitespace.
4226     */
4227    remove(...tokens: string[]): void;
4228    /**
4229     * Replaces token with newToken.
4230     * 
4231     * Returns true if token was replaced with newToken, and false otherwise.
4232     * 
4233     * Throws a "SyntaxError" DOMException if one of the arguments is the empty string.
4234     * 
4235     * Throws an "InvalidCharacterError" DOMException if one of the arguments contains any ASCII whitespace.
4236     */
4237    replace(oldToken: string, newToken: string): void;
4238    /**
4239     * Returns true if token is in the associated attribute's supported tokens. Returns false otherwise.
4240     * 
4241     * Throws a TypeError if the associated attribute has no supported tokens defined.
4242     */
4243    supports(token: string): boolean;
4244    /**
4245     * If force is not given, "toggles" token, removing it if it's present and adding it if it's not present. If force is true, adds token (same as add()). If force is false, removes token (same as remove()).
4246     * 
4247     * Returns true if token is now present, and false otherwise.
4248     * 
4249     * Throws a "SyntaxError" DOMException if token is empty.
4250     * 
4251     * Throws an "InvalidCharacterError" DOMException if token contains any spaces.
4252     */
4253    toggle(token: string, force?: boolean): boolean;
4254    forEach(callbackfn: (value: string, key: number, parent: DOMTokenList) => void, thisArg?: any): void;
4255    [index: number]: string;
4256}
4257
4258declare var DOMTokenList: {
4259    prototype: DOMTokenList;
4260    new(): DOMTokenList;
4261};
4262
4263interface DataCue extends TextTrackCue {
4264    data: ArrayBuffer;
4265    addEventListener<K extends keyof TextTrackCueEventMap>(type: K, listener: (this: DataCue, ev: TextTrackCueEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
4266    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
4267    removeEventListener<K extends keyof TextTrackCueEventMap>(type: K, listener: (this: DataCue, ev: TextTrackCueEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
4268    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
4269}
4270
4271declare var DataCue: {
4272    prototype: DataCue;
4273    new(): DataCue;
4274};
4275
4276/** Used to hold the data that is being dragged during a drag and drop operation. It may hold one or more data items, each of one or more data types. For more information about drag and drop, see HTML Drag and Drop API. */
4277interface DataTransfer {
4278    /**
4279     * Returns the kind of operation that is currently selected. If the kind of operation isn't one of those that is allowed by the effectAllowed attribute, then the operation will fail.
4280     * 
4281     * Can be set, to change the selected operation.
4282     * 
4283     * The possible values are "none", "copy", "link", and "move".
4284     */
4285    dropEffect: string;
4286    /**
4287     * Returns the kinds of operations that are to be allowed.
4288     * 
4289     * Can be set (during the dragstart event), to change the allowed operations.
4290     * 
4291     * The possible values are "none", "copy", "copyLink", "copyMove", "link", "linkMove", "move", "all", and "uninitialized",
4292     */
4293    effectAllowed: string;
4294    /**
4295     * Returns a FileList of the files being dragged, if any.
4296     */
4297    readonly files: FileList;
4298    /**
4299     * Returns a DataTransferItemList object, with the drag data.
4300     */
4301    readonly items: DataTransferItemList;
4302    /**
4303     * Returns a frozen array listing the formats that were set in the dragstart event. In addition, if any files are being dragged, then one of the types will be the string "Files".
4304     */
4305    readonly types: ReadonlyArray<string>;
4306    /**
4307     * Removes the data of the specified formats. Removes all data if the argument is omitted.
4308     */
4309    clearData(format?: string): void;
4310    /**
4311     * Returns the specified data. If there is no such data, returns the empty string.
4312     */
4313    getData(format: string): string;
4314    /**
4315     * Adds the specified data.
4316     */
4317    setData(format: string, data: string): void;
4318    /**
4319     * Uses the given element to update the drag feedback, replacing any previously specified feedback.
4320     */
4321    setDragImage(image: Element, x: number, y: number): void;
4322}
4323
4324declare var DataTransfer: {
4325    prototype: DataTransfer;
4326    new(): DataTransfer;
4327};
4328
4329/** One drag data item. During a drag operation, each drag event has a dataTransfer property which contains a list of drag data items. Each item in the list is a DataTransferItem object. */
4330interface DataTransferItem {
4331    /**
4332     * Returns the drag data item kind, one of: "string", "file".
4333     */
4334    readonly kind: string;
4335    /**
4336     * Returns the drag data item type string.
4337     */
4338    readonly type: string;
4339    /**
4340     * Returns a File object, if the drag data item kind is File.
4341     */
4342    getAsFile(): File | null;
4343    /**
4344     * Invokes the callback with the string data as the argument, if the drag data item kind is Plain Unicode string.
4345     */
4346    getAsString(callback: FunctionStringCallback | null): void;
4347    webkitGetAsEntry(): any;
4348}
4349
4350declare var DataTransferItem: {
4351    prototype: DataTransferItem;
4352    new(): DataTransferItem;
4353};
4354
4355/** A list of DataTransferItem objects representing items being dragged. During a drag operation, each DragEvent has a dataTransfer property and that property is a DataTransferItemList. */
4356interface DataTransferItemList {
4357    /**
4358     * Returns the number of items in the drag data store.
4359     */
4360    readonly length: number;
4361    /**
4362     * Adds a new entry for the given data to the drag data store. If the data is plain text then a type string has to be provided also.
4363     */
4364    add(data: string, type: string): DataTransferItem | null;
4365    add(data: File): DataTransferItem | null;
4366    /**
4367     * Removes all the entries in the drag data store.
4368     */
4369    clear(): void;
4370    item(index: number): DataTransferItem;
4371    /**
4372     * Removes the indexth entry in the drag data store.
4373     */
4374    remove(index: number): void;
4375    [name: number]: DataTransferItem;
4376}
4377
4378declare var DataTransferItemList: {
4379    prototype: DataTransferItemList;
4380    new(): DataTransferItemList;
4381};
4382
4383interface DeferredPermissionRequest {
4384    readonly id: number;
4385    readonly type: MSWebViewPermissionType;
4386    readonly uri: string;
4387    allow(): void;
4388    deny(): void;
4389}
4390
4391declare var DeferredPermissionRequest: {
4392    prototype: DeferredPermissionRequest;
4393    new(): DeferredPermissionRequest;
4394};
4395
4396/** A delay-line; an AudioNode audio-processing module that causes a delay between the arrival of an input data and its propagation to the output. */
4397interface DelayNode extends AudioNode {
4398    readonly delayTime: AudioParam;
4399}
4400
4401declare var DelayNode: {
4402    prototype: DelayNode;
4403    new(context: BaseAudioContext, options?: DelayOptions): DelayNode;
4404};
4405
4406/** Provides information about the amount of acceleration the device is experiencing along all three axes. */
4407interface DeviceAcceleration {
4408    readonly x: number | null;
4409    readonly y: number | null;
4410    readonly z: number | null;
4411}
4412
4413declare var DeviceAcceleration: {
4414    prototype: DeviceAcceleration;
4415    new(): DeviceAcceleration;
4416};
4417
4418/** The DeviceLightEvent provides web developers with information from photo sensors or similiar detectors about ambient light levels near the device. For example this may be useful to adjust the screen's brightness based on the current ambient light level in order to save energy or provide better readability. */
4419interface DeviceLightEvent extends Event {
4420    readonly value: number;
4421}
4422
4423declare var DeviceLightEvent: {
4424    prototype: DeviceLightEvent;
4425    new(typeArg: string, eventInitDict?: DeviceLightEventInit): DeviceLightEvent;
4426};
4427
4428/** The DeviceMotionEvent provides web developers with information about the speed of changes for the device's position and orientation. */
4429interface DeviceMotionEvent extends Event {
4430    readonly acceleration: DeviceMotionEventAcceleration | null;
4431    readonly accelerationIncludingGravity: DeviceMotionEventAcceleration | null;
4432    readonly interval: number;
4433    readonly rotationRate: DeviceMotionEventRotationRate | null;
4434}
4435
4436declare var DeviceMotionEvent: {
4437    prototype: DeviceMotionEvent;
4438    new(type: string, eventInitDict?: DeviceMotionEventInit): DeviceMotionEvent;
4439};
4440
4441interface DeviceMotionEventAcceleration {
4442    readonly x: number | null;
4443    readonly y: number | null;
4444    readonly z: number | null;
4445}
4446
4447interface DeviceMotionEventRotationRate {
4448    readonly alpha: number | null;
4449    readonly beta: number | null;
4450    readonly gamma: number | null;
4451}
4452
4453/** The DeviceOrientationEvent provides web developers with information from the physical orientation of the device running the web page. */
4454interface DeviceOrientationEvent extends Event {
4455    readonly absolute: boolean;
4456    readonly alpha: number | null;
4457    readonly beta: number | null;
4458    readonly gamma: number | null;
4459}
4460
4461declare var DeviceOrientationEvent: {
4462    prototype: DeviceOrientationEvent;
4463    new(type: string, eventInitDict?: DeviceOrientationEventInit): DeviceOrientationEvent;
4464};
4465
4466/** Provides information about the rate at which the device is rotating around all three axes. */
4467interface DeviceRotationRate {
4468    readonly alpha: number | null;
4469    readonly beta: number | null;
4470    readonly gamma: number | null;
4471}
4472
4473declare var DeviceRotationRate: {
4474    prototype: DeviceRotationRate;
4475    new(): DeviceRotationRate;
4476};
4477
4478interface DhImportKeyParams extends Algorithm {
4479    generator: Uint8Array;
4480    prime: Uint8Array;
4481}
4482
4483interface DhKeyAlgorithm extends KeyAlgorithm {
4484    generator: Uint8Array;
4485    prime: Uint8Array;
4486}
4487
4488interface DhKeyDeriveParams extends Algorithm {
4489    public: CryptoKey;
4490}
4491
4492interface DhKeyGenParams extends Algorithm {
4493    generator: Uint8Array;
4494    prime: Uint8Array;
4495}
4496
4497interface DocumentEventMap extends GlobalEventHandlersEventMap, DocumentAndElementEventHandlersEventMap {
4498    "fullscreenchange": Event;
4499    "fullscreenerror": Event;
4500    "pointerlockchange": Event;
4501    "pointerlockerror": Event;
4502    "readystatechange": ProgressEvent<Document>;
4503    "visibilitychange": Event;
4504}
4505
4506/** Any web page loaded in the browser and serves as an entry point into the web page's content, which is the DOM tree. */
4507interface Document extends Node, DocumentAndElementEventHandlers, DocumentOrShadowRoot, GlobalEventHandlers, NonElementParentNode, ParentNode, XPathEvaluatorBase {
4508    /**
4509     * Sets or gets the URL for the current document.
4510     */
4511    readonly URL: string;
4512    /**
4513     * Gets the object that has the focus when the parent document has focus.
4514     */
4515    readonly activeElement: Element | null;
4516    /**
4517     * Sets or gets the color of all active links in the document.
4518     */
4519    /** @deprecated */
4520    alinkColor: string;
4521    /**
4522     * Returns a reference to the collection of elements contained by the object.
4523     */
4524    /** @deprecated */
4525    readonly all: HTMLAllCollection;
4526    /**
4527     * Retrieves a collection of all a objects that have a name and/or id property. Objects in this collection are in HTML source order.
4528     */
4529    /** @deprecated */
4530    readonly anchors: HTMLCollectionOf<HTMLAnchorElement>;
4531    /**
4532     * Retrieves a collection of all applet objects in the document.
4533     */
4534    /** @deprecated */
4535    readonly applets: HTMLCollectionOf<HTMLAppletElement>;
4536    /**
4537     * Deprecated. Sets or retrieves a value that indicates the background color behind the object.
4538     */
4539    /** @deprecated */
4540    bgColor: string;
4541    /**
4542     * Specifies the beginning and end of the document body.
4543     */
4544    body: HTMLElement;
4545    /**
4546     * Returns document's encoding.
4547     */
4548    readonly characterSet: string;
4549    /**
4550     * Gets or sets the character set used to encode the object.
4551     */
4552    readonly charset: string;
4553    /**
4554     * Gets a value that indicates whether standards-compliant mode is switched on for the object.
4555     */
4556    readonly compatMode: string;
4557    /**
4558     * Returns document's content type.
4559     */
4560    readonly contentType: string;
4561    /**
4562     * Returns the HTTP cookies that apply to the Document. If there are no cookies or cookies can't be applied to this resource, the empty string will be returned.
4563     * 
4564     * Can be set, to add a new cookie to the element's set of HTTP cookies.
4565     * 
4566     * If the contents are sandboxed into a unique origin (e.g. in an iframe with the sandbox attribute), a "SecurityError" DOMException will be thrown on getting and setting.
4567     */
4568    cookie: string;
4569    /**
4570     * Returns the script element, or the SVG script element, that is currently executing, as long as the element represents a classic script. In the case of reentrant script execution, returns the one that most recently started executing amongst those that have not yet finished executing.
4571     * 
4572     * Returns null if the Document is not currently executing a script or SVG script element (e.g., because the running script is an event handler, or a timeout), or if the currently executing script or SVG script element represents a module script.
4573     */
4574    readonly currentScript: HTMLOrSVGScriptElement | null;
4575    readonly defaultView: WindowProxy | null;
4576    /**
4577     * Sets or gets a value that indicates whether the document can be edited.
4578     */
4579    designMode: string;
4580    /**
4581     * Sets or retrieves a value that indicates the reading order of the object.
4582     */
4583    dir: string;
4584    /**
4585     * Gets an object representing the document type declaration associated with the current document.
4586     */
4587    readonly doctype: DocumentType | null;
4588    /**
4589     * Gets a reference to the root node of the document.
4590     */
4591    readonly documentElement: HTMLElement;
4592    /**
4593     * Returns document's URL.
4594     */
4595    readonly documentURI: string;
4596    /**
4597     * Sets or gets the security domain of the document.
4598     */
4599    domain: string;
4600    /**
4601     * Retrieves a collection of all embed objects in the document.
4602     */
4603    readonly embeds: HTMLCollectionOf<HTMLEmbedElement>;
4604    /**
4605     * Sets or gets the foreground (text) color of the document.
4606     */
4607    /** @deprecated */
4608    fgColor: string;
4609    /**
4610     * Retrieves a collection, in source order, of all form objects in the document.
4611     */
4612    readonly forms: HTMLCollectionOf<HTMLFormElement>;
4613    /** @deprecated */
4614    readonly fullscreen: boolean;
4615    /**
4616     * Returns true if document has the ability to display elements fullscreen and fullscreen is supported, or false otherwise.
4617     */
4618    readonly fullscreenEnabled: boolean;
4619    /**
4620     * Returns the head element.
4621     */
4622    readonly head: HTMLHeadElement;
4623    readonly hidden: boolean;
4624    /**
4625     * Retrieves a collection, in source order, of img objects in the document.
4626     */
4627    readonly images: HTMLCollectionOf<HTMLImageElement>;
4628    /**
4629     * Gets the implementation object of the current document.
4630     */
4631    readonly implementation: DOMImplementation;
4632    /**
4633     * Returns the character encoding used to create the webpage that is loaded into the document object.
4634     */
4635    readonly inputEncoding: string;
4636    /**
4637     * Gets the date that the page was last modified, if the page supplies one.
4638     */
4639    readonly lastModified: string;
4640    /**
4641     * Sets or gets the color of the document links.
4642     */
4643    /** @deprecated */
4644    linkColor: string;
4645    /**
4646     * Retrieves a collection of all a objects that specify the href property and all area objects in the document.
4647     */
4648    readonly links: HTMLCollectionOf<HTMLAnchorElement | HTMLAreaElement>;
4649    /**
4650     * Contains information about the current URL.
4651     */
4652    location: Location;
4653    onfullscreenchange: ((this: Document, ev: Event) => any) | null;
4654    onfullscreenerror: ((this: Document, ev: Event) => any) | null;
4655    onpointerlockchange: ((this: Document, ev: Event) => any) | null;
4656    onpointerlockerror: ((this: Document, ev: Event) => any) | null;
4657    /**
4658     * Fires when the state of the object has changed.
4659     * @param ev The event
4660     */
4661    onreadystatechange: ((this: Document, ev: ProgressEvent<Document>) => any) | null;
4662    onvisibilitychange: ((this: Document, ev: Event) => any) | null;
4663    /**
4664     * Returns document's origin.
4665     */
4666    readonly origin: string;
4667    /**
4668     * Return an HTMLCollection of the embed elements in the Document.
4669     */
4670    readonly plugins: HTMLCollectionOf<HTMLEmbedElement>;
4671    /**
4672     * Retrieves a value that indicates the current state of the object.
4673     */
4674    readonly readyState: DocumentReadyState;
4675    /**
4676     * Gets the URL of the location that referred the user to the current page.
4677     */
4678    readonly referrer: string;
4679    /**
4680     * Retrieves a collection of all script objects in the document.
4681     */
4682    readonly scripts: HTMLCollectionOf<HTMLScriptElement>;
4683    readonly scrollingElement: Element | null;
4684    readonly timeline: DocumentTimeline;
4685    /**
4686     * Contains the title of the document.
4687     */
4688    title: string;
4689    readonly visibilityState: VisibilityState;
4690    /**
4691     * Sets or gets the color of the links that the user has visited.
4692     */
4693    /** @deprecated */
4694    vlinkColor: string;
4695    /**
4696     * Moves node from another document and returns it.
4697     * 
4698     * If node is a document, throws a "NotSupportedError" DOMException or, if node is a shadow root, throws a "HierarchyRequestError" DOMException.
4699     */
4700    adoptNode<T extends Node>(source: T): T;
4701    /** @deprecated */
4702    captureEvents(): void;
4703    caretPositionFromPoint(x: number, y: number): CaretPosition | null;
4704    /** @deprecated */
4705    caretRangeFromPoint(x: number, y: number): Range;
4706    /** @deprecated */
4707    clear(): void;
4708    /**
4709     * Closes an output stream and forces the sent data to display.
4710     */
4711    close(): void;
4712    /**
4713     * Creates an attribute object with a specified name.
4714     * @param name String that sets the attribute object's name.
4715     */
4716    createAttribute(localName: string): Attr;
4717    createAttributeNS(namespace: string | null, qualifiedName: string): Attr;
4718    /**
4719     * Returns a CDATASection node whose data is data.
4720     */
4721    createCDATASection(data: string): CDATASection;
4722    /**
4723     * Creates a comment object with the specified data.
4724     * @param data Sets the comment object's data.
4725     */
4726    createComment(data: string): Comment;
4727    /**
4728     * Creates a new document.
4729     */
4730    createDocumentFragment(): DocumentFragment;
4731    /**
4732     * Creates an instance of the element for the specified tag.
4733     * @param tagName The name of an element.
4734     */
4735    createElement<K extends keyof HTMLElementTagNameMap>(tagName: K, options?: ElementCreationOptions): HTMLElementTagNameMap[K];
4736    /** @deprecated */
4737    createElement<K extends keyof HTMLElementDeprecatedTagNameMap>(tagName: K, options?: ElementCreationOptions): HTMLElementDeprecatedTagNameMap[K];
4738    createElement(tagName: string, options?: ElementCreationOptions): HTMLElement;
4739    /**
4740     * Returns an element with namespace namespace. Its namespace prefix will be everything before ":" (U+003E) in qualifiedName or null. Its local name will be everything after ":" (U+003E) in qualifiedName or qualifiedName.
4741     * 
4742     * If localName does not match the Name production an "InvalidCharacterError" DOMException will be thrown.
4743     * 
4744     * If one of the following conditions is true a "NamespaceError" DOMException will be thrown:
4745     * 
4746     * localName does not match the QName production.
4747     * Namespace prefix is not null and namespace is the empty string.
4748     * Namespace prefix is "xml" and namespace is not the XML namespace.
4749     * qualifiedName or namespace prefix is "xmlns" and namespace is not the XMLNS namespace.
4750     * namespace is the XMLNS namespace and neither qualifiedName nor namespace prefix is "xmlns".
4751     * 
4752     * When supplied, options's is can be used to create a customized built-in element.
4753     */
4754    createElementNS(namespaceURI: "http://www.w3.org/1999/xhtml", qualifiedName: string): HTMLElement;
4755    createElementNS<K extends keyof SVGElementTagNameMap>(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: K): SVGElementTagNameMap[K];
4756    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: string): SVGElement;
4757    createElementNS(namespaceURI: string | null, qualifiedName: string, options?: ElementCreationOptions): Element;
4758    createElementNS(namespace: string | null, qualifiedName: string, options?: string | ElementCreationOptions): Element;
4759    createEvent(eventInterface: "AnimationEvent"): AnimationEvent;
4760    createEvent(eventInterface: "AnimationPlaybackEvent"): AnimationPlaybackEvent;
4761    createEvent(eventInterface: "AudioProcessingEvent"): AudioProcessingEvent;
4762    createEvent(eventInterface: "BeforeUnloadEvent"): BeforeUnloadEvent;
4763    createEvent(eventInterface: "ClipboardEvent"): ClipboardEvent;
4764    createEvent(eventInterface: "CloseEvent"): CloseEvent;
4765    createEvent(eventInterface: "CompositionEvent"): CompositionEvent;
4766    createEvent(eventInterface: "CustomEvent"): CustomEvent;
4767    createEvent(eventInterface: "DeviceLightEvent"): DeviceLightEvent;
4768    createEvent(eventInterface: "DeviceMotionEvent"): DeviceMotionEvent;
4769    createEvent(eventInterface: "DeviceOrientationEvent"): DeviceOrientationEvent;
4770    createEvent(eventInterface: "DragEvent"): DragEvent;
4771    createEvent(eventInterface: "ErrorEvent"): ErrorEvent;
4772    createEvent(eventInterface: "Event"): Event;
4773    createEvent(eventInterface: "Events"): Event;
4774    createEvent(eventInterface: "FocusEvent"): FocusEvent;
4775    createEvent(eventInterface: "FocusNavigationEvent"): FocusNavigationEvent;
4776    createEvent(eventInterface: "GamepadEvent"): GamepadEvent;
4777    createEvent(eventInterface: "HashChangeEvent"): HashChangeEvent;
4778    createEvent(eventInterface: "IDBVersionChangeEvent"): IDBVersionChangeEvent;
4779    createEvent(eventInterface: "InputEvent"): InputEvent;
4780    createEvent(eventInterface: "KeyboardEvent"): KeyboardEvent;
4781    createEvent(eventInterface: "ListeningStateChangedEvent"): ListeningStateChangedEvent;
4782    createEvent(eventInterface: "MSGestureEvent"): MSGestureEvent;
4783    createEvent(eventInterface: "MSMediaKeyMessageEvent"): MSMediaKeyMessageEvent;
4784    createEvent(eventInterface: "MSMediaKeyNeededEvent"): MSMediaKeyNeededEvent;
4785    createEvent(eventInterface: "MSPointerEvent"): MSPointerEvent;
4786    createEvent(eventInterface: "MediaEncryptedEvent"): MediaEncryptedEvent;
4787    createEvent(eventInterface: "MediaKeyMessageEvent"): MediaKeyMessageEvent;
4788    createEvent(eventInterface: "MediaQueryListEvent"): MediaQueryListEvent;
4789    createEvent(eventInterface: "MediaStreamErrorEvent"): MediaStreamErrorEvent;
4790    createEvent(eventInterface: "MediaStreamEvent"): MediaStreamEvent;
4791    createEvent(eventInterface: "MediaStreamTrackEvent"): MediaStreamTrackEvent;
4792    createEvent(eventInterface: "MessageEvent"): MessageEvent;
4793    createEvent(eventInterface: "MouseEvent"): MouseEvent;
4794    createEvent(eventInterface: "MouseEvents"): MouseEvent;
4795    createEvent(eventInterface: "MutationEvent"): MutationEvent;
4796    createEvent(eventInterface: "MutationEvents"): MutationEvent;
4797    createEvent(eventInterface: "OfflineAudioCompletionEvent"): OfflineAudioCompletionEvent;
4798    createEvent(eventInterface: "OverflowEvent"): OverflowEvent;
4799    createEvent(eventInterface: "PageTransitionEvent"): PageTransitionEvent;
4800    createEvent(eventInterface: "PaymentRequestUpdateEvent"): PaymentRequestUpdateEvent;
4801    createEvent(eventInterface: "PermissionRequestedEvent"): PermissionRequestedEvent;
4802    createEvent(eventInterface: "PointerEvent"): PointerEvent;
4803    createEvent(eventInterface: "PopStateEvent"): PopStateEvent;
4804    createEvent(eventInterface: "ProgressEvent"): ProgressEvent;
4805    createEvent(eventInterface: "PromiseRejectionEvent"): PromiseRejectionEvent;
4806    createEvent(eventInterface: "RTCDTMFToneChangeEvent"): RTCDTMFToneChangeEvent;
4807    createEvent(eventInterface: "RTCDataChannelEvent"): RTCDataChannelEvent;
4808    createEvent(eventInterface: "RTCDtlsTransportStateChangedEvent"): RTCDtlsTransportStateChangedEvent;
4809    createEvent(eventInterface: "RTCErrorEvent"): RTCErrorEvent;
4810    createEvent(eventInterface: "RTCIceCandidatePairChangedEvent"): RTCIceCandidatePairChangedEvent;
4811    createEvent(eventInterface: "RTCIceGathererEvent"): RTCIceGathererEvent;
4812    createEvent(eventInterface: "RTCIceTransportStateChangedEvent"): RTCIceTransportStateChangedEvent;
4813    createEvent(eventInterface: "RTCPeerConnectionIceErrorEvent"): RTCPeerConnectionIceErrorEvent;
4814    createEvent(eventInterface: "RTCPeerConnectionIceEvent"): RTCPeerConnectionIceEvent;
4815    createEvent(eventInterface: "RTCSsrcConflictEvent"): RTCSsrcConflictEvent;
4816    createEvent(eventInterface: "RTCStatsEvent"): RTCStatsEvent;
4817    createEvent(eventInterface: "RTCTrackEvent"): RTCTrackEvent;
4818    createEvent(eventInterface: "SVGZoomEvent"): SVGZoomEvent;
4819    createEvent(eventInterface: "SVGZoomEvents"): SVGZoomEvent;
4820    createEvent(eventInterface: "SecurityPolicyViolationEvent"): SecurityPolicyViolationEvent;
4821    createEvent(eventInterface: "ServiceWorkerMessageEvent"): ServiceWorkerMessageEvent;
4822    createEvent(eventInterface: "SpeechRecognitionError"): SpeechRecognitionError;
4823    createEvent(eventInterface: "SpeechRecognitionEvent"): SpeechRecognitionEvent;
4824    createEvent(eventInterface: "SpeechSynthesisErrorEvent"): SpeechSynthesisErrorEvent;
4825    createEvent(eventInterface: "SpeechSynthesisEvent"): SpeechSynthesisEvent;
4826    createEvent(eventInterface: "StorageEvent"): StorageEvent;
4827    createEvent(eventInterface: "TextEvent"): TextEvent;
4828    createEvent(eventInterface: "TouchEvent"): TouchEvent;
4829    createEvent(eventInterface: "TrackEvent"): TrackEvent;
4830    createEvent(eventInterface: "TransitionEvent"): TransitionEvent;
4831    createEvent(eventInterface: "UIEvent"): UIEvent;
4832    createEvent(eventInterface: "UIEvents"): UIEvent;
4833    createEvent(eventInterface: "VRDisplayEvent"): VRDisplayEvent;
4834    createEvent(eventInterface: "VRDisplayEvent "): VRDisplayEvent ;
4835    createEvent(eventInterface: "WebGLContextEvent"): WebGLContextEvent;
4836    createEvent(eventInterface: "WheelEvent"): WheelEvent;
4837    createEvent(eventInterface: string): Event;
4838    /**
4839     * Creates a NodeIterator object that you can use to traverse filtered lists of nodes or elements in a document.
4840     * @param root The root element or node to start traversing on.
4841     * @param whatToShow The type of nodes or elements to appear in the node list
4842     * @param filter A custom NodeFilter function to use. For more information, see filter. Use null for no filter.
4843     * @param entityReferenceExpansion A flag that specifies whether entity reference nodes are expanded.
4844     */
4845    createNodeIterator(root: Node, whatToShow?: number, filter?: NodeFilter | null): NodeIterator;
4846    /**
4847     * Returns a ProcessingInstruction node whose target is target and data is data. If target does not match the Name production an "InvalidCharacterError" DOMException will be thrown. If data contains "?>" an "InvalidCharacterError" DOMException will be thrown.
4848     */
4849    createProcessingInstruction(target: string, data: string): ProcessingInstruction;
4850    /**
4851     *  Returns an empty range object that has both of its boundary points positioned at the beginning of the document.
4852     */
4853    createRange(): Range;
4854    /**
4855     * Creates a text string from the specified value.
4856     * @param data String that specifies the nodeValue property of the text node.
4857     */
4858    createTextNode(data: string): Text;
4859    /**
4860     * Creates a TreeWalker object that you can use to traverse filtered lists of nodes or elements in a document.
4861     * @param root The root element or node to start traversing on.
4862     * @param whatToShow The type of nodes or elements to appear in the node list. For more information, see whatToShow.
4863     * @param filter A custom NodeFilter function to use.
4864     * @param entityReferenceExpansion A flag that specifies whether entity reference nodes are expanded.
4865     */
4866    createTreeWalker(root: Node, whatToShow?: number, filter?: NodeFilter | null): TreeWalker;
4867    /** @deprecated */
4868    createTreeWalker(root: Node, whatToShow: number, filter: NodeFilter | null, entityReferenceExpansion?: boolean): TreeWalker;
4869    /**
4870     * Returns the element for the specified x coordinate and the specified y coordinate.
4871     * @param x The x-offset
4872     * @param y The y-offset
4873     */
4874    elementFromPoint(x: number, y: number): Element | null;
4875    elementsFromPoint(x: number, y: number): Element[];
4876    /**
4877     * Executes a command on the current document, current selection, or the given range.
4878     * @param commandId String that specifies the command to execute. This command can be any of the command identifiers that can be executed in script.
4879     * @param showUI Display the user interface, defaults to false.
4880     * @param value Value to assign.
4881     */
4882    execCommand(commandId: string, showUI?: boolean, value?: string): boolean;
4883    /**
4884     * Stops document's fullscreen element from being displayed fullscreen and resolves promise when done.
4885     */
4886    exitFullscreen(): Promise<void>;
4887    exitPointerLock(): void;
4888    getAnimations(): Animation[];
4889    /**
4890     * Returns a reference to the first object with the specified value of the ID or NAME attribute.
4891     * @param elementId String that specifies the ID value. Case-insensitive.
4892     */
4893    getElementById(elementId: string): HTMLElement | null;
4894    /**
4895     * Returns a HTMLCollection of the elements in the object on which the method was invoked (a document or an element) that have all the classes given by classNames. The classNames argument is interpreted as a space-separated list of classes.
4896     */
4897    getElementsByClassName(classNames: string): HTMLCollectionOf<Element>;
4898    /**
4899     * Gets a collection of objects based on the value of the NAME or ID attribute.
4900     * @param elementName Gets a collection of objects based on the value of the NAME or ID attribute.
4901     */
4902    getElementsByName(elementName: string): NodeListOf<HTMLElement>;
4903    /**
4904     * Retrieves a collection of objects based on the specified element name.
4905     * @param name Specifies the name of an element.
4906     */
4907    getElementsByTagName<K extends keyof HTMLElementTagNameMap>(qualifiedName: K): HTMLCollectionOf<HTMLElementTagNameMap[K]>;
4908    getElementsByTagName<K extends keyof SVGElementTagNameMap>(qualifiedName: K): HTMLCollectionOf<SVGElementTagNameMap[K]>;
4909    getElementsByTagName(qualifiedName: string): HTMLCollectionOf<Element>;
4910    /**
4911     * If namespace and localName are "*" returns a HTMLCollection of all descendant elements.
4912     * 
4913     * If only namespace is "*" returns a HTMLCollection of all descendant elements whose local name is localName.
4914     * 
4915     * If only localName is "*" returns a HTMLCollection of all descendant elements whose namespace is namespace.
4916     * 
4917     * Otherwise, returns a HTMLCollection of all descendant elements whose namespace is namespace and local name is localName.
4918     */
4919    getElementsByTagNameNS(namespaceURI: "http://www.w3.org/1999/xhtml", localName: string): HTMLCollectionOf<HTMLElement>;
4920    getElementsByTagNameNS(namespaceURI: "http://www.w3.org/2000/svg", localName: string): HTMLCollectionOf<SVGElement>;
4921    getElementsByTagNameNS(namespaceURI: string, localName: string): HTMLCollectionOf<Element>;
4922    /**
4923     * Returns an object representing the current selection of the document that is loaded into the object displaying a webpage.
4924     */
4925    getSelection(): Selection | null;
4926    /**
4927     * Gets a value indicating whether the object currently has focus.
4928     */
4929    hasFocus(): boolean;
4930    /**
4931     * Returns a copy of node. If deep is true, the copy also includes the node's descendants.
4932     * 
4933     * If node is a document or a shadow root, throws a "NotSupportedError" DOMException.
4934     */
4935    importNode<T extends Node>(importedNode: T, deep: boolean): T;
4936    /**
4937     * Opens a new window and loads a document specified by a given URL. Also, opens a new window that uses the url parameter and the name parameter to collect the output of the write method and the writeln method.
4938     * @param url Specifies a MIME type for the document.
4939     * @param name Specifies the name of the window. This name is used as the value for the TARGET attribute on a form or an anchor element.
4940     * @param features Contains a list of items separated by commas. Each item consists of an option and a value, separated by an equals sign (for example, "fullscreen=yes, toolbar=yes"). The following values are supported.
4941     * @param replace Specifies whether the existing entry for the document is replaced in the history list.
4942     */
4943    open(url?: string, name?: string, features?: string, replace?: boolean): Document;
4944    /**
4945     * Returns a Boolean value that indicates whether a specified command can be successfully executed using execCommand, given the current state of the document.
4946     * @param commandId Specifies a command identifier.
4947     */
4948    queryCommandEnabled(commandId: string): boolean;
4949    /**
4950     * Returns a Boolean value that indicates whether the specified command is in the indeterminate state.
4951     * @param commandId String that specifies a command identifier.
4952     */
4953    queryCommandIndeterm(commandId: string): boolean;
4954    /**
4955     * Returns a Boolean value that indicates the current state of the command.
4956     * @param commandId String that specifies a command identifier.
4957     */
4958    queryCommandState(commandId: string): boolean;
4959    /**
4960     * Returns a Boolean value that indicates whether the current command is supported on the current range.
4961     * @param commandId Specifies a command identifier.
4962     */
4963    queryCommandSupported(commandId: string): boolean;
4964    /**
4965     * Returns the current value of the document, range, or current selection for the given command.
4966     * @param commandId String that specifies a command identifier.
4967     */
4968    queryCommandValue(commandId: string): string;
4969    /** @deprecated */
4970    releaseEvents(): void;
4971    /**
4972     * Writes one or more HTML expressions to a document in the specified window.
4973     * @param content Specifies the text and HTML tags to write.
4974     */
4975    write(...text: string[]): void;
4976    /**
4977     * Writes one or more HTML expressions, followed by a carriage return, to a document in the specified window.
4978     * @param content The text and HTML tags to write.
4979     */
4980    writeln(...text: string[]): void;
4981    addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
4982    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
4983    removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
4984    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
4985}
4986
4987declare var Document: {
4988    prototype: Document;
4989    new(): Document;
4990};
4991
4992interface DocumentAndElementEventHandlersEventMap {
4993    "copy": ClipboardEvent;
4994    "cut": ClipboardEvent;
4995    "paste": ClipboardEvent;
4996}
4997
4998interface DocumentAndElementEventHandlers {
4999    oncopy: ((this: DocumentAndElementEventHandlers, ev: ClipboardEvent) => any) | null;
5000    oncut: ((this: DocumentAndElementEventHandlers, ev: ClipboardEvent) => any) | null;
5001    onpaste: ((this: DocumentAndElementEventHandlers, ev: ClipboardEvent) => any) | null;
5002    addEventListener<K extends keyof DocumentAndElementEventHandlersEventMap>(type: K, listener: (this: DocumentAndElementEventHandlers, ev: DocumentAndElementEventHandlersEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
5003    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
5004    removeEventListener<K extends keyof DocumentAndElementEventHandlersEventMap>(type: K, listener: (this: DocumentAndElementEventHandlers, ev: DocumentAndElementEventHandlersEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
5005    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
5006}
5007
5008interface DocumentEvent {
5009    createEvent(eventInterface: "AnimationEvent"): AnimationEvent;
5010    createEvent(eventInterface: "AnimationPlaybackEvent"): AnimationPlaybackEvent;
5011    createEvent(eventInterface: "AudioProcessingEvent"): AudioProcessingEvent;
5012    createEvent(eventInterface: "BeforeUnloadEvent"): BeforeUnloadEvent;
5013    createEvent(eventInterface: "ClipboardEvent"): ClipboardEvent;
5014    createEvent(eventInterface: "CloseEvent"): CloseEvent;
5015    createEvent(eventInterface: "CompositionEvent"): CompositionEvent;
5016    createEvent(eventInterface: "CustomEvent"): CustomEvent;
5017    createEvent(eventInterface: "DeviceLightEvent"): DeviceLightEvent;
5018    createEvent(eventInterface: "DeviceMotionEvent"): DeviceMotionEvent;
5019    createEvent(eventInterface: "DeviceOrientationEvent"): DeviceOrientationEvent;
5020    createEvent(eventInterface: "DragEvent"): DragEvent;
5021    createEvent(eventInterface: "ErrorEvent"): ErrorEvent;
5022    createEvent(eventInterface: "Event"): Event;
5023    createEvent(eventInterface: "Events"): Event;
5024    createEvent(eventInterface: "FocusEvent"): FocusEvent;
5025    createEvent(eventInterface: "FocusNavigationEvent"): FocusNavigationEvent;
5026    createEvent(eventInterface: "GamepadEvent"): GamepadEvent;
5027    createEvent(eventInterface: "HashChangeEvent"): HashChangeEvent;
5028    createEvent(eventInterface: "IDBVersionChangeEvent"): IDBVersionChangeEvent;
5029    createEvent(eventInterface: "InputEvent"): InputEvent;
5030    createEvent(eventInterface: "KeyboardEvent"): KeyboardEvent;
5031    createEvent(eventInterface: "ListeningStateChangedEvent"): ListeningStateChangedEvent;
5032    createEvent(eventInterface: "MSGestureEvent"): MSGestureEvent;
5033    createEvent(eventInterface: "MSMediaKeyMessageEvent"): MSMediaKeyMessageEvent;
5034    createEvent(eventInterface: "MSMediaKeyNeededEvent"): MSMediaKeyNeededEvent;
5035    createEvent(eventInterface: "MSPointerEvent"): MSPointerEvent;
5036    createEvent(eventInterface: "MediaEncryptedEvent"): MediaEncryptedEvent;
5037    createEvent(eventInterface: "MediaKeyMessageEvent"): MediaKeyMessageEvent;
5038    createEvent(eventInterface: "MediaQueryListEvent"): MediaQueryListEvent;
5039    createEvent(eventInterface: "MediaStreamErrorEvent"): MediaStreamErrorEvent;
5040    createEvent(eventInterface: "MediaStreamEvent"): MediaStreamEvent;
5041    createEvent(eventInterface: "MediaStreamTrackEvent"): MediaStreamTrackEvent;
5042    createEvent(eventInterface: "MessageEvent"): MessageEvent;
5043    createEvent(eventInterface: "MouseEvent"): MouseEvent;
5044    createEvent(eventInterface: "MouseEvents"): MouseEvent;
5045    createEvent(eventInterface: "MutationEvent"): MutationEvent;
5046    createEvent(eventInterface: "MutationEvents"): MutationEvent;
5047    createEvent(eventInterface: "OfflineAudioCompletionEvent"): OfflineAudioCompletionEvent;
5048    createEvent(eventInterface: "OverflowEvent"): OverflowEvent;
5049    createEvent(eventInterface: "PageTransitionEvent"): PageTransitionEvent;
5050    createEvent(eventInterface: "PaymentRequestUpdateEvent"): PaymentRequestUpdateEvent;
5051    createEvent(eventInterface: "PermissionRequestedEvent"): PermissionRequestedEvent;
5052    createEvent(eventInterface: "PointerEvent"): PointerEvent;
5053    createEvent(eventInterface: "PopStateEvent"): PopStateEvent;
5054    createEvent(eventInterface: "ProgressEvent"): ProgressEvent;
5055    createEvent(eventInterface: "PromiseRejectionEvent"): PromiseRejectionEvent;
5056    createEvent(eventInterface: "RTCDTMFToneChangeEvent"): RTCDTMFToneChangeEvent;
5057    createEvent(eventInterface: "RTCDataChannelEvent"): RTCDataChannelEvent;
5058    createEvent(eventInterface: "RTCDtlsTransportStateChangedEvent"): RTCDtlsTransportStateChangedEvent;
5059    createEvent(eventInterface: "RTCErrorEvent"): RTCErrorEvent;
5060    createEvent(eventInterface: "RTCIceCandidatePairChangedEvent"): RTCIceCandidatePairChangedEvent;
5061    createEvent(eventInterface: "RTCIceGathererEvent"): RTCIceGathererEvent;
5062    createEvent(eventInterface: "RTCIceTransportStateChangedEvent"): RTCIceTransportStateChangedEvent;
5063    createEvent(eventInterface: "RTCPeerConnectionIceErrorEvent"): RTCPeerConnectionIceErrorEvent;
5064    createEvent(eventInterface: "RTCPeerConnectionIceEvent"): RTCPeerConnectionIceEvent;
5065    createEvent(eventInterface: "RTCSsrcConflictEvent"): RTCSsrcConflictEvent;
5066    createEvent(eventInterface: "RTCStatsEvent"): RTCStatsEvent;
5067    createEvent(eventInterface: "RTCTrackEvent"): RTCTrackEvent;
5068    createEvent(eventInterface: "SVGZoomEvent"): SVGZoomEvent;
5069    createEvent(eventInterface: "SVGZoomEvents"): SVGZoomEvent;
5070    createEvent(eventInterface: "SecurityPolicyViolationEvent"): SecurityPolicyViolationEvent;
5071    createEvent(eventInterface: "ServiceWorkerMessageEvent"): ServiceWorkerMessageEvent;
5072    createEvent(eventInterface: "SpeechRecognitionError"): SpeechRecognitionError;
5073    createEvent(eventInterface: "SpeechRecognitionEvent"): SpeechRecognitionEvent;
5074    createEvent(eventInterface: "SpeechSynthesisErrorEvent"): SpeechSynthesisErrorEvent;
5075    createEvent(eventInterface: "SpeechSynthesisEvent"): SpeechSynthesisEvent;
5076    createEvent(eventInterface: "StorageEvent"): StorageEvent;
5077    createEvent(eventInterface: "TextEvent"): TextEvent;
5078    createEvent(eventInterface: "TouchEvent"): TouchEvent;
5079    createEvent(eventInterface: "TrackEvent"): TrackEvent;
5080    createEvent(eventInterface: "TransitionEvent"): TransitionEvent;
5081    createEvent(eventInterface: "UIEvent"): UIEvent;
5082    createEvent(eventInterface: "UIEvents"): UIEvent;
5083    createEvent(eventInterface: "VRDisplayEvent"): VRDisplayEvent;
5084    createEvent(eventInterface: "VRDisplayEvent "): VRDisplayEvent ;
5085    createEvent(eventInterface: "WebGLContextEvent"): WebGLContextEvent;
5086    createEvent(eventInterface: "WheelEvent"): WheelEvent;
5087    createEvent(eventInterface: string): Event;
5088}
5089
5090/** A minimal document object that has no parent. It is used as a lightweight version of Document that stores a segment of a document structure comprised of nodes just like a standard document. The key difference is that because the document fragment isn't part of the active document tree structure, changes made to the fragment don't affect the document, cause reflow, or incur any performance impact that can occur when changes are made. */
5091interface DocumentFragment extends Node, NonElementParentNode, ParentNode {
5092    getElementById(elementId: string): HTMLElement | null;
5093}
5094
5095declare var DocumentFragment: {
5096    prototype: DocumentFragment;
5097    new(): DocumentFragment;
5098};
5099
5100interface DocumentOrShadowRoot {
5101    readonly activeElement: Element | null;
5102    /**
5103     * Returns document's fullscreen element.
5104     */
5105    readonly fullscreenElement: Element | null;
5106    readonly pointerLockElement: Element | null;
5107    /**
5108     * Retrieves a collection of styleSheet objects representing the style sheets that correspond to each instance of a link or style object in the document.
5109     */
5110    readonly styleSheets: StyleSheetList;
5111    caretPositionFromPoint(x: number, y: number): CaretPosition | null;
5112    /** @deprecated */
5113    caretRangeFromPoint(x: number, y: number): Range;
5114    elementFromPoint(x: number, y: number): Element | null;
5115    elementsFromPoint(x: number, y: number): Element[];
5116    getSelection(): Selection | null;
5117}
5118
5119interface DocumentTimeline extends AnimationTimeline {
5120}
5121
5122declare var DocumentTimeline: {
5123    prototype: DocumentTimeline;
5124    new(options?: DocumentTimelineOptions): DocumentTimeline;
5125};
5126
5127/** A Node containing a doctype. */
5128interface DocumentType extends Node, ChildNode {
5129    readonly name: string;
5130    readonly publicId: string;
5131    readonly systemId: string;
5132}
5133
5134declare var DocumentType: {
5135    prototype: DocumentType;
5136    new(): DocumentType;
5137};
5138
5139/** A DOM event that represents a drag and drop interaction. The user initiates a drag by placing a pointer device (such as a mouse) on the touch surface and then dragging the pointer to a new location (such as another DOM element). Applications are free to interpret a drag and drop interaction in an application-specific way. */
5140interface DragEvent extends MouseEvent {
5141    /**
5142     * Returns the DataTransfer object for the event.
5143     */
5144    readonly dataTransfer: DataTransfer | null;
5145}
5146
5147declare var DragEvent: {
5148    prototype: DragEvent;
5149    new(type: string, eventInitDict?: DragEventInit): DragEvent;
5150};
5151
5152/** Inherits properties from its parent, AudioNode. */
5153interface DynamicsCompressorNode extends AudioNode {
5154    readonly attack: AudioParam;
5155    readonly knee: AudioParam;
5156    readonly ratio: AudioParam;
5157    readonly reduction: number;
5158    readonly release: AudioParam;
5159    readonly threshold: AudioParam;
5160}
5161
5162declare var DynamicsCompressorNode: {
5163    prototype: DynamicsCompressorNode;
5164    new(context: BaseAudioContext, options?: DynamicsCompressorOptions): DynamicsCompressorNode;
5165};
5166
5167interface EXT_blend_minmax {
5168    readonly MAX_EXT: GLenum;
5169    readonly MIN_EXT: GLenum;
5170}
5171
5172/** The EXT_frag_depth extension is part of the WebGL API and enables to set a depth value of a fragment from within the fragment shader. */
5173interface EXT_frag_depth {
5174}
5175
5176interface EXT_sRGB {
5177    readonly FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT: GLenum;
5178    readonly SRGB8_ALPHA8_EXT: GLenum;
5179    readonly SRGB_ALPHA_EXT: GLenum;
5180    readonly SRGB_EXT: GLenum;
5181}
5182
5183interface EXT_shader_texture_lod {
5184}
5185
5186/** The EXT_texture_filter_anisotropic extension is part of the WebGL API and exposes two constants for anisotropic filtering (AF). */
5187interface EXT_texture_filter_anisotropic {
5188    readonly MAX_TEXTURE_MAX_ANISOTROPY_EXT: GLenum;
5189    readonly TEXTURE_MAX_ANISOTROPY_EXT: GLenum;
5190}
5191
5192interface ElementEventMap {
5193    "fullscreenchange": Event;
5194    "fullscreenerror": Event;
5195}
5196
5197/** Element is the most general base class from which all objects in a Document inherit. It only has methods and properties common to all kinds of elements. More specific classes inherit from Element. */
5198interface Element extends Node, Animatable, ChildNode, InnerHTML, NonDocumentTypeChildNode, ParentNode, Slotable {
5199    readonly assignedSlot: HTMLSlotElement | null;
5200    readonly attributes: NamedNodeMap;
5201    /**
5202     * Allows for manipulation of element's class content attribute as a set of whitespace-separated tokens through a DOMTokenList object.
5203     */
5204    readonly classList: DOMTokenList;
5205    /**
5206     * Returns the value of element's class content attribute. Can be set to change it.
5207     */
5208    className: string;
5209    readonly clientHeight: number;
5210    readonly clientLeft: number;
5211    readonly clientTop: number;
5212    readonly clientWidth: number;
5213    /**
5214     * Returns the value of element's id content attribute. Can be set to change it.
5215     */
5216    id: string;
5217    /**
5218     * Returns the local name.
5219     */
5220    readonly localName: string;
5221    /**
5222     * Returns the namespace.
5223     */
5224    readonly namespaceURI: string | null;
5225    onfullscreenchange: ((this: Element, ev: Event) => any) | null;
5226    onfullscreenerror: ((this: Element, ev: Event) => any) | null;
5227    outerHTML: string;
5228    /**
5229     * Returns the namespace prefix.
5230     */
5231    readonly prefix: string | null;
5232    readonly scrollHeight: number;
5233    scrollLeft: number;
5234    scrollTop: number;
5235    readonly scrollWidth: number;
5236    /**
5237     * Returns element's shadow root, if any, and if shadow root's mode is "open", and null otherwise.
5238     */
5239    readonly shadowRoot: ShadowRoot | null;
5240    /**
5241     * Returns the value of element's slot content attribute. Can be set to change it.
5242     */
5243    slot: string;
5244    /**
5245     * Returns the HTML-uppercased qualified name.
5246     */
5247    readonly tagName: string;
5248    /**
5249     * Creates a shadow root for element and returns it.
5250     */
5251    attachShadow(init: ShadowRootInit): ShadowRoot;
5252    /**
5253     * Returns the first (starting at element) inclusive ancestor that matches selectors, and null otherwise.
5254     */
5255    closest<K extends keyof HTMLElementTagNameMap>(selector: K): HTMLElementTagNameMap[K] | null;
5256    closest<K extends keyof SVGElementTagNameMap>(selector: K): SVGElementTagNameMap[K] | null;
5257    closest<E extends Element = Element>(selector: string): E | null;
5258    /**
5259     * Returns element's first attribute whose qualified name is qualifiedName, and null if there is no such attribute otherwise.
5260     */
5261    getAttribute(qualifiedName: string): string | null;
5262    /**
5263     * Returns element's attribute whose namespace is namespace and local name is localName, and null if there is no such attribute otherwise.
5264     */
5265    getAttributeNS(namespace: string | null, localName: string): string | null;
5266    /**
5267     * Returns the qualified names of all element's attributes. Can contain duplicates.
5268     */
5269    getAttributeNames(): string[];
5270    getAttributeNode(name: string): Attr | null;
5271    getAttributeNodeNS(namespaceURI: string, localName: string): Attr | null;
5272    getBoundingClientRect(): DOMRect;
5273    getClientRects(): DOMRectList;
5274    /**
5275     * Returns a HTMLCollection of the elements in the object on which the method was invoked (a document or an element) that have all the classes given by classNames. The classNames argument is interpreted as a space-separated list of classes.
5276     */
5277    getElementsByClassName(classNames: string): HTMLCollectionOf<Element>;
5278    getElementsByTagName<K extends keyof HTMLElementTagNameMap>(qualifiedName: K): HTMLCollectionOf<HTMLElementTagNameMap[K]>;
5279    getElementsByTagName<K extends keyof SVGElementTagNameMap>(qualifiedName: K): HTMLCollectionOf<SVGElementTagNameMap[K]>;
5280    getElementsByTagName(qualifiedName: string): HTMLCollectionOf<Element>;
5281    getElementsByTagNameNS(namespaceURI: "http://www.w3.org/1999/xhtml", localName: string): HTMLCollectionOf<HTMLElement>;
5282    getElementsByTagNameNS(namespaceURI: "http://www.w3.org/2000/svg", localName: string): HTMLCollectionOf<SVGElement>;
5283    getElementsByTagNameNS(namespaceURI: string, localName: string): HTMLCollectionOf<Element>;
5284    /**
5285     * Returns true if element has an attribute whose qualified name is qualifiedName, and false otherwise.
5286     */
5287    hasAttribute(qualifiedName: string): boolean;
5288    /**
5289     * Returns true if element has an attribute whose namespace is namespace and local name is localName.
5290     */
5291    hasAttributeNS(namespace: string | null, localName: string): boolean;
5292    /**
5293     * Returns true if element has attributes, and false otherwise.
5294     */
5295    hasAttributes(): boolean;
5296    hasPointerCapture(pointerId: number): boolean;
5297    insertAdjacentElement(position: InsertPosition, insertedElement: Element): Element | null;
5298    insertAdjacentHTML(where: InsertPosition, html: string): void;
5299    insertAdjacentText(where: InsertPosition, text: string): void;
5300    /**
5301     * Returns true if matching selectors against element's root yields element, and false otherwise.
5302     */
5303    matches(selectors: string): boolean;
5304    msGetRegionContent(): any;
5305    releasePointerCapture(pointerId: number): void;
5306    /**
5307     * Removes element's first attribute whose qualified name is qualifiedName.
5308     */
5309    removeAttribute(qualifiedName: string): void;
5310    /**
5311     * Removes element's attribute whose namespace is namespace and local name is localName.
5312     */
5313    removeAttributeNS(namespace: string | null, localName: string): void;
5314    removeAttributeNode(attr: Attr): Attr;
5315    /**
5316     * Displays element fullscreen and resolves promise when done.
5317     * 
5318     * When supplied, options's navigationUI member indicates whether showing navigation UI while in fullscreen is preferred or not. If set to "show", navigation simplicity is preferred over screen space, and if set to "hide", more screen space is preferred. User agents are always free to honor user preference over the application's. The default value "auto" indicates no application preference.
5319     */
5320    requestFullscreen(options?: FullscreenOptions): Promise<void>;
5321    requestPointerLock(): void;
5322    scroll(options?: ScrollToOptions): void;
5323    scroll(x: number, y: number): void;
5324    scrollBy(options?: ScrollToOptions): void;
5325    scrollBy(x: number, y: number): void;
5326    scrollIntoView(arg?: boolean | ScrollIntoViewOptions): void;
5327    scrollTo(options?: ScrollToOptions): void;
5328    scrollTo(x: number, y: number): void;
5329    /**
5330     * Sets the value of element's first attribute whose qualified name is qualifiedName to value.
5331     */
5332    setAttribute(qualifiedName: string, value: string): void;
5333    /**
5334     * Sets the value of element's attribute whose namespace is namespace and local name is localName to value.
5335     */
5336    setAttributeNS(namespace: string | null, qualifiedName: string, value: string): void;
5337    setAttributeNode(attr: Attr): Attr | null;
5338    setAttributeNodeNS(attr: Attr): Attr | null;
5339    setPointerCapture(pointerId: number): void;
5340    /**
5341     * If force is not given, "toggles" qualifiedName, removing it if it is present and adding it if it is not present. If force is true, adds qualifiedName. If force is false, removes qualifiedName.
5342     * 
5343     * Returns true if qualifiedName is now present, and false otherwise.
5344     */
5345    toggleAttribute(qualifiedName: string, force?: boolean): boolean;
5346    webkitMatchesSelector(selectors: string): boolean;
5347    addEventListener<K extends keyof ElementEventMap>(type: K, listener: (this: Element, ev: ElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
5348    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
5349    removeEventListener<K extends keyof ElementEventMap>(type: K, listener: (this: Element, ev: ElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
5350    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
5351}
5352
5353declare var Element: {
5354    prototype: Element;
5355    new(): Element;
5356};
5357
5358interface ElementCSSInlineStyle {
5359    readonly style: CSSStyleDeclaration;
5360}
5361
5362interface ElementContentEditable {
5363    contentEditable: string;
5364    inputMode: string;
5365    readonly isContentEditable: boolean;
5366}
5367
5368/** Events providing information related to errors in scripts or in files. */
5369interface ErrorEvent extends Event {
5370    readonly colno: number;
5371    readonly error: any;
5372    readonly filename: string;
5373    readonly lineno: number;
5374    readonly message: string;
5375}
5376
5377declare var ErrorEvent: {
5378    prototype: ErrorEvent;
5379    new(type: string, eventInitDict?: ErrorEventInit): ErrorEvent;
5380};
5381
5382/** An event which takes place in the DOM. */
5383interface Event {
5384    /**
5385     * Returns true or false depending on how event was initialized. True if event goes through its target's ancestors in reverse tree order, and false otherwise.
5386     */
5387    readonly bubbles: boolean;
5388    cancelBubble: boolean;
5389    /**
5390     * Returns true or false depending on how event was initialized. Its return value does not always carry meaning, but true can indicate that part of the operation during which event was dispatched, can be canceled by invoking the preventDefault() method.
5391     */
5392    readonly cancelable: boolean;
5393    /**
5394     * Returns true or false depending on how event was initialized. True if event invokes listeners past a ShadowRoot node that is the root of its target, and false otherwise.
5395     */
5396    readonly composed: boolean;
5397    /**
5398     * Returns the object whose event listener's callback is currently being invoked.
5399     */
5400    readonly currentTarget: EventTarget | null;
5401    /**
5402     * Returns true if preventDefault() was invoked successfully to indicate cancelation, and false otherwise.
5403     */
5404    readonly defaultPrevented: boolean;
5405    /**
5406     * Returns the event's phase, which is one of NONE, CAPTURING_PHASE, AT_TARGET, and BUBBLING_PHASE.
5407     */
5408    readonly eventPhase: number;
5409    /**
5410     * Returns true if event was dispatched by the user agent, and false otherwise.
5411     */
5412    readonly isTrusted: boolean;
5413    returnValue: boolean;
5414    /** @deprecated */
5415    readonly srcElement: EventTarget | null;
5416    /**
5417     * Returns the object to which event is dispatched (its target).
5418     */
5419    readonly target: EventTarget | null;
5420    /**
5421     * Returns the event's timestamp as the number of milliseconds measured relative to the time origin.
5422     */
5423    readonly timeStamp: number;
5424    /**
5425     * Returns the type of event, e.g. "click", "hashchange", or "submit".
5426     */
5427    readonly type: string;
5428    /**
5429     * Returns the invocation target objects of event's path (objects on which listeners will be invoked), except for any nodes in shadow trees of which the shadow root's mode is "closed" that are not reachable from event's currentTarget.
5430     */
5431    composedPath(): EventTarget[];
5432    initEvent(type: string, bubbles?: boolean, cancelable?: boolean): void;
5433    /**
5434     * If invoked when the cancelable attribute value is true, and while executing a listener for the event with passive set to false, signals to the operation that caused event to be dispatched that it needs to be canceled.
5435     */
5436    preventDefault(): void;
5437    /**
5438     * Invoking this method prevents event from reaching any registered event listeners after the current one finishes running and, when dispatched in a tree, also prevents event from reaching any other objects.
5439     */
5440    stopImmediatePropagation(): void;
5441    /**
5442     * When dispatched in a tree, invoking this method prevents event from reaching any objects other than the current object.
5443     */
5444    stopPropagation(): void;
5445    readonly AT_TARGET: number;
5446    readonly BUBBLING_PHASE: number;
5447    readonly CAPTURING_PHASE: number;
5448    readonly NONE: number;
5449}
5450
5451declare var Event: {
5452    prototype: Event;
5453    new(type: string, eventInitDict?: EventInit): Event;
5454    readonly AT_TARGET: number;
5455    readonly BUBBLING_PHASE: number;
5456    readonly CAPTURING_PHASE: number;
5457    readonly NONE: number;
5458};
5459
5460interface EventListenerObject {
5461    handleEvent(evt: Event): void;
5462}
5463
5464interface EventSourceEventMap {
5465    "error": Event;
5466    "message": MessageEvent;
5467    "open": Event;
5468}
5469
5470interface EventSource extends EventTarget {
5471    onerror: ((this: EventSource, ev: Event) => any) | null;
5472    onmessage: ((this: EventSource, ev: MessageEvent) => any) | null;
5473    onopen: ((this: EventSource, ev: Event) => any) | null;
5474    /**
5475     * Returns the state of this EventSource object's connection. It can have the values described below.
5476     */
5477    readonly readyState: number;
5478    /**
5479     * Returns the URL providing the event stream.
5480     */
5481    readonly url: string;
5482    /**
5483     * Returns true if the credentials mode for connection requests to the URL providing the event stream is set to "include", and false otherwise.
5484     */
5485    readonly withCredentials: boolean;
5486    /**
5487     * Aborts any instances of the fetch algorithm started for this EventSource object, and sets the readyState attribute to CLOSED.
5488     */
5489    close(): void;
5490    readonly CLOSED: number;
5491    readonly CONNECTING: number;
5492    readonly OPEN: number;
5493    addEventListener<K extends keyof EventSourceEventMap>(type: K, listener: (this: EventSource, ev: EventSourceEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
5494    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
5495    removeEventListener<K extends keyof EventSourceEventMap>(type: K, listener: (this: EventSource, ev: EventSourceEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
5496    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
5497}
5498
5499declare var EventSource: {
5500    prototype: EventSource;
5501    new(url: string, eventSourceInitDict?: EventSourceInit): EventSource;
5502    readonly CLOSED: number;
5503    readonly CONNECTING: number;
5504    readonly OPEN: number;
5505};
5506
5507/** EventTarget is a DOM interface implemented by objects that can receive events and may have listeners for them. */
5508interface EventTarget {
5509    /**
5510     * Appends an event listener for events whose type attribute value is type. The callback argument sets the callback that will be invoked when the event is dispatched.
5511     * 
5512     * The options argument sets listener-specific options. For compatibility this can be a boolean, in which case the method behaves exactly as if the value was specified as options's capture.
5513     * 
5514     * When set to true, options's capture prevents callback from being invoked when the event's eventPhase attribute value is BUBBLING_PHASE. When false (or not present), callback will not be invoked when event's eventPhase attribute value is CAPTURING_PHASE. Either way, callback will be invoked if event's eventPhase attribute value is AT_TARGET.
5515     * 
5516     * When set to true, options's passive indicates that the callback will not cancel the event by invoking preventDefault(). This is used to enable performance optimizations described in §2.8 Observing event listeners.
5517     * 
5518     * When set to true, options's once indicates that the callback will only be invoked once after which the event listener will be removed.
5519     * 
5520     * The event listener is appended to target's event listener list and is not appended if it has the same type, callback, and capture.
5521     */
5522    addEventListener(type: string, listener: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions): void;
5523    /**
5524     * Dispatches a synthetic event event to target and returns true if either event's cancelable attribute value is false or its preventDefault() method was not invoked, and false otherwise.
5525     */
5526    dispatchEvent(event: Event): boolean;
5527    /**
5528     * Removes the event listener in target's event listener list with the same type, callback, and options.
5529     */
5530    removeEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
5531}
5532
5533declare var EventTarget: {
5534    prototype: EventTarget;
5535    new(): EventTarget;
5536};
5537
5538interface ExtensionScriptApis {
5539    extensionIdToShortId(extensionId: string): number;
5540    fireExtensionApiTelemetry(functionName: string, isSucceeded: boolean, isSupported: boolean, errorString: string): void;
5541    genericFunction(routerAddress: any, parameters?: string, callbackId?: number): void;
5542    genericSynchronousFunction(functionId: number, parameters?: string): string;
5543    genericWebRuntimeCallout(to: any, from: any, payload: string): void;
5544    getExtensionId(): string;
5545    registerGenericFunctionCallbackHandler(callbackHandler: Function): void;
5546    registerGenericPersistentCallbackHandler(callbackHandler: Function): void;
5547    registerWebRuntimeCallbackHandler(handler: Function): any;
5548}
5549
5550declare var ExtensionScriptApis: {
5551    prototype: ExtensionScriptApis;
5552    new(): ExtensionScriptApis;
5553};
5554
5555interface External {
5556    /** @deprecated */
5557    AddSearchProvider(): void;
5558    /** @deprecated */
5559    IsSearchProviderInstalled(): void;
5560}
5561
5562declare var External: {
5563    prototype: External;
5564    new(): External;
5565};
5566
5567/** Provides information about files and allows JavaScript in a web page to access their content. */
5568interface File extends Blob {
5569    readonly lastModified: number;
5570    readonly name: string;
5571}
5572
5573declare var File: {
5574    prototype: File;
5575    new(fileBits: BlobPart[], fileName: string, options?: FilePropertyBag): File;
5576};
5577
5578/** An object of this type is returned by the files property of the HTML <input> element; this lets you access the list of files selected with the <input type="file"> element. It's also used for a list of files dropped into web content when using the drag and drop API; see the DataTransfer object for details on this usage. */
5579interface FileList {
5580    readonly length: number;
5581    item(index: number): File | null;
5582    [index: number]: File;
5583}
5584
5585declare var FileList: {
5586    prototype: FileList;
5587    new(): FileList;
5588};
5589
5590interface FileReaderEventMap {
5591    "abort": ProgressEvent<FileReader>;
5592    "error": ProgressEvent<FileReader>;
5593    "load": ProgressEvent<FileReader>;
5594    "loadend": ProgressEvent<FileReader>;
5595    "loadstart": ProgressEvent<FileReader>;
5596    "progress": ProgressEvent<FileReader>;
5597}
5598
5599/** Lets web applications asynchronously read the contents of files (or raw data buffers) stored on the user's computer, using File or Blob objects to specify the file or data to read. */
5600interface FileReader extends EventTarget {
5601    readonly error: DOMException | null;
5602    onabort: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
5603    onerror: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
5604    onload: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
5605    onloadend: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
5606    onloadstart: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
5607    onprogress: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
5608    readonly readyState: number;
5609    readonly result: string | ArrayBuffer | null;
5610    abort(): void;
5611    readAsArrayBuffer(blob: Blob): void;
5612    readAsBinaryString(blob: Blob): void;
5613    readAsDataURL(blob: Blob): void;
5614    readAsText(blob: Blob, encoding?: string): void;
5615    readonly DONE: number;
5616    readonly EMPTY: number;
5617    readonly LOADING: number;
5618    addEventListener<K extends keyof FileReaderEventMap>(type: K, listener: (this: FileReader, ev: FileReaderEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
5619    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
5620    removeEventListener<K extends keyof FileReaderEventMap>(type: K, listener: (this: FileReader, ev: FileReaderEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
5621    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
5622}
5623
5624declare var FileReader: {
5625    prototype: FileReader;
5626    new(): FileReader;
5627    readonly DONE: number;
5628    readonly EMPTY: number;
5629    readonly LOADING: number;
5630};
5631
5632/** Focus-related events like focus, blur, focusin, or focusout. */
5633interface FocusEvent extends UIEvent {
5634    readonly relatedTarget: EventTarget | null;
5635}
5636
5637declare var FocusEvent: {
5638    prototype: FocusEvent;
5639    new(type: string, eventInitDict?: FocusEventInit): FocusEvent;
5640};
5641
5642interface FocusNavigationEvent extends Event {
5643    readonly navigationReason: NavigationReason;
5644    readonly originHeight: number;
5645    readonly originLeft: number;
5646    readonly originTop: number;
5647    readonly originWidth: number;
5648    requestFocus(): void;
5649}
5650
5651declare var FocusNavigationEvent: {
5652    prototype: FocusNavigationEvent;
5653    new(type: string, eventInitDict?: FocusNavigationEventInit): FocusNavigationEvent;
5654};
5655
5656/** Provides a way to easily construct a set of key/value pairs representing form fields and their values, which can then be easily sent using the XMLHttpRequest.send() method. It uses the same format a form would use if the encoding type were set to "multipart/form-data". */
5657interface FormData {
5658    append(name: string, value: string | Blob, fileName?: string): void;
5659    delete(name: string): void;
5660    get(name: string): FormDataEntryValue | null;
5661    getAll(name: string): FormDataEntryValue[];
5662    has(name: string): boolean;
5663    set(name: string, value: string | Blob, fileName?: string): void;
5664    forEach(callbackfn: (value: FormDataEntryValue, key: string, parent: FormData) => void, thisArg?: any): void;
5665}
5666
5667declare var FormData: {
5668    prototype: FormData;
5669    new(form?: HTMLFormElement): FormData;
5670};
5671
5672/** A change in volume. It is an AudioNode audio-processing module that causes a given gain to be applied to the input data before its propagation to the output. A GainNode always has exactly one input and one output, both with the same number of channels. */
5673interface GainNode extends AudioNode {
5674    readonly gain: AudioParam;
5675}
5676
5677declare var GainNode: {
5678    prototype: GainNode;
5679    new(context: BaseAudioContext, options?: GainOptions): GainNode;
5680};
5681
5682/** This Gamepad API interface defines an individual gamepad or other controller, allowing access to information such as button presses, axis positions, and id. */
5683interface Gamepad {
5684    readonly axes: ReadonlyArray<number>;
5685    readonly buttons: ReadonlyArray<GamepadButton>;
5686    readonly connected: boolean;
5687    readonly hand: GamepadHand;
5688    readonly hapticActuators: ReadonlyArray<GamepadHapticActuator>;
5689    readonly id: string;
5690    readonly index: number;
5691    readonly mapping: GamepadMappingType;
5692    readonly pose: GamepadPose | null;
5693    readonly timestamp: number;
5694}
5695
5696declare var Gamepad: {
5697    prototype: Gamepad;
5698    new(): Gamepad;
5699};
5700
5701/** An individual button of a gamepad or other controller, allowing access to the current state of different types of buttons available on the control device. */
5702interface GamepadButton {
5703    readonly pressed: boolean;
5704    readonly touched: boolean;
5705    readonly value: number;
5706}
5707
5708declare var GamepadButton: {
5709    prototype: GamepadButton;
5710    new(): GamepadButton;
5711};
5712
5713/** This Gamepad API interface contains references to gamepads connected to the system, which is what the gamepad events Window.gamepadconnected and Window.gamepaddisconnected are fired in response to. */
5714interface GamepadEvent extends Event {
5715    readonly gamepad: Gamepad;
5716}
5717
5718declare var GamepadEvent: {
5719    prototype: GamepadEvent;
5720    new(type: string, eventInitDict: GamepadEventInit): GamepadEvent;
5721};
5722
5723/** This Gamepad API interface represents hardware in the controller designed to provide haptic feedback to the user (if available), most commonly vibration hardware. */
5724interface GamepadHapticActuator {
5725    readonly type: GamepadHapticActuatorType;
5726    pulse(value: number, duration: number): Promise<boolean>;
5727}
5728
5729declare var GamepadHapticActuator: {
5730    prototype: GamepadHapticActuator;
5731    new(): GamepadHapticActuator;
5732};
5733
5734/** This Gamepad API interface represents the pose of a WebVR controller at a given timestamp (which includes orientation, position, velocity, and acceleration information.) */
5735interface GamepadPose {
5736    readonly angularAcceleration: Float32Array | null;
5737    readonly angularVelocity: Float32Array | null;
5738    readonly hasOrientation: boolean;
5739    readonly hasPosition: boolean;
5740    readonly linearAcceleration: Float32Array | null;
5741    readonly linearVelocity: Float32Array | null;
5742    readonly orientation: Float32Array | null;
5743    readonly position: Float32Array | null;
5744}
5745
5746declare var GamepadPose: {
5747    prototype: GamepadPose;
5748    new(): GamepadPose;
5749};
5750
5751interface GenericTransformStream {
5752    /**
5753     * Returns a readable stream whose chunks are strings resulting from running encoding's decoder on the chunks written to writable.
5754     */
5755    readonly readable: ReadableStream;
5756    /**
5757     * Returns a writable stream which accepts BufferSource chunks and runs them through encoding's decoder before making them available to readable.
5758     * 
5759     * Typically this will be used via the pipeThrough() method on a ReadableStream source.
5760     * 
5761     * ```
5762     * var decoder = new TextDecoderStream(encoding);
5763     * byteReadable
5764     *   .pipeThrough(decoder)
5765     *   .pipeTo(textWritable);
5766     * ```
5767     * 
5768     * If the error mode is "fatal" and encoding's decoder returns error, both readable and writable will be errored with a TypeError.
5769     */
5770    readonly writable: WritableStream;
5771}
5772
5773/** An object able to programmatically obtain the position of the device. It gives Web content access to the location of the device. This allows a Web site or app to offer customized results based on the user's location. */
5774interface Geolocation {
5775    clearWatch(watchId: number): void;
5776    getCurrentPosition(successCallback: PositionCallback, errorCallback?: PositionErrorCallback, options?: PositionOptions): void;
5777    watchPosition(successCallback: PositionCallback, errorCallback?: PositionErrorCallback, options?: PositionOptions): number;
5778}
5779
5780interface GlobalEventHandlersEventMap {
5781    "abort": UIEvent;
5782    "animationcancel": AnimationEvent;
5783    "animationend": AnimationEvent;
5784    "animationiteration": AnimationEvent;
5785    "animationstart": AnimationEvent;
5786    "auxclick": MouseEvent;
5787    "blur": FocusEvent;
5788    "cancel": Event;
5789    "canplay": Event;
5790    "canplaythrough": Event;
5791    "change": Event;
5792    "click": MouseEvent;
5793    "close": Event;
5794    "contextmenu": MouseEvent;
5795    "cuechange": Event;
5796    "dblclick": MouseEvent;
5797    "drag": DragEvent;
5798    "dragend": DragEvent;
5799    "dragenter": DragEvent;
5800    "dragexit": Event;
5801    "dragleave": DragEvent;
5802    "dragover": DragEvent;
5803    "dragstart": DragEvent;
5804    "drop": DragEvent;
5805    "durationchange": Event;
5806    "emptied": Event;
5807    "ended": Event;
5808    "error": ErrorEvent;
5809    "focus": FocusEvent;
5810    "focusin": FocusEvent;
5811    "focusout": FocusEvent;
5812    "gotpointercapture": PointerEvent;
5813    "input": Event;
5814    "invalid": Event;
5815    "keydown": KeyboardEvent;
5816    "keypress": KeyboardEvent;
5817    "keyup": KeyboardEvent;
5818    "load": Event;
5819    "loadeddata": Event;
5820    "loadedmetadata": Event;
5821    "loadend": ProgressEvent;
5822    "loadstart": Event;
5823    "lostpointercapture": PointerEvent;
5824    "mousedown": MouseEvent;
5825    "mouseenter": MouseEvent;
5826    "mouseleave": MouseEvent;
5827    "mousemove": MouseEvent;
5828    "mouseout": MouseEvent;
5829    "mouseover": MouseEvent;
5830    "mouseup": MouseEvent;
5831    "pause": Event;
5832    "play": Event;
5833    "playing": Event;
5834    "pointercancel": PointerEvent;
5835    "pointerdown": PointerEvent;
5836    "pointerenter": PointerEvent;
5837    "pointerleave": PointerEvent;
5838    "pointermove": PointerEvent;
5839    "pointerout": PointerEvent;
5840    "pointerover": PointerEvent;
5841    "pointerup": PointerEvent;
5842    "progress": ProgressEvent;
5843    "ratechange": Event;
5844    "reset": Event;
5845    "resize": UIEvent;
5846    "scroll": Event;
5847    "securitypolicyviolation": SecurityPolicyViolationEvent;
5848    "seeked": Event;
5849    "seeking": Event;
5850    "select": Event;
5851    "selectionchange": Event;
5852    "selectstart": Event;
5853    "stalled": Event;
5854    "submit": Event;
5855    "suspend": Event;
5856    "timeupdate": Event;
5857    "toggle": Event;
5858    "touchcancel": TouchEvent;
5859    "touchend": TouchEvent;
5860    "touchmove": TouchEvent;
5861    "touchstart": TouchEvent;
5862    "transitioncancel": TransitionEvent;
5863    "transitionend": TransitionEvent;
5864    "transitionrun": TransitionEvent;
5865    "transitionstart": TransitionEvent;
5866    "volumechange": Event;
5867    "waiting": Event;
5868    "wheel": WheelEvent;
5869}
5870
5871interface GlobalEventHandlers {
5872    /**
5873     * Fires when the user aborts the download.
5874     * @param ev The event.
5875     */
5876    onabort: ((this: GlobalEventHandlers, ev: UIEvent) => any) | null;
5877    onanimationcancel: ((this: GlobalEventHandlers, ev: AnimationEvent) => any) | null;
5878    onanimationend: ((this: GlobalEventHandlers, ev: AnimationEvent) => any) | null;
5879    onanimationiteration: ((this: GlobalEventHandlers, ev: AnimationEvent) => any) | null;
5880    onanimationstart: ((this: GlobalEventHandlers, ev: AnimationEvent) => any) | null;
5881    onauxclick: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
5882    /**
5883     * Fires when the object loses the input focus.
5884     * @param ev The focus event.
5885     */
5886    onblur: ((this: GlobalEventHandlers, ev: FocusEvent) => any) | null;
5887    oncancel: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5888    /**
5889     * Occurs when playback is possible, but would require further buffering.
5890     * @param ev The event.
5891     */
5892    oncanplay: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5893    oncanplaythrough: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5894    /**
5895     * Fires when the contents of the object or selection have changed.
5896     * @param ev The event.
5897     */
5898    onchange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5899    /**
5900     * Fires when the user clicks the left mouse button on the object
5901     * @param ev The mouse event.
5902     */
5903    onclick: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
5904    onclose: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5905    /**
5906     * Fires when the user clicks the right mouse button in the client area, opening the context menu.
5907     * @param ev The mouse event.
5908     */
5909    oncontextmenu: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
5910    oncuechange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5911    /**
5912     * Fires when the user double-clicks the object.
5913     * @param ev The mouse event.
5914     */
5915    ondblclick: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
5916    /**
5917     * Fires on the source object continuously during a drag operation.
5918     * @param ev The event.
5919     */
5920    ondrag: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
5921    /**
5922     * Fires on the source object when the user releases the mouse at the close of a drag operation.
5923     * @param ev The event.
5924     */
5925    ondragend: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
5926    /**
5927     * Fires on the target element when the user drags the object to a valid drop target.
5928     * @param ev The drag event.
5929     */
5930    ondragenter: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
5931    ondragexit: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5932    /**
5933     * Fires on the target object when the user moves the mouse out of a valid drop target during a drag operation.
5934     * @param ev The drag event.
5935     */
5936    ondragleave: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
5937    /**
5938     * Fires on the target element continuously while the user drags the object over a valid drop target.
5939     * @param ev The event.
5940     */
5941    ondragover: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
5942    /**
5943     * Fires on the source object when the user starts to drag a text selection or selected object.
5944     * @param ev The event.
5945     */
5946    ondragstart: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
5947    ondrop: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
5948    /**
5949     * Occurs when the duration attribute is updated.
5950     * @param ev The event.
5951     */
5952    ondurationchange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5953    /**
5954     * Occurs when the media element is reset to its initial state.
5955     * @param ev The event.
5956     */
5957    onemptied: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5958    /**
5959     * Occurs when the end of playback is reached.
5960     * @param ev The event
5961     */
5962    onended: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5963    /**
5964     * Fires when an error occurs during object loading.
5965     * @param ev The event.
5966     */
5967    onerror: OnErrorEventHandler;
5968    /**
5969     * Fires when the object receives focus.
5970     * @param ev The event.
5971     */
5972    onfocus: ((this: GlobalEventHandlers, ev: FocusEvent) => any) | null;
5973    ongotpointercapture: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
5974    oninput: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5975    oninvalid: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5976    /**
5977     * Fires when the user presses a key.
5978     * @param ev The keyboard event
5979     */
5980    onkeydown: ((this: GlobalEventHandlers, ev: KeyboardEvent) => any) | null;
5981    /**
5982     * Fires when the user presses an alphanumeric key.
5983     * @param ev The event.
5984     */
5985    onkeypress: ((this: GlobalEventHandlers, ev: KeyboardEvent) => any) | null;
5986    /**
5987     * Fires when the user releases a key.
5988     * @param ev The keyboard event
5989     */
5990    onkeyup: ((this: GlobalEventHandlers, ev: KeyboardEvent) => any) | null;
5991    /**
5992     * Fires immediately after the browser loads the object.
5993     * @param ev The event.
5994     */
5995    onload: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5996    /**
5997     * Occurs when media data is loaded at the current playback position.
5998     * @param ev The event.
5999     */
6000    onloadeddata: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6001    /**
6002     * Occurs when the duration and dimensions of the media have been determined.
6003     * @param ev The event.
6004     */
6005    onloadedmetadata: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6006    onloadend: ((this: GlobalEventHandlers, ev: ProgressEvent) => any) | null;
6007    /**
6008     * Occurs when Internet Explorer begins looking for media data.
6009     * @param ev The event.
6010     */
6011    onloadstart: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6012    onlostpointercapture: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
6013    /**
6014     * Fires when the user clicks the object with either mouse button.
6015     * @param ev The mouse event.
6016     */
6017    onmousedown: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
6018    onmouseenter: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
6019    onmouseleave: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
6020    /**
6021     * Fires when the user moves the mouse over the object.
6022     * @param ev The mouse event.
6023     */
6024    onmousemove: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
6025    /**
6026     * Fires when the user moves the mouse pointer outside the boundaries of the object.
6027     * @param ev The mouse event.
6028     */
6029    onmouseout: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
6030    /**
6031     * Fires when the user moves the mouse pointer into the object.
6032     * @param ev The mouse event.
6033     */
6034    onmouseover: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
6035    /**
6036     * Fires when the user releases a mouse button while the mouse is over the object.
6037     * @param ev The mouse event.
6038     */
6039    onmouseup: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
6040    /**
6041     * Occurs when playback is paused.
6042     * @param ev The event.
6043     */
6044    onpause: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6045    /**
6046     * Occurs when the play method is requested.
6047     * @param ev The event.
6048     */
6049    onplay: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6050    /**
6051     * Occurs when the audio or video has started playing.
6052     * @param ev The event.
6053     */
6054    onplaying: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6055    onpointercancel: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
6056    onpointerdown: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
6057    onpointerenter: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
6058    onpointerleave: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
6059    onpointermove: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
6060    onpointerout: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
6061    onpointerover: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
6062    onpointerup: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
6063    /**
6064     * Occurs to indicate progress while downloading media data.
6065     * @param ev The event.
6066     */
6067    onprogress: ((this: GlobalEventHandlers, ev: ProgressEvent) => any) | null;
6068    /**
6069     * Occurs when the playback rate is increased or decreased.
6070     * @param ev The event.
6071     */
6072    onratechange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6073    /**
6074     * Fires when the user resets a form.
6075     * @param ev The event.
6076     */
6077    onreset: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6078    onresize: ((this: GlobalEventHandlers, ev: UIEvent) => any) | null;
6079    /**
6080     * Fires when the user repositions the scroll box in the scroll bar on the object.
6081     * @param ev The event.
6082     */
6083    onscroll: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6084    onsecuritypolicyviolation: ((this: GlobalEventHandlers, ev: SecurityPolicyViolationEvent) => any) | null;
6085    /**
6086     * Occurs when the seek operation ends.
6087     * @param ev The event.
6088     */
6089    onseeked: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6090    /**
6091     * Occurs when the current playback position is moved.
6092     * @param ev The event.
6093     */
6094    onseeking: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6095    /**
6096     * Fires when the current selection changes.
6097     * @param ev The event.
6098     */
6099    onselect: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6100    onselectionchange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6101    onselectstart: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6102    /**
6103     * Occurs when the download has stopped.
6104     * @param ev The event.
6105     */
6106    onstalled: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6107    onsubmit: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6108    /**
6109     * Occurs if the load operation has been intentionally halted.
6110     * @param ev The event.
6111     */
6112    onsuspend: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6113    /**
6114     * Occurs to indicate the current playback position.
6115     * @param ev The event.
6116     */
6117    ontimeupdate: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6118    ontoggle: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6119    ontouchcancel: ((this: GlobalEventHandlers, ev: TouchEvent) => any) | null;
6120    ontouchend: ((this: GlobalEventHandlers, ev: TouchEvent) => any) | null;
6121    ontouchmove: ((this: GlobalEventHandlers, ev: TouchEvent) => any) | null;
6122    ontouchstart: ((this: GlobalEventHandlers, ev: TouchEvent) => any) | null;
6123    ontransitioncancel: ((this: GlobalEventHandlers, ev: TransitionEvent) => any) | null;
6124    ontransitionend: ((this: GlobalEventHandlers, ev: TransitionEvent) => any) | null;
6125    ontransitionrun: ((this: GlobalEventHandlers, ev: TransitionEvent) => any) | null;
6126    ontransitionstart: ((this: GlobalEventHandlers, ev: TransitionEvent) => any) | null;
6127    /**
6128     * Occurs when the volume is changed, or playback is muted or unmuted.
6129     * @param ev The event.
6130     */
6131    onvolumechange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6132    /**
6133     * Occurs when playback stops because the next frame of a video resource is not available.
6134     * @param ev The event.
6135     */
6136    onwaiting: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6137    onwheel: ((this: GlobalEventHandlers, ev: WheelEvent) => any) | null;
6138    addEventListener<K extends keyof GlobalEventHandlersEventMap>(type: K, listener: (this: GlobalEventHandlers, ev: GlobalEventHandlersEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6139    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6140    removeEventListener<K extends keyof GlobalEventHandlersEventMap>(type: K, listener: (this: GlobalEventHandlers, ev: GlobalEventHandlersEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6141    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6142}
6143
6144interface HTMLAllCollection {
6145    /**
6146     * Returns the number of elements in the collection.
6147     */
6148    readonly length: number;
6149    /**
6150     * Returns the item with index index from the collection (determined by tree order).
6151     */
6152    item(nameOrIndex?: string): HTMLCollection | Element | null;
6153    /**
6154     * Returns the item with ID or name name from the collection.
6155     * 
6156     * If there are multiple matching items, then an HTMLCollection object containing all those elements is returned.
6157     * 
6158     * Only button, form, iframe, input, map, meta, object, select, and textarea elements can have a name for the purpose of this method; their name is given by the value of their name attribute.
6159     */
6160    namedItem(name: string): HTMLCollection | Element | null;
6161    [index: number]: Element;
6162}
6163
6164declare var HTMLAllCollection: {
6165    prototype: HTMLAllCollection;
6166    new(): HTMLAllCollection;
6167};
6168
6169/** Hyperlink elements and provides special properties and methods (beyond those of the regular HTMLElement object interface that they inherit from) for manipulating the layout and presentation of such elements. */
6170interface HTMLAnchorElement extends HTMLElement, HTMLHyperlinkElementUtils {
6171    /**
6172     * Sets or retrieves the character set used to encode the object.
6173     */
6174    /** @deprecated */
6175    charset: string;
6176    /**
6177     * Sets or retrieves the coordinates of the object.
6178     */
6179    /** @deprecated */
6180    coords: string;
6181    download: string;
6182    /**
6183     * Sets or retrieves the language code of the object.
6184     */
6185    hreflang: string;
6186    /**
6187     * Sets or retrieves the shape of the object.
6188     */
6189    /** @deprecated */
6190    name: string;
6191    ping: string;
6192    referrerPolicy: string;
6193    /**
6194     * Sets or retrieves the relationship between the object and the destination of the link.
6195     */
6196    rel: string;
6197    readonly relList: DOMTokenList;
6198    /**
6199     * Sets or retrieves the relationship between the object and the destination of the link.
6200     */
6201    /** @deprecated */
6202    rev: string;
6203    /**
6204     * Sets or retrieves the shape of the object.
6205     */
6206    /** @deprecated */
6207    shape: string;
6208    /**
6209     * Sets or retrieves the window or frame at which to target content.
6210     */
6211    target: string;
6212    /**
6213     * Retrieves or sets the text of the object as a string.
6214     */
6215    text: string;
6216    type: string;
6217    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLAnchorElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6218    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6219    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLAnchorElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6220    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6221}
6222
6223declare var HTMLAnchorElement: {
6224    prototype: HTMLAnchorElement;
6225    new(): HTMLAnchorElement;
6226};
6227
6228interface HTMLAppletElement extends HTMLElement {
6229    /** @deprecated */
6230    align: string;
6231    /**
6232     * Sets or retrieves a text alternative to the graphic.
6233     */
6234    /** @deprecated */
6235    alt: string;
6236    /**
6237     * Sets or retrieves a character string that can be used to implement your own archive functionality for the object.
6238     */
6239    /** @deprecated */
6240    archive: string;
6241    /** @deprecated */
6242    code: string;
6243    /**
6244     * Sets or retrieves the URL of the component.
6245     */
6246    /** @deprecated */
6247    codeBase: string;
6248    readonly form: HTMLFormElement | null;
6249    /**
6250     * Sets or retrieves the height of the object.
6251     */
6252    /** @deprecated */
6253    height: string;
6254    /** @deprecated */
6255    hspace: number;
6256    /**
6257     * Sets or retrieves the shape of the object.
6258     */
6259    /** @deprecated */
6260    name: string;
6261    /** @deprecated */
6262    object: string;
6263    /** @deprecated */
6264    vspace: number;
6265    /** @deprecated */
6266    width: string;
6267    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLAppletElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6268    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6269    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLAppletElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6270    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6271}
6272
6273declare var HTMLAppletElement: {
6274    prototype: HTMLAppletElement;
6275    new(): HTMLAppletElement;
6276};
6277
6278/** Provides special properties and methods (beyond those of the regular object HTMLElement interface it also has available to it by inheritance) for manipulating the layout and presentation of <area> elements. */
6279interface HTMLAreaElement extends HTMLElement, HTMLHyperlinkElementUtils {
6280    /**
6281     * Sets or retrieves a text alternative to the graphic.
6282     */
6283    alt: string;
6284    /**
6285     * Sets or retrieves the coordinates of the object.
6286     */
6287    coords: string;
6288    download: string;
6289    /**
6290     * Sets or gets whether clicks in this region cause action.
6291     */
6292    /** @deprecated */
6293    noHref: boolean;
6294    ping: string;
6295    referrerPolicy: string;
6296    rel: string;
6297    readonly relList: DOMTokenList;
6298    /**
6299     * Sets or retrieves the shape of the object.
6300     */
6301    shape: string;
6302    /**
6303     * Sets or retrieves the window or frame at which to target content.
6304     */
6305    target: string;
6306    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLAreaElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6307    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6308    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLAreaElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6309    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6310}
6311
6312declare var HTMLAreaElement: {
6313    prototype: HTMLAreaElement;
6314    new(): HTMLAreaElement;
6315};
6316
6317/** Provides access to the properties of <audio> elements, as well as methods to manipulate them. It derives from the HTMLMediaElement interface. */
6318interface HTMLAudioElement extends HTMLMediaElement {
6319    addEventListener<K extends keyof HTMLMediaElementEventMap>(type: K, listener: (this: HTMLAudioElement, ev: HTMLMediaElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6320    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6321    removeEventListener<K extends keyof HTMLMediaElementEventMap>(type: K, listener: (this: HTMLAudioElement, ev: HTMLMediaElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6322    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6323}
6324
6325declare var HTMLAudioElement: {
6326    prototype: HTMLAudioElement;
6327    new(): HTMLAudioElement;
6328};
6329
6330/** A HTML line break element (<br>). It inherits from HTMLElement. */
6331interface HTMLBRElement extends HTMLElement {
6332    /**
6333     * Sets or retrieves the side on which floating objects are not to be positioned when any IHTMLBlockElement is inserted into the document.
6334     */
6335    /** @deprecated */
6336    clear: string;
6337    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLBRElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6338    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6339    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLBRElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6340    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6341}
6342
6343declare var HTMLBRElement: {
6344    prototype: HTMLBRElement;
6345    new(): HTMLBRElement;
6346};
6347
6348/** Contains the base URI for a document. This object inherits all of the properties and methods as described in the HTMLElement interface. */
6349interface HTMLBaseElement extends HTMLElement {
6350    /**
6351     * Gets or sets the baseline URL on which relative links are based.
6352     */
6353    href: string;
6354    /**
6355     * Sets or retrieves the window or frame at which to target content.
6356     */
6357    target: string;
6358    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLBaseElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6359    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6360    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLBaseElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6361    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6362}
6363
6364declare var HTMLBaseElement: {
6365    prototype: HTMLBaseElement;
6366    new(): HTMLBaseElement;
6367};
6368
6369/** Provides special properties (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating <basefont> elements. */
6370interface HTMLBaseFontElement extends HTMLElement, DOML2DeprecatedColorProperty {
6371    /**
6372     * Sets or retrieves the current typeface family.
6373     */
6374    /** @deprecated */
6375    face: string;
6376    /**
6377     * Sets or retrieves the font size of the object.
6378     */
6379    /** @deprecated */
6380    size: number;
6381    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLBaseFontElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6382    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6383    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLBaseFontElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6384    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6385}
6386
6387declare var HTMLBaseFontElement: {
6388    prototype: HTMLBaseFontElement;
6389    new(): HTMLBaseFontElement;
6390};
6391
6392interface HTMLBodyElementEventMap extends HTMLElementEventMap, WindowEventHandlersEventMap {
6393    "orientationchange": Event;
6394}
6395
6396/** Provides special properties (beyond those inherited from the regular HTMLElement interface) for manipulating <body> elements. */
6397interface HTMLBodyElement extends HTMLElement, WindowEventHandlers {
6398    /** @deprecated */
6399    aLink: string;
6400    /** @deprecated */
6401    background: string;
6402    /** @deprecated */
6403    bgColor: string;
6404    bgProperties: string;
6405    /** @deprecated */
6406    link: string;
6407    /** @deprecated */
6408    noWrap: boolean;
6409    /** @deprecated */
6410    onorientationchange: ((this: HTMLBodyElement, ev: Event) => any) | null;
6411    /** @deprecated */
6412    text: string;
6413    /** @deprecated */
6414    vLink: string;
6415    addEventListener<K extends keyof HTMLBodyElementEventMap>(type: K, listener: (this: HTMLBodyElement, ev: HTMLBodyElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6416    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6417    removeEventListener<K extends keyof HTMLBodyElementEventMap>(type: K, listener: (this: HTMLBodyElement, ev: HTMLBodyElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6418    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6419}
6420
6421declare var HTMLBodyElement: {
6422    prototype: HTMLBodyElement;
6423    new(): HTMLBodyElement;
6424};
6425
6426/** Provides properties and methods (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating <button> elements. */
6427interface HTMLButtonElement extends HTMLElement {
6428    /**
6429     * Provides a way to direct a user to a specific field when a document loads. This can provide both direction and convenience for a user, reducing the need to click or tab to a field when a page opens. This attribute is true when present on an element, and false when missing.
6430     */
6431    autofocus: boolean;
6432    disabled: boolean;
6433    /**
6434     * Retrieves a reference to the form that the object is embedded in.
6435     */
6436    readonly form: HTMLFormElement | null;
6437    /**
6438     * Overrides the action attribute (where the data on a form is sent) on the parent form element.
6439     */
6440    formAction: string;
6441    /**
6442     * Used to override the encoding (formEnctype attribute) specified on the form element.
6443     */
6444    formEnctype: string;
6445    /**
6446     * Overrides the submit method attribute previously specified on a form element.
6447     */
6448    formMethod: string;
6449    /**
6450     * Overrides any validation or required attributes on a form or form elements to allow it to be submitted without validation. This can be used to create a "save draft"-type submit option.
6451     */
6452    formNoValidate: boolean;
6453    /**
6454     * Overrides the target attribute on a form element.
6455     */
6456    formTarget: string;
6457    readonly labels: NodeListOf<HTMLLabelElement>;
6458    /**
6459     * Sets or retrieves the name of the object.
6460     */
6461    name: string;
6462    /**
6463     * Gets the classification and default behavior of the button.
6464     */
6465    type: string;
6466    /**
6467     * Returns the error message that would be displayed if the user submits the form, or an empty string if no error message. It also triggers the standard error message, such as "this is a required field". The result is that the user sees validation messages without actually submitting.
6468     */
6469    readonly validationMessage: string;
6470    /**
6471     * Returns a  ValidityState object that represents the validity states of an element.
6472     */
6473    readonly validity: ValidityState;
6474    /**
6475     * Sets or retrieves the default or selected value of the control.
6476     */
6477    value: string;
6478    /**
6479     * Returns whether an element will successfully validate based on forms validation rules and constraints.
6480     */
6481    readonly willValidate: boolean;
6482    /**
6483     * Returns whether a form will validate when it is submitted, without having to submit it.
6484     */
6485    checkValidity(): boolean;
6486    reportValidity(): boolean;
6487    /**
6488     * Sets a custom error message that is displayed when a form is submitted.
6489     * @param error Sets a custom error message that is displayed when a form is submitted.
6490     */
6491    setCustomValidity(error: string): void;
6492    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLButtonElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6493    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6494    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLButtonElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6495    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6496}
6497
6498declare var HTMLButtonElement: {
6499    prototype: HTMLButtonElement;
6500    new(): HTMLButtonElement;
6501};
6502
6503/** Provides properties and methods for manipulating the layout and presentation of <canvas> elements. The HTMLCanvasElement interface also inherits the properties and methods of the HTMLElement interface. */
6504interface HTMLCanvasElement extends HTMLElement {
6505    /**
6506     * Gets or sets the height of a canvas element on a document.
6507     */
6508    height: number;
6509    /**
6510     * Gets or sets the width of a canvas element on a document.
6511     */
6512    width: number;
6513    /**
6514     * Returns an object that provides methods and properties for drawing and manipulating images and graphics on a canvas element in a document. A context object includes information about colors, line widths, fonts, and other graphic parameters that can be drawn on a canvas.
6515     * @param contextId The identifier (ID) of the type of canvas to create. Internet Explorer 9 and Internet Explorer 10 support only a 2-D context using canvas.getContext("2d"); IE11 Preview also supports 3-D or WebGL context using canvas.getContext("experimental-webgl");
6516     */
6517    getContext(contextId: "2d", options?: CanvasRenderingContext2DSettings): CanvasRenderingContext2D | null;
6518    getContext(contextId: "bitmaprenderer", options?: ImageBitmapRenderingContextSettings): ImageBitmapRenderingContext | null;
6519    getContext(contextId: "webgl", options?: WebGLContextAttributes): WebGLRenderingContext | null;
6520    getContext(contextId: "webgl2", options?: WebGLContextAttributes): WebGL2RenderingContext | null;
6521    getContext(contextId: string, options?: any): RenderingContext | null;
6522    toBlob(callback: BlobCallback, type?: string, quality?: any): void;
6523    /**
6524     * Returns the content of the current canvas as an image that you can use as a source for another canvas or an HTML element.
6525     * @param type The standard MIME type for the image format to return. If you do not specify this parameter, the default value is a PNG format image.
6526     */
6527    toDataURL(type?: string, quality?: any): string;
6528    transferControlToOffscreen(): OffscreenCanvas;
6529    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLCanvasElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6530    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6531    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLCanvasElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6532    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6533}
6534
6535declare var HTMLCanvasElement: {
6536    prototype: HTMLCanvasElement;
6537    new(): HTMLCanvasElement;
6538};
6539
6540/** A generic collection (array-like object similar to arguments) of elements (in document order) and offers methods and properties for selecting from the list. */
6541interface HTMLCollectionBase {
6542    /**
6543     * Sets or retrieves the number of objects in a collection.
6544     */
6545    readonly length: number;
6546    /**
6547     * Retrieves an object from various collections.
6548     */
6549    item(index: number): Element | null;
6550    [index: number]: Element;
6551}
6552
6553interface HTMLCollection extends HTMLCollectionBase {
6554    /**
6555     * Retrieves a select object or an object from an options collection.
6556     */
6557    namedItem(name: string): Element | null;
6558}
6559
6560declare var HTMLCollection: {
6561    prototype: HTMLCollection;
6562    new(): HTMLCollection;
6563};
6564
6565interface HTMLCollectionOf<T extends Element> extends HTMLCollectionBase {
6566    item(index: number): T | null;
6567    namedItem(name: string): T | null;
6568    [index: number]: T;
6569}
6570
6571/** Provides special properties (beyond those of the regular HTMLElement interface it also has available to it by inheritance) for manipulating definition list (<dl>) elements. */
6572interface HTMLDListElement extends HTMLElement {
6573    /** @deprecated */
6574    compact: boolean;
6575    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDListElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6576    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6577    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDListElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6578    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6579}
6580
6581declare var HTMLDListElement: {
6582    prototype: HTMLDListElement;
6583    new(): HTMLDListElement;
6584};
6585
6586/** Provides special properties (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating <data> elements. */
6587interface HTMLDataElement extends HTMLElement {
6588    value: string;
6589    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDataElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6590    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6591    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDataElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6592    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6593}
6594
6595declare var HTMLDataElement: {
6596    prototype: HTMLDataElement;
6597    new(): HTMLDataElement;
6598};
6599
6600/** Provides special properties (beyond the HTMLElement object interface it also has available to it by inheritance) to manipulate <datalist> elements and their content. */
6601interface HTMLDataListElement extends HTMLElement {
6602    readonly options: HTMLCollectionOf<HTMLOptionElement>;
6603    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDataListElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6604    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6605    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDataListElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6606    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6607}
6608
6609declare var HTMLDataListElement: {
6610    prototype: HTMLDataListElement;
6611    new(): HTMLDataListElement;
6612};
6613
6614interface HTMLDetailsElement extends HTMLElement {
6615    open: boolean;
6616    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDetailsElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6617    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6618    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDetailsElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6619    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6620}
6621
6622declare var HTMLDetailsElement: {
6623    prototype: HTMLDetailsElement;
6624    new(): HTMLDetailsElement;
6625};
6626
6627interface HTMLDialogElement extends HTMLElement {
6628    open: boolean;
6629    returnValue: string;
6630    close(returnValue?: string): void;
6631    show(): void;
6632    showModal(): void;
6633    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDialogElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6634    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6635    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDialogElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6636    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6637}
6638
6639declare var HTMLDialogElement: {
6640    prototype: HTMLDialogElement;
6641    new(): HTMLDialogElement;
6642};
6643
6644interface HTMLDirectoryElement extends HTMLElement {
6645    /** @deprecated */
6646    compact: boolean;
6647    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDirectoryElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6648    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6649    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDirectoryElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6650    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6651}
6652
6653declare var HTMLDirectoryElement: {
6654    prototype: HTMLDirectoryElement;
6655    new(): HTMLDirectoryElement;
6656};
6657
6658/** Provides special properties (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating <div> elements. */
6659interface HTMLDivElement extends HTMLElement {
6660    /**
6661     * Sets or retrieves how the object is aligned with adjacent text.
6662     */
6663    /** @deprecated */
6664    align: string;
6665    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDivElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6666    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6667    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDivElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6668    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6669}
6670
6671declare var HTMLDivElement: {
6672    prototype: HTMLDivElement;
6673    new(): HTMLDivElement;
6674};
6675
6676/** The HTMLDocument property of Window objects is an alias that browsers expose for the Document interface object. */
6677interface HTMLDocument extends Document {
6678    addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: HTMLDocument, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6679    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6680    removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: HTMLDocument, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6681    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6682}
6683
6684declare var HTMLDocument: {
6685    prototype: HTMLDocument;
6686    new(): HTMLDocument;
6687};
6688
6689interface HTMLElementEventMap extends ElementEventMap, GlobalEventHandlersEventMap, DocumentAndElementEventHandlersEventMap {
6690}
6691
6692/** Any HTML element. Some elements directly implement this interface, while others implement it via an interface that inherits it. */
6693interface HTMLElement extends Element, DocumentAndElementEventHandlers, ElementCSSInlineStyle, ElementContentEditable, GlobalEventHandlers, HTMLOrSVGElement {
6694    accessKey: string;
6695    readonly accessKeyLabel: string;
6696    autocapitalize: string;
6697    dir: string;
6698    draggable: boolean;
6699    hidden: boolean;
6700    innerText: string;
6701    lang: string;
6702    readonly offsetHeight: number;
6703    readonly offsetLeft: number;
6704    readonly offsetParent: Element | null;
6705    readonly offsetTop: number;
6706    readonly offsetWidth: number;
6707    spellcheck: boolean;
6708    title: string;
6709    translate: boolean;
6710    click(): void;
6711    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6712    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6713    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6714    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6715}
6716
6717declare var HTMLElement: {
6718    prototype: HTMLElement;
6719    new(): HTMLElement;
6720};
6721
6722/** Provides special properties (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating <embed> elements. */
6723interface HTMLEmbedElement extends HTMLElement {
6724    /** @deprecated */
6725    align: string;
6726    /**
6727     * Sets or retrieves the height of the object.
6728     */
6729    height: string;
6730    /**
6731     * Sets or retrieves the name of the object.
6732     */
6733    /** @deprecated */
6734    name: string;
6735    /**
6736     * Sets or retrieves a URL to be loaded by the object.
6737     */
6738    src: string;
6739    type: string;
6740    /**
6741     * Sets or retrieves the width of the object.
6742     */
6743    width: string;
6744    getSVGDocument(): Document | null;
6745    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLEmbedElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6746    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6747    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLEmbedElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6748    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6749}
6750
6751declare var HTMLEmbedElement: {
6752    prototype: HTMLEmbedElement;
6753    new(): HTMLEmbedElement;
6754};
6755
6756/** Provides special properties and methods (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating the layout and presentation of <fieldset> elements. */
6757interface HTMLFieldSetElement extends HTMLElement {
6758    disabled: boolean;
6759    readonly elements: HTMLCollection;
6760    /**
6761     * Retrieves a reference to the form that the object is embedded in.
6762     */
6763    readonly form: HTMLFormElement | null;
6764    name: string;
6765    readonly type: string;
6766    /**
6767     * Returns the error message that would be displayed if the user submits the form, or an empty string if no error message. It also triggers the standard error message, such as "this is a required field". The result is that the user sees validation messages without actually submitting.
6768     */
6769    readonly validationMessage: string;
6770    /**
6771     * Returns a  ValidityState object that represents the validity states of an element.
6772     */
6773    readonly validity: ValidityState;
6774    /**
6775     * Returns whether an element will successfully validate based on forms validation rules and constraints.
6776     */
6777    readonly willValidate: boolean;
6778    /**
6779     * Returns whether a form will validate when it is submitted, without having to submit it.
6780     */
6781    checkValidity(): boolean;
6782    reportValidity(): boolean;
6783    /**
6784     * Sets a custom error message that is displayed when a form is submitted.
6785     * @param error Sets a custom error message that is displayed when a form is submitted.
6786     */
6787    setCustomValidity(error: string): void;
6788    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLFieldSetElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6789    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6790    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLFieldSetElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6791    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6792}
6793
6794declare var HTMLFieldSetElement: {
6795    prototype: HTMLFieldSetElement;
6796    new(): HTMLFieldSetElement;
6797};
6798
6799/** Implements the document object model (DOM) representation of the font element. The HTML Font Element <font> defines the font size, font face and color of text. */
6800interface HTMLFontElement extends HTMLElement {
6801    /** @deprecated */
6802    color: string;
6803    /**
6804     * Sets or retrieves the current typeface family.
6805     */
6806    /** @deprecated */
6807    face: string;
6808    /** @deprecated */
6809    size: string;
6810    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLFontElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6811    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6812    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLFontElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6813    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6814}
6815
6816declare var HTMLFontElement: {
6817    prototype: HTMLFontElement;
6818    new(): HTMLFontElement;
6819};
6820
6821/** A collection of HTML form control elements.  */
6822interface HTMLFormControlsCollection extends HTMLCollectionBase {
6823    /**
6824     * Returns the item with ID or name name from the collection.
6825     * 
6826     * If there are multiple matching items, then a RadioNodeList object containing all those elements is returned.
6827     */
6828    namedItem(name: string): RadioNodeList | Element | null;
6829}
6830
6831declare var HTMLFormControlsCollection: {
6832    prototype: HTMLFormControlsCollection;
6833    new(): HTMLFormControlsCollection;
6834};
6835
6836/** A <form> element in the DOM; it allows access to and in some cases modification of aspects of the form, as well as access to its component elements. */
6837interface HTMLFormElement extends HTMLElement {
6838    /**
6839     * Sets or retrieves a list of character encodings for input data that must be accepted by the server processing the form.
6840     */
6841    acceptCharset: string;
6842    /**
6843     * Sets or retrieves the URL to which the form content is sent for processing.
6844     */
6845    action: string;
6846    /**
6847     * Specifies whether autocomplete is applied to an editable text field.
6848     */
6849    autocomplete: string;
6850    /**
6851     * Retrieves a collection, in source order, of all controls in a given form.
6852     */
6853    readonly elements: HTMLFormControlsCollection;
6854    /**
6855     * Sets or retrieves the MIME encoding for the form.
6856     */
6857    encoding: string;
6858    /**
6859     * Sets or retrieves the encoding type for the form.
6860     */
6861    enctype: string;
6862    /**
6863     * Sets or retrieves the number of objects in a collection.
6864     */
6865    readonly length: number;
6866    /**
6867     * Sets or retrieves how to send the form data to the server.
6868     */
6869    method: string;
6870    /**
6871     * Sets or retrieves the name of the object.
6872     */
6873    name: string;
6874    /**
6875     * Designates a form that is not validated when submitted.
6876     */
6877    noValidate: boolean;
6878    /**
6879     * Sets or retrieves the window or frame at which to target content.
6880     */
6881    target: string;
6882    /**
6883     * Returns whether a form will validate when it is submitted, without having to submit it.
6884     */
6885    checkValidity(): boolean;
6886    reportValidity(): boolean;
6887    /**
6888     * Fires when the user resets a form.
6889     */
6890    reset(): void;
6891    /**
6892     * Fires when a FORM is about to be submitted.
6893     */
6894    submit(): void;
6895    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLFormElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6896    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6897    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLFormElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6898    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6899    [index: number]: Element;
6900    [name: string]: any;
6901}
6902
6903declare var HTMLFormElement: {
6904    prototype: HTMLFormElement;
6905    new(): HTMLFormElement;
6906};
6907
6908interface HTMLFrameElement extends HTMLElement {
6909    /**
6910     * Retrieves the document object of the page or frame.
6911     */
6912    /** @deprecated */
6913    readonly contentDocument: Document | null;
6914    /**
6915     * Retrieves the object of the specified.
6916     */
6917    /** @deprecated */
6918    readonly contentWindow: WindowProxy | null;
6919    /**
6920     * Sets or retrieves whether to display a border for the frame.
6921     */
6922    /** @deprecated */
6923    frameBorder: string;
6924    /**
6925     * Sets or retrieves a URI to a long description of the object.
6926     */
6927    /** @deprecated */
6928    longDesc: string;
6929    /**
6930     * Sets or retrieves the top and bottom margin heights before displaying the text in a frame.
6931     */
6932    /** @deprecated */
6933    marginHeight: string;
6934    /**
6935     * Sets or retrieves the left and right margin widths before displaying the text in a frame.
6936     */
6937    /** @deprecated */
6938    marginWidth: string;
6939    /**
6940     * Sets or retrieves the frame name.
6941     */
6942    /** @deprecated */
6943    name: string;
6944    /**
6945     * Sets or retrieves whether the user can resize the frame.
6946     */
6947    /** @deprecated */
6948    noResize: boolean;
6949    /**
6950     * Sets or retrieves whether the frame can be scrolled.
6951     */
6952    /** @deprecated */
6953    scrolling: string;
6954    /**
6955     * Sets or retrieves a URL to be loaded by the object.
6956     */
6957    /** @deprecated */
6958    src: string;
6959    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLFrameElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6960    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6961    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLFrameElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6962    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6963}
6964
6965declare var HTMLFrameElement: {
6966    prototype: HTMLFrameElement;
6967    new(): HTMLFrameElement;
6968};
6969
6970interface HTMLFrameSetElementEventMap extends HTMLElementEventMap, WindowEventHandlersEventMap {
6971}
6972
6973/** Provides special properties (beyond those of the regular HTMLElement interface they also inherit) for manipulating <frameset> elements. */
6974interface HTMLFrameSetElement extends HTMLElement, WindowEventHandlers {
6975    /**
6976     * Sets or retrieves the frame widths of the object.
6977     */
6978    /** @deprecated */
6979    cols: string;
6980    /**
6981     * Sets or retrieves the frame heights of the object.
6982     */
6983    /** @deprecated */
6984    rows: string;
6985    addEventListener<K extends keyof HTMLFrameSetElementEventMap>(type: K, listener: (this: HTMLFrameSetElement, ev: HTMLFrameSetElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6986    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6987    removeEventListener<K extends keyof HTMLFrameSetElementEventMap>(type: K, listener: (this: HTMLFrameSetElement, ev: HTMLFrameSetElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6988    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6989}
6990
6991declare var HTMLFrameSetElement: {
6992    prototype: HTMLFrameSetElement;
6993    new(): HTMLFrameSetElement;
6994};
6995
6996/** Provides special properties (beyond those of the HTMLElement interface it also has available to it by inheritance) for manipulating <hr> elements. */
6997interface HTMLHRElement extends HTMLElement {
6998    /**
6999     * Sets or retrieves how the object is aligned with adjacent text.
7000     */
7001    /** @deprecated */
7002    align: string;
7003    /** @deprecated */
7004    color: string;
7005    /**
7006     * Sets or retrieves whether the horizontal rule is drawn with 3-D shading.
7007     */
7008    /** @deprecated */
7009    noShade: boolean;
7010    /** @deprecated */
7011    size: string;
7012    /**
7013     * Sets or retrieves the width of the object.
7014     */
7015    /** @deprecated */
7016    width: string;
7017    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLHRElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7018    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7019    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLHRElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7020    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7021}
7022
7023declare var HTMLHRElement: {
7024    prototype: HTMLHRElement;
7025    new(): HTMLHRElement;
7026};
7027
7028/** Contains the descriptive information, or metadata, for a document. This object inherits all of the properties and methods described in the HTMLElement interface. */
7029interface HTMLHeadElement extends HTMLElement {
7030    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLHeadElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7031    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7032    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLHeadElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7033    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7034}
7035
7036declare var HTMLHeadElement: {
7037    prototype: HTMLHeadElement;
7038    new(): HTMLHeadElement;
7039};
7040
7041/** The different heading elements. It inherits methods and properties from the HTMLElement interface. */
7042interface HTMLHeadingElement extends HTMLElement {
7043    /**
7044     * Sets or retrieves a value that indicates the table alignment.
7045     */
7046    /** @deprecated */
7047    align: string;
7048    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLHeadingElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7049    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7050    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLHeadingElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7051    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7052}
7053
7054declare var HTMLHeadingElement: {
7055    prototype: HTMLHeadingElement;
7056    new(): HTMLHeadingElement;
7057};
7058
7059/** Serves as the root node for a given HTML document. This object inherits the properties and methods described in the HTMLElement interface. */
7060interface HTMLHtmlElement extends HTMLElement {
7061    /**
7062     * Sets or retrieves the DTD version that governs the current document.
7063     */
7064    /** @deprecated */
7065    version: string;
7066    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLHtmlElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7067    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7068    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLHtmlElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7069    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7070}
7071
7072declare var HTMLHtmlElement: {
7073    prototype: HTMLHtmlElement;
7074    new(): HTMLHtmlElement;
7075};
7076
7077interface HTMLHyperlinkElementUtils {
7078    hash: string;
7079    host: string;
7080    hostname: string;
7081    href: string;
7082    readonly origin: string;
7083    password: string;
7084    pathname: string;
7085    port: string;
7086    protocol: string;
7087    search: string;
7088    username: string;
7089}
7090
7091/** Provides special properties and methods (beyond those of the HTMLElement interface it also has available to it by inheritance) for manipulating the layout and presentation of inline frame elements. */
7092interface HTMLIFrameElement extends HTMLElement {
7093    /**
7094     * Sets or retrieves how the object is aligned with adjacent text.
7095     */
7096    /** @deprecated */
7097    align: string;
7098    allow: string;
7099    allowFullscreen: boolean;
7100    allowPaymentRequest: boolean;
7101    /**
7102     * Retrieves the document object of the page or frame.
7103     */
7104    readonly contentDocument: Document | null;
7105    /**
7106     * Retrieves the object of the specified.
7107     */
7108    readonly contentWindow: WindowProxy | null;
7109    /**
7110     * Sets or retrieves whether to display a border for the frame.
7111     */
7112    /** @deprecated */
7113    frameBorder: string;
7114    /**
7115     * Sets or retrieves the height of the object.
7116     */
7117    height: string;
7118    /**
7119     * Sets or retrieves a URI to a long description of the object.
7120     */
7121    /** @deprecated */
7122    longDesc: string;
7123    /**
7124     * Sets or retrieves the top and bottom margin heights before displaying the text in a frame.
7125     */
7126    /** @deprecated */
7127    marginHeight: string;
7128    /**
7129     * Sets or retrieves the left and right margin widths before displaying the text in a frame.
7130     */
7131    /** @deprecated */
7132    marginWidth: string;
7133    /**
7134     * Sets or retrieves the frame name.
7135     */
7136    name: string;
7137    referrerPolicy: ReferrerPolicy;
7138    readonly sandbox: DOMTokenList;
7139    /**
7140     * Sets or retrieves whether the frame can be scrolled.
7141     */
7142    /** @deprecated */
7143    scrolling: string;
7144    /**
7145     * Sets or retrieves a URL to be loaded by the object.
7146     */
7147    src: string;
7148    /**
7149     * Sets or retrives the content of the page that is to contain.
7150     */
7151    srcdoc: string;
7152    /**
7153     * Sets or retrieves the width of the object.
7154     */
7155    width: string;
7156    getSVGDocument(): Document | null;
7157    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLIFrameElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7158    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7159    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLIFrameElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7160    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7161}
7162
7163declare var HTMLIFrameElement: {
7164    prototype: HTMLIFrameElement;
7165    new(): HTMLIFrameElement;
7166};
7167
7168/** Provides special properties and methods for manipulating <img> elements. */
7169interface HTMLImageElement extends HTMLElement {
7170    /**
7171     * Sets or retrieves how the object is aligned with adjacent text.
7172     */
7173    /** @deprecated */
7174    align: string;
7175    /**
7176     * Sets or retrieves a text alternative to the graphic.
7177     */
7178    alt: string;
7179    /**
7180     * Specifies the properties of a border drawn around an object.
7181     */
7182    /** @deprecated */
7183    border: string;
7184    /**
7185     * Retrieves whether the object is fully loaded.
7186     */
7187    readonly complete: boolean;
7188    crossOrigin: string | null;
7189    readonly currentSrc: string;
7190    decoding: "async" | "sync" | "auto";
7191    /**
7192     * Sets or retrieves the height of the object.
7193     */
7194    height: number;
7195    /**
7196     * Sets or retrieves the width of the border to draw around the object.
7197     */
7198    /** @deprecated */
7199    hspace: number;
7200    /**
7201     * Sets or retrieves whether the image is a server-side image map.
7202     */
7203    isMap: boolean;
7204    /**
7205     * Sets or retrieves a Uniform Resource Identifier (URI) to a long description of the object.
7206     */
7207    /** @deprecated */
7208    longDesc: string;
7209    /** @deprecated */
7210    lowsrc: string;
7211    /**
7212     * Sets or retrieves the name of the object.
7213     */
7214    /** @deprecated */
7215    name: string;
7216    /**
7217     * The original height of the image resource before sizing.
7218     */
7219    readonly naturalHeight: number;
7220    /**
7221     * The original width of the image resource before sizing.
7222     */
7223    readonly naturalWidth: number;
7224    referrerPolicy: string;
7225    sizes: string;
7226    /**
7227     * The address or URL of the a media resource that is to be considered.
7228     */
7229    src: string;
7230    srcset: string;
7231    /**
7232     * Sets or retrieves the URL, often with a bookmark extension (#name), to use as a client-side image map.
7233     */
7234    useMap: string;
7235    /**
7236     * Sets or retrieves the vertical margin for the object.
7237     */
7238    /** @deprecated */
7239    vspace: number;
7240    /**
7241     * Sets or retrieves the width of the object.
7242     */
7243    width: number;
7244    readonly x: number;
7245    readonly y: number;
7246    decode(): Promise<void>;
7247    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLImageElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7248    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7249    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLImageElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7250    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7251}
7252
7253declare var HTMLImageElement: {
7254    prototype: HTMLImageElement;
7255    new(): HTMLImageElement;
7256};
7257
7258/** Provides special properties and methods for manipulating the options, layout, and presentation of <input> elements. */
7259interface HTMLInputElement extends HTMLElement {
7260    /**
7261     * Sets or retrieves a comma-separated list of content types.
7262     */
7263    accept: string;
7264    /**
7265     * Sets or retrieves how the object is aligned with adjacent text.
7266     */
7267    /** @deprecated */
7268    align: string;
7269    /**
7270     * Sets or retrieves a text alternative to the graphic.
7271     */
7272    alt: string;
7273    /**
7274     * Specifies whether autocomplete is applied to an editable text field.
7275     */
7276    autocomplete: string;
7277    /**
7278     * Provides a way to direct a user to a specific field when a document loads. This can provide both direction and convenience for a user, reducing the need to click or tab to a field when a page opens. This attribute is true when present on an element, and false when missing.
7279     */
7280    autofocus: boolean;
7281    /**
7282     * Sets or retrieves the state of the check box or radio button.
7283     */
7284    checked: boolean;
7285    /**
7286     * Sets or retrieves the state of the check box or radio button.
7287     */
7288    defaultChecked: boolean;
7289    /**
7290     * Sets or retrieves the initial contents of the object.
7291     */
7292    defaultValue: string;
7293    dirName: string;
7294    disabled: boolean;
7295    /**
7296     * Returns a FileList object on a file type input object.
7297     */
7298    files: FileList | null;
7299    /**
7300     * Retrieves a reference to the form that the object is embedded in.
7301     */
7302    readonly form: HTMLFormElement | null;
7303    /**
7304     * Overrides the action attribute (where the data on a form is sent) on the parent form element.
7305     */
7306    formAction: string;
7307    /**
7308     * Used to override the encoding (formEnctype attribute) specified on the form element.
7309     */
7310    formEnctype: string;
7311    /**
7312     * Overrides the submit method attribute previously specified on a form element.
7313     */
7314    formMethod: string;
7315    /**
7316     * Overrides any validation or required attributes on a form or form elements to allow it to be submitted without validation. This can be used to create a "save draft"-type submit option.
7317     */
7318    formNoValidate: boolean;
7319    /**
7320     * Overrides the target attribute on a form element.
7321     */
7322    formTarget: string;
7323    /**
7324     * Sets or retrieves the height of the object.
7325     */
7326    height: number;
7327    indeterminate: boolean;
7328    readonly labels: NodeListOf<HTMLLabelElement> | null;
7329    /**
7330     * Specifies the ID of a pre-defined datalist of options for an input element.
7331     */
7332    readonly list: HTMLElement | null;
7333    /**
7334     * Defines the maximum acceptable value for an input element with type="number".When used with the min and step attributes, lets you control the range and increment (such as only even numbers) that the user can enter into an input field.
7335     */
7336    max: string;
7337    /**
7338     * Sets or retrieves the maximum number of characters that the user can enter in a text control.
7339     */
7340    maxLength: number;
7341    /**
7342     * Defines the minimum acceptable value for an input element with type="number". When used with the max and step attributes, lets you control the range and increment (such as even numbers only) that the user can enter into an input field.
7343     */
7344    min: string;
7345    minLength: number;
7346    /**
7347     * Sets or retrieves the Boolean value indicating whether multiple items can be selected from a list.
7348     */
7349    multiple: boolean;
7350    /**
7351     * Sets or retrieves the name of the object.
7352     */
7353    name: string;
7354    /**
7355     * Gets or sets a string containing a regular expression that the user's input must match.
7356     */
7357    pattern: string;
7358    /**
7359     * Gets or sets a text string that is displayed in an input field as a hint or prompt to users as the format or type of information they need to enter.The text appears in an input field until the user puts focus on the field.
7360     */
7361    placeholder: string;
7362    readOnly: boolean;
7363    /**
7364     * When present, marks an element that can't be submitted without a value.
7365     */
7366    required: boolean;
7367    selectionDirection: string | null;
7368    /**
7369     * Gets or sets the end position or offset of a text selection.
7370     */
7371    selectionEnd: number | null;
7372    /**
7373     * Gets or sets the starting position or offset of a text selection.
7374     */
7375    selectionStart: number | null;
7376    size: number;
7377    /**
7378     * The address or URL of the a media resource that is to be considered.
7379     */
7380    src: string;
7381    /**
7382     * Defines an increment or jump between values that you want to allow the user to enter. When used with the max and min attributes, lets you control the range and increment (for example, allow only even numbers) that the user can enter into an input field.
7383     */
7384    step: string;
7385    /**
7386     * Returns the content type of the object.
7387     */
7388    type: string;
7389    /**
7390     * Sets or retrieves the URL, often with a bookmark extension (#name), to use as a client-side image map.
7391     */
7392    /** @deprecated */
7393    useMap: string;
7394    /**
7395     * Returns the error message that would be displayed if the user submits the form, or an empty string if no error message. It also triggers the standard error message, such as "this is a required field". The result is that the user sees validation messages without actually submitting.
7396     */
7397    readonly validationMessage: string;
7398    /**
7399     * Returns a  ValidityState object that represents the validity states of an element.
7400     */
7401    readonly validity: ValidityState;
7402    /**
7403     * Returns the value of the data at the cursor's current position.
7404     */
7405    value: string;
7406    /**
7407     * Returns a Date object representing the form control's value, if applicable; otherwise, returns null. Can be set, to change the value. Throws an "InvalidStateError" DOMException if the control isn't date- or time-based.
7408     */
7409    valueAsDate: Date | null;
7410    /**
7411     * Returns the input field value as a number.
7412     */
7413    valueAsNumber: number;
7414    /**
7415     * Sets or retrieves the width of the object.
7416     */
7417    width: number;
7418    /**
7419     * Returns whether an element will successfully validate based on forms validation rules and constraints.
7420     */
7421    readonly willValidate: boolean;
7422    /**
7423     * Returns whether a form will validate when it is submitted, without having to submit it.
7424     */
7425    checkValidity(): boolean;
7426    reportValidity(): boolean;
7427    /**
7428     * Makes the selection equal to the current object.
7429     */
7430    select(): void;
7431    /**
7432     * Sets a custom error message that is displayed when a form is submitted.
7433     * @param error Sets a custom error message that is displayed when a form is submitted.
7434     */
7435    setCustomValidity(error: string): void;
7436    setRangeText(replacement: string): void;
7437    setRangeText(replacement: string, start: number, end: number, selectionMode?: SelectionMode): void;
7438    /**
7439     * Sets the start and end positions of a selection in a text field.
7440     * @param start The offset into the text field for the start of the selection.
7441     * @param end The offset into the text field for the end of the selection.
7442     * @param direction The direction in which the selection is performed.
7443     */
7444    setSelectionRange(start: number, end: number, direction?: "forward" | "backward" | "none"): void;
7445    /**
7446     * Decrements a range input control's value by the value given by the Step attribute. If the optional parameter is used, it will decrement the input control's step value multiplied by the parameter's value.
7447     * @param n Value to decrement the value by.
7448     */
7449    stepDown(n?: number): void;
7450    /**
7451     * Increments a range input control's value by the value given by the Step attribute. If the optional parameter is used, will increment the input control's value by that value.
7452     * @param n Value to increment the value by.
7453     */
7454    stepUp(n?: number): void;
7455    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLInputElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7456    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7457    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLInputElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7458    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7459}
7460
7461declare var HTMLInputElement: {
7462    prototype: HTMLInputElement;
7463    new(): HTMLInputElement;
7464};
7465
7466/** Exposes specific properties and methods (beyond those defined by regular HTMLElement interface it also has available to it by inheritance) for manipulating list elements. */
7467interface HTMLLIElement extends HTMLElement {
7468    /** @deprecated */
7469    type: string;
7470    /**
7471     * Sets or retrieves the value of a list item.
7472     */
7473    value: number;
7474    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLLIElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7475    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7476    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLLIElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7477    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7478}
7479
7480declare var HTMLLIElement: {
7481    prototype: HTMLLIElement;
7482    new(): HTMLLIElement;
7483};
7484
7485/** Gives access to properties specific to <label> elements. It inherits methods and properties from the base HTMLElement interface. */
7486interface HTMLLabelElement extends HTMLElement {
7487    readonly control: HTMLElement | null;
7488    /**
7489     * Retrieves a reference to the form that the object is embedded in.
7490     */
7491    readonly form: HTMLFormElement | null;
7492    /**
7493     * Sets or retrieves the object to which the given label object is assigned.
7494     */
7495    htmlFor: string;
7496    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLLabelElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7497    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7498    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLLabelElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7499    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7500}
7501
7502declare var HTMLLabelElement: {
7503    prototype: HTMLLabelElement;
7504    new(): HTMLLabelElement;
7505};
7506
7507/** The HTMLLegendElement is an interface allowing to access properties of the <legend> elements. It inherits properties and methods from the HTMLElement interface. */
7508interface HTMLLegendElement extends HTMLElement {
7509    /** @deprecated */
7510    align: string;
7511    /**
7512     * Retrieves a reference to the form that the object is embedded in.
7513     */
7514    readonly form: HTMLFormElement | null;
7515    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLLegendElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7516    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7517    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLLegendElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7518    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7519}
7520
7521declare var HTMLLegendElement: {
7522    prototype: HTMLLegendElement;
7523    new(): HTMLLegendElement;
7524};
7525
7526/** Reference information for external resources and the relationship of those resources to a document and vice-versa. This object inherits all of the properties and methods of the HTMLElement interface. */
7527interface HTMLLinkElement extends HTMLElement, LinkStyle {
7528    as: string;
7529    /**
7530     * Sets or retrieves the character set used to encode the object.
7531     */
7532    /** @deprecated */
7533    charset: string;
7534    crossOrigin: string | null;
7535    disabled: boolean;
7536    /**
7537     * Sets or retrieves a destination URL or an anchor point.
7538     */
7539    href: string;
7540    /**
7541     * Sets or retrieves the language code of the object.
7542     */
7543    hreflang: string;
7544    imageSizes: string;
7545    imageSrcset: string;
7546    integrity: string;
7547    /**
7548     * Sets or retrieves the media type.
7549     */
7550    media: string;
7551    referrerPolicy: string;
7552    /**
7553     * Sets or retrieves the relationship between the object and the destination of the link.
7554     */
7555    rel: string;
7556    readonly relList: DOMTokenList;
7557    /**
7558     * Sets or retrieves the relationship between the object and the destination of the link.
7559     */
7560    /** @deprecated */
7561    rev: string;
7562    readonly sizes: DOMTokenList;
7563    /**
7564     * Sets or retrieves the window or frame at which to target content.
7565     */
7566    /** @deprecated */
7567    target: string;
7568    /**
7569     * Sets or retrieves the MIME type of the object.
7570     */
7571    type: string;
7572    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLLinkElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7573    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7574    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLLinkElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7575    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7576}
7577
7578declare var HTMLLinkElement: {
7579    prototype: HTMLLinkElement;
7580    new(): HTMLLinkElement;
7581};
7582
7583/** Provides special properties and methods (beyond those of the regular object HTMLElement interface it also has available to it by inheritance) for manipulating the layout and presentation of map elements. */
7584interface HTMLMapElement extends HTMLElement {
7585    /**
7586     * Retrieves a collection of the area objects defined for the given map object.
7587     */
7588    readonly areas: HTMLCollection;
7589    /**
7590     * Sets or retrieves the name of the object.
7591     */
7592    name: string;
7593    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLMapElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7594    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7595    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLMapElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7596    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7597}
7598
7599declare var HTMLMapElement: {
7600    prototype: HTMLMapElement;
7601    new(): HTMLMapElement;
7602};
7603
7604interface HTMLMarqueeElementEventMap extends HTMLElementEventMap {
7605    "bounce": Event;
7606    "finish": Event;
7607    "start": Event;
7608}
7609
7610/** Provides methods to manipulate <marquee> elements. */
7611interface HTMLMarqueeElement extends HTMLElement {
7612    /** @deprecated */
7613    behavior: string;
7614    /** @deprecated */
7615    bgColor: string;
7616    /** @deprecated */
7617    direction: string;
7618    /** @deprecated */
7619    height: string;
7620    /** @deprecated */
7621    hspace: number;
7622    /** @deprecated */
7623    loop: number;
7624    /** @deprecated */
7625    onbounce: ((this: HTMLMarqueeElement, ev: Event) => any) | null;
7626    /** @deprecated */
7627    onfinish: ((this: HTMLMarqueeElement, ev: Event) => any) | null;
7628    /** @deprecated */
7629    onstart: ((this: HTMLMarqueeElement, ev: Event) => any) | null;
7630    /** @deprecated */
7631    scrollAmount: number;
7632    /** @deprecated */
7633    scrollDelay: number;
7634    /** @deprecated */
7635    trueSpeed: boolean;
7636    /** @deprecated */
7637    vspace: number;
7638    /** @deprecated */
7639    width: string;
7640    /** @deprecated */
7641    start(): void;
7642    /** @deprecated */
7643    stop(): void;
7644    addEventListener<K extends keyof HTMLMarqueeElementEventMap>(type: K, listener: (this: HTMLMarqueeElement, ev: HTMLMarqueeElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7645    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7646    removeEventListener<K extends keyof HTMLMarqueeElementEventMap>(type: K, listener: (this: HTMLMarqueeElement, ev: HTMLMarqueeElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7647    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7648}
7649
7650declare var HTMLMarqueeElement: {
7651    prototype: HTMLMarqueeElement;
7652    new(): HTMLMarqueeElement;
7653};
7654
7655interface HTMLMediaElementEventMap extends HTMLElementEventMap {
7656    "encrypted": MediaEncryptedEvent;
7657    "msneedkey": Event;
7658    "waitingforkey": Event;
7659}
7660
7661/** Adds to HTMLElement the properties and methods needed to support basic media-related capabilities that are common to audio and video. */
7662interface HTMLMediaElement extends HTMLElement {
7663    /**
7664     * Returns an AudioTrackList object with the audio tracks for a given video element.
7665     */
7666    readonly audioTracks: AudioTrackList;
7667    /**
7668     * Gets or sets a value that indicates whether to start playing the media automatically.
7669     */
7670    autoplay: boolean;
7671    /**
7672     * Gets a collection of buffered time ranges.
7673     */
7674    readonly buffered: TimeRanges;
7675    /**
7676     * Gets or sets a flag that indicates whether the client provides a set of controls for the media (in case the developer does not include controls for the player).
7677     */
7678    controls: boolean;
7679    crossOrigin: string | null;
7680    /**
7681     * Gets the address or URL of the current media resource that is selected by IHTMLMediaElement.
7682     */
7683    readonly currentSrc: string;
7684    /**
7685     * Gets or sets the current playback position, in seconds.
7686     */
7687    currentTime: number;
7688    defaultMuted: boolean;
7689    /**
7690     * Gets or sets the default playback rate when the user is not using fast forward or reverse for a video or audio resource.
7691     */
7692    defaultPlaybackRate: number;
7693    /**
7694     * Returns the duration in seconds of the current media resource. A NaN value is returned if duration is not available, or Infinity if the media resource is streaming.
7695     */
7696    readonly duration: number;
7697    /**
7698     * Gets information about whether the playback has ended or not.
7699     */
7700    readonly ended: boolean;
7701    /**
7702     * Returns an object representing the current error state of the audio or video element.
7703     */
7704    readonly error: MediaError | null;
7705    /**
7706     * Gets or sets a flag to specify whether playback should restart after it completes.
7707     */
7708    loop: boolean;
7709    readonly mediaKeys: MediaKeys | null;
7710    /**
7711     * Specifies the purpose of the audio or video media, such as background audio or alerts.
7712     */
7713    msAudioCategory: string;
7714    /**
7715     * Specifies the output device id that the audio will be sent to.
7716     */
7717    msAudioDeviceType: string;
7718    readonly msGraphicsTrustStatus: MSGraphicsTrust;
7719    /**
7720     * Gets the MSMediaKeys object, which is used for decrypting media data, that is associated with this media element.
7721     */
7722    /** @deprecated */
7723    readonly msKeys: MSMediaKeys;
7724    /**
7725     * Gets or sets whether the DLNA PlayTo device is available.
7726     */
7727    msPlayToDisabled: boolean;
7728    /**
7729     * Gets or sets the path to the preferred media source. This enables the Play To target device to stream the media content, which can be DRM protected, from a different location, such as a cloud media server.
7730     */
7731    msPlayToPreferredSourceUri: string;
7732    /**
7733     * Gets or sets the primary DLNA PlayTo device.
7734     */
7735    msPlayToPrimary: boolean;
7736    /**
7737     * Gets the source associated with the media element for use by the PlayToManager.
7738     */
7739    readonly msPlayToSource: any;
7740    /**
7741     * Specifies whether or not to enable low-latency playback on the media element.
7742     */
7743    msRealTime: boolean;
7744    /**
7745     * Gets or sets a flag that indicates whether the audio (either audio or the audio track on video media) is muted.
7746     */
7747    muted: boolean;
7748    /**
7749     * Gets the current network activity for the element.
7750     */
7751    readonly networkState: number;
7752    onencrypted: ((this: HTMLMediaElement, ev: MediaEncryptedEvent) => any) | null;
7753    /** @deprecated */
7754    onmsneedkey: ((this: HTMLMediaElement, ev: Event) => any) | null;
7755    onwaitingforkey: ((this: HTMLMediaElement, ev: Event) => any) | null;
7756    /**
7757     * Gets a flag that specifies whether playback is paused.
7758     */
7759    readonly paused: boolean;
7760    /**
7761     * Gets or sets the current rate of speed for the media resource to play. This speed is expressed as a multiple of the normal speed of the media resource.
7762     */
7763    playbackRate: number;
7764    /**
7765     * Gets TimeRanges for the current media resource that has been played.
7766     */
7767    readonly played: TimeRanges;
7768    /**
7769     * Gets or sets the current playback position, in seconds.
7770     */
7771    preload: string;
7772    readonly readyState: number;
7773    /**
7774     * Returns a TimeRanges object that represents the ranges of the current media resource that can be seeked.
7775     */
7776    readonly seekable: TimeRanges;
7777    /**
7778     * Gets a flag that indicates whether the client is currently moving to a new playback position in the media resource.
7779     */
7780    readonly seeking: boolean;
7781    /**
7782     * The address or URL of the a media resource that is to be considered.
7783     */
7784    src: string;
7785    srcObject: MediaStream | MediaSource | Blob | null;
7786    readonly textTracks: TextTrackList;
7787    readonly videoTracks: VideoTrackList;
7788    /**
7789     * Gets or sets the volume level for audio portions of the media element.
7790     */
7791    volume: number;
7792    addTextTrack(kind: TextTrackKind, label?: string, language?: string): TextTrack;
7793    /**
7794     * Returns a string that specifies whether the client can play a given media resource type.
7795     */
7796    canPlayType(type: string): CanPlayTypeResult;
7797    /**
7798     * Resets the audio or video object and loads a new media resource.
7799     */
7800    load(): void;
7801    /**
7802     * Clears all effects from the media pipeline.
7803     */
7804    msClearEffects(): void;
7805    msGetAsCastingSource(): any;
7806    /**
7807     * Inserts the specified audio effect into media pipeline.
7808     */
7809    msInsertAudioEffect(activatableClassId: string, effectRequired: boolean, config?: any): void;
7810    /** @deprecated */
7811    msSetMediaKeys(mediaKeys: MSMediaKeys): void;
7812    /**
7813     * Specifies the media protection manager for a given media pipeline.
7814     */
7815    msSetMediaProtectionManager(mediaProtectionManager?: any): void;
7816    /**
7817     * Pauses the current playback and sets paused to TRUE. This can be used to test whether the media is playing or paused. You can also use the pause or play events to tell whether the media is playing or not.
7818     */
7819    pause(): void;
7820    /**
7821     * Loads and starts playback of a media resource.
7822     */
7823    play(): Promise<void>;
7824    setMediaKeys(mediaKeys: MediaKeys | null): Promise<void>;
7825    readonly HAVE_CURRENT_DATA: number;
7826    readonly HAVE_ENOUGH_DATA: number;
7827    readonly HAVE_FUTURE_DATA: number;
7828    readonly HAVE_METADATA: number;
7829    readonly HAVE_NOTHING: number;
7830    readonly NETWORK_EMPTY: number;
7831    readonly NETWORK_IDLE: number;
7832    readonly NETWORK_LOADING: number;
7833    readonly NETWORK_NO_SOURCE: number;
7834    addEventListener<K extends keyof HTMLMediaElementEventMap>(type: K, listener: (this: HTMLMediaElement, ev: HTMLMediaElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7835    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7836    removeEventListener<K extends keyof HTMLMediaElementEventMap>(type: K, listener: (this: HTMLMediaElement, ev: HTMLMediaElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7837    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7838}
7839
7840declare var HTMLMediaElement: {
7841    prototype: HTMLMediaElement;
7842    new(): HTMLMediaElement;
7843    readonly HAVE_CURRENT_DATA: number;
7844    readonly HAVE_ENOUGH_DATA: number;
7845    readonly HAVE_FUTURE_DATA: number;
7846    readonly HAVE_METADATA: number;
7847    readonly HAVE_NOTHING: number;
7848    readonly NETWORK_EMPTY: number;
7849    readonly NETWORK_IDLE: number;
7850    readonly NETWORK_LOADING: number;
7851    readonly NETWORK_NO_SOURCE: number;
7852};
7853
7854interface HTMLMenuElement extends HTMLElement {
7855    /** @deprecated */
7856    compact: boolean;
7857    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLMenuElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7858    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7859    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLMenuElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7860    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7861}
7862
7863declare var HTMLMenuElement: {
7864    prototype: HTMLMenuElement;
7865    new(): HTMLMenuElement;
7866};
7867
7868/** Contains descriptive metadata about a document. It inherits all of the properties and methods described in the HTMLElement interface. */
7869interface HTMLMetaElement extends HTMLElement {
7870    /**
7871     * Gets or sets meta-information to associate with httpEquiv or name.
7872     */
7873    content: string;
7874    /**
7875     * Gets or sets information used to bind the value of a content attribute of a meta element to an HTTP response header.
7876     */
7877    httpEquiv: string;
7878    /**
7879     * Sets or retrieves the value specified in the content attribute of the meta object.
7880     */
7881    name: string;
7882    /**
7883     * Sets or retrieves a scheme to be used in interpreting the value of a property specified for the object.
7884     */
7885    /** @deprecated */
7886    scheme: string;
7887    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLMetaElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7888    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7889    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLMetaElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7890    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7891}
7892
7893declare var HTMLMetaElement: {
7894    prototype: HTMLMetaElement;
7895    new(): HTMLMetaElement;
7896};
7897
7898/** The HTML <meter> elements expose the HTMLMeterElement interface, which provides special properties and methods (beyond the HTMLElement object interface they also have available to them by inheritance) for manipulating the layout and presentation of <meter> elements. */
7899interface HTMLMeterElement extends HTMLElement {
7900    high: number;
7901    readonly labels: NodeListOf<HTMLLabelElement>;
7902    low: number;
7903    max: number;
7904    min: number;
7905    optimum: number;
7906    value: number;
7907    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLMeterElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7908    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7909    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLMeterElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7910    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7911}
7912
7913declare var HTMLMeterElement: {
7914    prototype: HTMLMeterElement;
7915    new(): HTMLMeterElement;
7916};
7917
7918/** Provides special properties (beyond the regular methods and properties available through the HTMLElement interface they also have available to them by inheritance) for manipulating modification elements, that is <del> and <ins>. */
7919interface HTMLModElement extends HTMLElement {
7920    /**
7921     * Sets or retrieves reference information about the object.
7922     */
7923    cite: string;
7924    /**
7925     * Sets or retrieves the date and time of a modification to the object.
7926     */
7927    dateTime: string;
7928    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLModElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7929    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7930    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLModElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7931    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7932}
7933
7934declare var HTMLModElement: {
7935    prototype: HTMLModElement;
7936    new(): HTMLModElement;
7937};
7938
7939/** Provides special properties (beyond those defined on the regular HTMLElement interface it also has available to it by inheritance) for manipulating ordered list elements. */
7940interface HTMLOListElement extends HTMLElement {
7941    /** @deprecated */
7942    compact: boolean;
7943    reversed: boolean;
7944    /**
7945     * The starting number.
7946     */
7947    start: number;
7948    type: string;
7949    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLOListElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7950    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7951    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLOListElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7952    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7953}
7954
7955declare var HTMLOListElement: {
7956    prototype: HTMLOListElement;
7957    new(): HTMLOListElement;
7958};
7959
7960/** Provides special properties and methods (beyond those on the HTMLElement interface it also has available to it by inheritance) for manipulating the layout and presentation of <object> element, representing external resources. */
7961interface HTMLObjectElement extends HTMLElement {
7962    /** @deprecated */
7963    align: string;
7964    /**
7965     * Sets or retrieves a character string that can be used to implement your own archive functionality for the object.
7966     */
7967    /** @deprecated */
7968    archive: string;
7969    /** @deprecated */
7970    border: string;
7971    /**
7972     * Sets or retrieves the URL of the file containing the compiled Java class.
7973     */
7974    /** @deprecated */
7975    code: string;
7976    /**
7977     * Sets or retrieves the URL of the component.
7978     */
7979    /** @deprecated */
7980    codeBase: string;
7981    /**
7982     * Sets or retrieves the Internet media type for the code associated with the object.
7983     */
7984    /** @deprecated */
7985    codeType: string;
7986    /**
7987     * Retrieves the document object of the page or frame.
7988     */
7989    readonly contentDocument: Document | null;
7990    readonly contentWindow: WindowProxy | null;
7991    /**
7992     * Sets or retrieves the URL that references the data of the object.
7993     */
7994    data: string;
7995    /** @deprecated */
7996    declare: boolean;
7997    /**
7998     * Retrieves a reference to the form that the object is embedded in.
7999     */
8000    readonly form: HTMLFormElement | null;
8001    /**
8002     * Sets or retrieves the height of the object.
8003     */
8004    height: string;
8005    /** @deprecated */
8006    hspace: number;
8007    /**
8008     * Sets or retrieves the name of the object.
8009     */
8010    name: string;
8011    /**
8012     * Sets or retrieves a message to be displayed while an object is loading.
8013     */
8014    /** @deprecated */
8015    standby: string;
8016    /**
8017     * Sets or retrieves the MIME type of the object.
8018     */
8019    type: string;
8020    /**
8021     * Sets or retrieves the URL, often with a bookmark extension (#name), to use as a client-side image map.
8022     */
8023    useMap: string;
8024    /**
8025     * Returns the error message that would be displayed if the user submits the form, or an empty string if no error message. It also triggers the standard error message, such as "this is a required field". The result is that the user sees validation messages without actually submitting.
8026     */
8027    readonly validationMessage: string;
8028    /**
8029     * Returns a  ValidityState object that represents the validity states of an element.
8030     */
8031    readonly validity: ValidityState;
8032    /** @deprecated */
8033    vspace: number;
8034    /**
8035     * Sets or retrieves the width of the object.
8036     */
8037    width: string;
8038    /**
8039     * Returns whether an element will successfully validate based on forms validation rules and constraints.
8040     */
8041    readonly willValidate: boolean;
8042    /**
8043     * Returns whether a form will validate when it is submitted, without having to submit it.
8044     */
8045    checkValidity(): boolean;
8046    getSVGDocument(): Document | null;
8047    reportValidity(): boolean;
8048    /**
8049     * Sets a custom error message that is displayed when a form is submitted.
8050     * @param error Sets a custom error message that is displayed when a form is submitted.
8051     */
8052    setCustomValidity(error: string): void;
8053    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLObjectElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8054    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8055    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLObjectElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8056    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8057}
8058
8059declare var HTMLObjectElement: {
8060    prototype: HTMLObjectElement;
8061    new(): HTMLObjectElement;
8062};
8063
8064/** Provides special properties and methods (beyond the regular HTMLElement object interface they also have available to them by inheritance) for manipulating the layout and presentation of <optgroup> elements. */
8065interface HTMLOptGroupElement extends HTMLElement {
8066    disabled: boolean;
8067    /**
8068     * Retrieves a reference to the form that the object is embedded in.
8069     */
8070    readonly form: HTMLFormElement | null;
8071    /**
8072     * Sets or retrieves a value that you can use to implement your own label functionality for the object.
8073     */
8074    label: string;
8075    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLOptGroupElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8076    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8077    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLOptGroupElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8078    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8079}
8080
8081declare var HTMLOptGroupElement: {
8082    prototype: HTMLOptGroupElement;
8083    new(): HTMLOptGroupElement;
8084};
8085
8086/** <option> elements and inherits all classes and methods of the HTMLElement interface. */
8087interface HTMLOptionElement extends HTMLElement {
8088    /**
8089     * Sets or retrieves the status of an option.
8090     */
8091    defaultSelected: boolean;
8092    disabled: boolean;
8093    /**
8094     * Retrieves a reference to the form that the object is embedded in.
8095     */
8096    readonly form: HTMLFormElement | null;
8097    /**
8098     * Sets or retrieves the ordinal position of an option in a list box.
8099     */
8100    readonly index: number;
8101    /**
8102     * Sets or retrieves a value that you can use to implement your own label functionality for the object.
8103     */
8104    label: string;
8105    /**
8106     * Sets or retrieves whether the option in the list box is the default item.
8107     */
8108    selected: boolean;
8109    /**
8110     * Sets or retrieves the text string specified by the option tag.
8111     */
8112    text: string;
8113    /**
8114     * Sets or retrieves the value which is returned to the server when the form control is submitted.
8115     */
8116    value: string;
8117    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLOptionElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8118    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8119    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLOptionElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8120    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8121}
8122
8123declare var HTMLOptionElement: {
8124    prototype: HTMLOptionElement;
8125    new(): HTMLOptionElement;
8126};
8127
8128/** HTMLOptionsCollection is an interface representing a collection of HTML option elements (in document order) and offers methods and properties for traversing the list as well as optionally altering its items. This type is returned solely by the "options" property of select. */
8129interface HTMLOptionsCollection extends HTMLCollectionOf<HTMLOptionElement> {
8130    /**
8131     * Returns the number of elements in the collection.
8132     * 
8133     * When set to a smaller number, truncates the number of option elements in the corresponding container.
8134     * 
8135     * When set to a greater number, adds new blank option elements to that container.
8136     */
8137    length: number;
8138    /**
8139     * Returns the index of the first selected item, if any, or −1 if there is no selected item.
8140     * 
8141     * Can be set, to change the selection.
8142     */
8143    selectedIndex: number;
8144    /**
8145     * Inserts element before the node given by before.
8146     * 
8147     * The before argument can be a number, in which case element is inserted before the item with that number, or an element from the collection, in which case element is inserted before that element.
8148     * 
8149     * If before is omitted, null, or a number out of range, then element will be added at the end of the list.
8150     * 
8151     * This method will throw a "HierarchyRequestError" DOMException if element is an ancestor of the element into which it is to be inserted.
8152     */
8153    add(element: HTMLOptionElement | HTMLOptGroupElement, before?: HTMLElement | number | null): void;
8154    /**
8155     * Removes the item with index index from the collection.
8156     */
8157    remove(index: number): void;
8158}
8159
8160declare var HTMLOptionsCollection: {
8161    prototype: HTMLOptionsCollection;
8162    new(): HTMLOptionsCollection;
8163};
8164
8165interface HTMLOrSVGElement {
8166    readonly dataset: DOMStringMap;
8167    nonce?: string;
8168    tabIndex: number;
8169    blur(): void;
8170    focus(options?: FocusOptions): void;
8171}
8172
8173/** Provides properties and methods (beyond those inherited from HTMLElement) for manipulating the layout and presentation of <output> elements. */
8174interface HTMLOutputElement extends HTMLElement {
8175    defaultValue: string;
8176    readonly form: HTMLFormElement | null;
8177    readonly htmlFor: DOMTokenList;
8178    readonly labels: NodeListOf<HTMLLabelElement>;
8179    name: string;
8180    readonly type: string;
8181    readonly validationMessage: string;
8182    readonly validity: ValidityState;
8183    value: string;
8184    readonly willValidate: boolean;
8185    checkValidity(): boolean;
8186    reportValidity(): boolean;
8187    setCustomValidity(error: string): void;
8188    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLOutputElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8189    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8190    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLOutputElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8191    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8192}
8193
8194declare var HTMLOutputElement: {
8195    prototype: HTMLOutputElement;
8196    new(): HTMLOutputElement;
8197};
8198
8199/** Provides special properties (beyond those of the regular HTMLElement object interface it inherits) for manipulating <p> elements. */
8200interface HTMLParagraphElement extends HTMLElement {
8201    /**
8202     * Sets or retrieves how the object is aligned with adjacent text.
8203     */
8204    /** @deprecated */
8205    align: string;
8206    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLParagraphElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8207    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8208    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLParagraphElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8209    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8210}
8211
8212declare var HTMLParagraphElement: {
8213    prototype: HTMLParagraphElement;
8214    new(): HTMLParagraphElement;
8215};
8216
8217/** Provides special properties (beyond those of the regular HTMLElement object interface it inherits) for manipulating <param> elements, representing a pair of a key and a value that acts as a parameter for an <object> element. */
8218interface HTMLParamElement extends HTMLElement {
8219    /**
8220     * Sets or retrieves the name of an input parameter for an element.
8221     */
8222    name: string;
8223    /**
8224     * Sets or retrieves the content type of the resource designated by the value attribute.
8225     */
8226    /** @deprecated */
8227    type: string;
8228    /**
8229     * Sets or retrieves the value of an input parameter for an element.
8230     */
8231    value: string;
8232    /**
8233     * Sets or retrieves the data type of the value attribute.
8234     */
8235    /** @deprecated */
8236    valueType: string;
8237    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLParamElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8238    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8239    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLParamElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8240    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8241}
8242
8243declare var HTMLParamElement: {
8244    prototype: HTMLParamElement;
8245    new(): HTMLParamElement;
8246};
8247
8248/** A <picture> HTML element. It doesn't implement specific properties or methods. */
8249interface HTMLPictureElement extends HTMLElement {
8250    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLPictureElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8251    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8252    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLPictureElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8253    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8254}
8255
8256declare var HTMLPictureElement: {
8257    prototype: HTMLPictureElement;
8258    new(): HTMLPictureElement;
8259};
8260
8261/** Exposes specific properties and methods (beyond those of the HTMLElement interface it also has available to it by inheritance) for manipulating a block of preformatted text (<pre>). */
8262interface HTMLPreElement extends HTMLElement {
8263    /**
8264     * Sets or gets a value that you can use to implement your own width functionality for the object.
8265     */
8266    /** @deprecated */
8267    width: number;
8268    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLPreElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8269    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8270    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLPreElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8271    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8272}
8273
8274declare var HTMLPreElement: {
8275    prototype: HTMLPreElement;
8276    new(): HTMLPreElement;
8277};
8278
8279/** Provides special properties and methods (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating the layout and presentation of <progress> elements. */
8280interface HTMLProgressElement extends HTMLElement {
8281    readonly labels: NodeListOf<HTMLLabelElement>;
8282    /**
8283     * Defines the maximum, or "done" value for a progress element.
8284     */
8285    max: number;
8286    /**
8287     * Returns the quotient of value/max when the value attribute is set (determinate progress bar), or -1 when the value attribute is missing (indeterminate progress bar).
8288     */
8289    readonly position: number;
8290    /**
8291     * Sets or gets the current value of a progress element. The value must be a non-negative number between 0 and the max value.
8292     */
8293    value: number;
8294    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLProgressElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8295    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8296    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLProgressElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8297    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8298}
8299
8300declare var HTMLProgressElement: {
8301    prototype: HTMLProgressElement;
8302    new(): HTMLProgressElement;
8303};
8304
8305/** Provides special properties and methods (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating quoting elements, like <blockquote> and <q>, but not the <cite> element. */
8306interface HTMLQuoteElement extends HTMLElement {
8307    /**
8308     * Sets or retrieves reference information about the object.
8309     */
8310    cite: string;
8311    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLQuoteElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8312    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8313    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLQuoteElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8314    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8315}
8316
8317declare var HTMLQuoteElement: {
8318    prototype: HTMLQuoteElement;
8319    new(): HTMLQuoteElement;
8320};
8321
8322/** HTML <script> elements expose the HTMLScriptElement interface, which provides special properties and methods for manipulating the behavior and execution of <script> elements (beyond the inherited HTMLElement interface). */
8323interface HTMLScriptElement extends HTMLElement {
8324    async: boolean;
8325    /**
8326     * Sets or retrieves the character set used to encode the object.
8327     */
8328    /** @deprecated */
8329    charset: string;
8330    crossOrigin: string | null;
8331    /**
8332     * Sets or retrieves the status of the script.
8333     */
8334    defer: boolean;
8335    /**
8336     * Sets or retrieves the event for which the script is written.
8337     */
8338    /** @deprecated */
8339    event: string;
8340    /**
8341     * Sets or retrieves the object that is bound to the event script.
8342     */
8343    /** @deprecated */
8344    htmlFor: string;
8345    integrity: string;
8346    noModule: boolean;
8347    referrerPolicy: string;
8348    /**
8349     * Retrieves the URL to an external file that contains the source code or data.
8350     */
8351    src: string;
8352    /**
8353     * Retrieves or sets the text of the object as a string.
8354     */
8355    text: string;
8356    /**
8357     * Sets or retrieves the MIME type for the associated scripting engine.
8358     */
8359    type: string;
8360    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLScriptElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8361    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8362    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLScriptElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8363    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8364}
8365
8366declare var HTMLScriptElement: {
8367    prototype: HTMLScriptElement;
8368    new(): HTMLScriptElement;
8369};
8370
8371/** A <select> HTML Element. These elements also share all of the properties and methods of other HTML elements via the HTMLElement interface. */
8372interface HTMLSelectElement extends HTMLElement {
8373    autocomplete: string;
8374    /**
8375     * Provides a way to direct a user to a specific field when a document loads. This can provide both direction and convenience for a user, reducing the need to click or tab to a field when a page opens. This attribute is true when present on an element, and false when missing.
8376     */
8377    autofocus: boolean;
8378    disabled: boolean;
8379    /**
8380     * Retrieves a reference to the form that the object is embedded in.
8381     */
8382    readonly form: HTMLFormElement | null;
8383    readonly labels: NodeListOf<HTMLLabelElement>;
8384    /**
8385     * Sets or retrieves the number of objects in a collection.
8386     */
8387    length: number;
8388    /**
8389     * Sets or retrieves the Boolean value indicating whether multiple items can be selected from a list.
8390     */
8391    multiple: boolean;
8392    /**
8393     * Sets or retrieves the name of the object.
8394     */
8395    name: string;
8396    readonly options: HTMLOptionsCollection;
8397    /**
8398     * When present, marks an element that can't be submitted without a value.
8399     */
8400    required: boolean;
8401    /**
8402     * Sets or retrieves the index of the selected option in a select object.
8403     */
8404    selectedIndex: number;
8405    readonly selectedOptions: HTMLCollectionOf<HTMLOptionElement>;
8406    /**
8407     * Sets or retrieves the number of rows in the list box.
8408     */
8409    size: number;
8410    /**
8411     * Retrieves the type of select control based on the value of the MULTIPLE attribute.
8412     */
8413    readonly type: string;
8414    /**
8415     * Returns the error message that would be displayed if the user submits the form, or an empty string if no error message. It also triggers the standard error message, such as "this is a required field". The result is that the user sees validation messages without actually submitting.
8416     */
8417    readonly validationMessage: string;
8418    /**
8419     * Returns a  ValidityState object that represents the validity states of an element.
8420     */
8421    readonly validity: ValidityState;
8422    /**
8423     * Sets or retrieves the value which is returned to the server when the form control is submitted.
8424     */
8425    value: string;
8426    /**
8427     * Returns whether an element will successfully validate based on forms validation rules and constraints.
8428     */
8429    readonly willValidate: boolean;
8430    /**
8431     * Adds an element to the areas, controlRange, or options collection.
8432     * @param element Variant of type Number that specifies the index position in the collection where the element is placed. If no value is given, the method places the element at the end of the collection.
8433     * @param before Variant of type Object that specifies an element to insert before, or null to append the object to the collection.
8434     */
8435    add(element: HTMLOptionElement | HTMLOptGroupElement, before?: HTMLElement | number | null): void;
8436    /**
8437     * Returns whether a form will validate when it is submitted, without having to submit it.
8438     */
8439    checkValidity(): boolean;
8440    /**
8441     * Retrieves a select object or an object from an options collection.
8442     * @param name Variant of type Number or String that specifies the object or collection to retrieve. If this parameter is an integer, it is the zero-based index of the object. If this parameter is a string, all objects with matching name or id properties are retrieved, and a collection is returned if more than one match is made.
8443     * @param index Variant of type Number that specifies the zero-based index of the object to retrieve when a collection is returned.
8444     */
8445    item(index: number): Element | null;
8446    /**
8447     * Retrieves a select object or an object from an options collection.
8448     * @param namedItem A String that specifies the name or id property of the object to retrieve. A collection is returned if more than one match is made.
8449     */
8450    namedItem(name: string): HTMLOptionElement | null;
8451    /**
8452     * Removes an element from the collection.
8453     * @param index Number that specifies the zero-based index of the element to remove from the collection.
8454     */
8455    remove(): void;
8456    remove(index: number): void;
8457    reportValidity(): boolean;
8458    /**
8459     * Sets a custom error message that is displayed when a form is submitted.
8460     * @param error Sets a custom error message that is displayed when a form is submitted.
8461     */
8462    setCustomValidity(error: string): void;
8463    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLSelectElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8464    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8465    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLSelectElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8466    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8467    [name: number]: HTMLOptionElement | HTMLOptGroupElement;
8468}
8469
8470declare var HTMLSelectElement: {
8471    prototype: HTMLSelectElement;
8472    new(): HTMLSelectElement;
8473};
8474
8475interface HTMLSlotElement extends HTMLElement {
8476    name: string;
8477    assignedElements(options?: AssignedNodesOptions): Element[];
8478    assignedNodes(options?: AssignedNodesOptions): Node[];
8479    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLSlotElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8480    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8481    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLSlotElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8482    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8483}
8484
8485declare var HTMLSlotElement: {
8486    prototype: HTMLSlotElement;
8487    new(): HTMLSlotElement;
8488};
8489
8490/** Provides special properties (beyond the regular HTMLElement object interface it also has available to it by inheritance) for manipulating <source> elements. */
8491interface HTMLSourceElement extends HTMLElement {
8492    /**
8493     * Gets or sets the intended media type of the media source.
8494     */
8495    media: string;
8496    sizes: string;
8497    /**
8498     * The address or URL of the a media resource that is to be considered.
8499     */
8500    src: string;
8501    srcset: string;
8502    /**
8503     * Gets or sets the MIME type of a media resource.
8504     */
8505    type: string;
8506    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLSourceElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8507    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8508    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLSourceElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8509    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8510}
8511
8512declare var HTMLSourceElement: {
8513    prototype: HTMLSourceElement;
8514    new(): HTMLSourceElement;
8515};
8516
8517/** A <span> element and derives from the HTMLElement interface, but without implementing any additional properties or methods. */
8518interface HTMLSpanElement extends HTMLElement {
8519    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLSpanElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8520    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8521    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLSpanElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8522    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8523}
8524
8525declare var HTMLSpanElement: {
8526    prototype: HTMLSpanElement;
8527    new(): HTMLSpanElement;
8528};
8529
8530/** A <style> element. It inherits properties and methods from its parent, HTMLElement, and from LinkStyle. */
8531interface HTMLStyleElement extends HTMLElement, LinkStyle {
8532    /**
8533     * Sets or retrieves the media type.
8534     */
8535    media: string;
8536    /**
8537     * Retrieves the CSS language in which the style sheet is written.
8538     */
8539    /** @deprecated */
8540    type: string;
8541    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLStyleElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8542    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8543    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLStyleElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8544    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8545}
8546
8547declare var HTMLStyleElement: {
8548    prototype: HTMLStyleElement;
8549    new(): HTMLStyleElement;
8550};
8551
8552/** Special properties (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating table caption elements. */
8553interface HTMLTableCaptionElement extends HTMLElement {
8554    /**
8555     * Sets or retrieves the alignment of the caption or legend.
8556     */
8557    /** @deprecated */
8558    align: string;
8559    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableCaptionElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8560    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8561    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableCaptionElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8562    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8563}
8564
8565declare var HTMLTableCaptionElement: {
8566    prototype: HTMLTableCaptionElement;
8567    new(): HTMLTableCaptionElement;
8568};
8569
8570/** Provides special properties and methods (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating the layout and presentation of table cells, either header or data cells, in an HTML document. */
8571interface HTMLTableCellElement extends HTMLElement {
8572    /**
8573     * Sets or retrieves abbreviated text for the object.
8574     */
8575    abbr: string;
8576    /**
8577     * Sets or retrieves how the object is aligned with adjacent text.
8578     */
8579    /** @deprecated */
8580    align: string;
8581    /**
8582     * Sets or retrieves a comma-delimited list of conceptual categories associated with the object.
8583     */
8584    /** @deprecated */
8585    axis: string;
8586    /** @deprecated */
8587    bgColor: string;
8588    /**
8589     * Retrieves the position of the object in the cells collection of a row.
8590     */
8591    readonly cellIndex: number;
8592    /** @deprecated */
8593    ch: string;
8594    /** @deprecated */
8595    chOff: string;
8596    /**
8597     * Sets or retrieves the number columns in the table that the object should span.
8598     */
8599    colSpan: number;
8600    /**
8601     * Sets or retrieves a list of header cells that provide information for the object.
8602     */
8603    headers: string;
8604    /**
8605     * Sets or retrieves the height of the object.
8606     */
8607    /** @deprecated */
8608    height: string;
8609    /**
8610     * Sets or retrieves whether the browser automatically performs wordwrap.
8611     */
8612    /** @deprecated */
8613    noWrap: boolean;
8614    /**
8615     * Sets or retrieves how many rows in a table the cell should span.
8616     */
8617    rowSpan: number;
8618    /**
8619     * Sets or retrieves the group of cells in a table to which the object's information applies.
8620     */
8621    scope: string;
8622    /** @deprecated */
8623    vAlign: string;
8624    /**
8625     * Sets or retrieves the width of the object.
8626     */
8627    /** @deprecated */
8628    width: string;
8629    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableCellElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8630    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8631    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableCellElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8632    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8633}
8634
8635declare var HTMLTableCellElement: {
8636    prototype: HTMLTableCellElement;
8637    new(): HTMLTableCellElement;
8638};
8639
8640/** Provides special properties (beyond the HTMLElement interface it also has available to it inheritance) for manipulating single or grouped table column elements. */
8641interface HTMLTableColElement extends HTMLElement {
8642    /**
8643     * Sets or retrieves the alignment of the object relative to the display or table.
8644     */
8645    /** @deprecated */
8646    align: string;
8647    /** @deprecated */
8648    ch: string;
8649    /** @deprecated */
8650    chOff: string;
8651    /**
8652     * Sets or retrieves the number of columns in the group.
8653     */
8654    span: number;
8655    /** @deprecated */
8656    vAlign: string;
8657    /**
8658     * Sets or retrieves the width of the object.
8659     */
8660    /** @deprecated */
8661    width: string;
8662    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableColElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8663    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8664    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableColElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8665    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8666}
8667
8668declare var HTMLTableColElement: {
8669    prototype: HTMLTableColElement;
8670    new(): HTMLTableColElement;
8671};
8672
8673interface HTMLTableDataCellElement extends HTMLTableCellElement {
8674    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableDataCellElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8675    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8676    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableDataCellElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8677    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8678}
8679
8680declare var HTMLTableDataCellElement: {
8681    prototype: HTMLTableDataCellElement;
8682    new(): HTMLTableDataCellElement;
8683};
8684
8685/** Provides special properties and methods (beyond the regular HTMLElement object interface it also has available to it by inheritance) for manipulating the layout and presentation of tables in an HTML document. */
8686interface HTMLTableElement extends HTMLElement {
8687    /**
8688     * Sets or retrieves a value that indicates the table alignment.
8689     */
8690    /** @deprecated */
8691    align: string;
8692    /** @deprecated */
8693    bgColor: string;
8694    /**
8695     * Sets or retrieves the width of the border to draw around the object.
8696     */
8697    /** @deprecated */
8698    border: string;
8699    /**
8700     * Retrieves the caption object of a table.
8701     */
8702    caption: HTMLTableCaptionElement | null;
8703    /**
8704     * Sets or retrieves the amount of space between the border of the cell and the content of the cell.
8705     */
8706    /** @deprecated */
8707    cellPadding: string;
8708    /**
8709     * Sets or retrieves the amount of space between cells in a table.
8710     */
8711    /** @deprecated */
8712    cellSpacing: string;
8713    /**
8714     * Sets or retrieves the way the border frame around the table is displayed.
8715     */
8716    /** @deprecated */
8717    frame: string;
8718    /**
8719     * Sets or retrieves the number of horizontal rows contained in the object.
8720     */
8721    readonly rows: HTMLCollectionOf<HTMLTableRowElement>;
8722    /**
8723     * Sets or retrieves which dividing lines (inner borders) are displayed.
8724     */
8725    /** @deprecated */
8726    rules: string;
8727    /**
8728     * Sets or retrieves a description and/or structure of the object.
8729     */
8730    /** @deprecated */
8731    summary: string;
8732    /**
8733     * Retrieves a collection of all tBody objects in the table. Objects in this collection are in source order.
8734     */
8735    readonly tBodies: HTMLCollectionOf<HTMLTableSectionElement>;
8736    /**
8737     * Retrieves the tFoot object of the table.
8738     */
8739    tFoot: HTMLTableSectionElement | null;
8740    /**
8741     * Retrieves the tHead object of the table.
8742     */
8743    tHead: HTMLTableSectionElement | null;
8744    /**
8745     * Sets or retrieves the width of the object.
8746     */
8747    /** @deprecated */
8748    width: string;
8749    /**
8750     * Creates an empty caption element in the table.
8751     */
8752    createCaption(): HTMLTableCaptionElement;
8753    /**
8754     * Creates an empty tBody element in the table.
8755     */
8756    createTBody(): HTMLTableSectionElement;
8757    /**
8758     * Creates an empty tFoot element in the table.
8759     */
8760    createTFoot(): HTMLTableSectionElement;
8761    /**
8762     * Returns the tHead element object if successful, or null otherwise.
8763     */
8764    createTHead(): HTMLTableSectionElement;
8765    /**
8766     * Deletes the caption element and its contents from the table.
8767     */
8768    deleteCaption(): void;
8769    /**
8770     * Removes the specified row (tr) from the element and from the rows collection.
8771     * @param index Number that specifies the zero-based position in the rows collection of the row to remove.
8772     */
8773    deleteRow(index: number): void;
8774    /**
8775     * Deletes the tFoot element and its contents from the table.
8776     */
8777    deleteTFoot(): void;
8778    /**
8779     * Deletes the tHead element and its contents from the table.
8780     */
8781    deleteTHead(): void;
8782    /**
8783     * Creates a new row (tr) in the table, and adds the row to the rows collection.
8784     * @param index Number that specifies where to insert the row in the rows collection. The default value is -1, which appends the new row to the end of the rows collection.
8785     */
8786    insertRow(index?: number): HTMLTableRowElement;
8787    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8788    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8789    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8790    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8791}
8792
8793declare var HTMLTableElement: {
8794    prototype: HTMLTableElement;
8795    new(): HTMLTableElement;
8796};
8797
8798interface HTMLTableHeaderCellElement extends HTMLTableCellElement {
8799    scope: string;
8800    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableHeaderCellElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8801    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8802    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableHeaderCellElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8803    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8804}
8805
8806declare var HTMLTableHeaderCellElement: {
8807    prototype: HTMLTableHeaderCellElement;
8808    new(): HTMLTableHeaderCellElement;
8809};
8810
8811/** Provides special properties and methods (beyond the HTMLElement interface it also has available to it by inheritance) for manipulating the layout and presentation of rows in an HTML table. */
8812interface HTMLTableRowElement extends HTMLElement {
8813    /**
8814     * Sets or retrieves how the object is aligned with adjacent text.
8815     */
8816    /** @deprecated */
8817    align: string;
8818    /** @deprecated */
8819    bgColor: string;
8820    /**
8821     * Retrieves a collection of all cells in the table row.
8822     */
8823    readonly cells: HTMLCollectionOf<HTMLTableDataCellElement | HTMLTableHeaderCellElement>;
8824    /** @deprecated */
8825    ch: string;
8826    /** @deprecated */
8827    chOff: string;
8828    /**
8829     * Retrieves the position of the object in the rows collection for the table.
8830     */
8831    readonly rowIndex: number;
8832    /**
8833     * Retrieves the position of the object in the collection.
8834     */
8835    readonly sectionRowIndex: number;
8836    /** @deprecated */
8837    vAlign: string;
8838    /**
8839     * Removes the specified cell from the table row, as well as from the cells collection.
8840     * @param index Number that specifies the zero-based position of the cell to remove from the table row. If no value is provided, the last cell in the cells collection is deleted.
8841     */
8842    deleteCell(index: number): void;
8843    /**
8844     * Creates a new cell in the table row, and adds the cell to the cells collection.
8845     * @param index Number that specifies where to insert the cell in the tr. The default value is -1, which appends the new cell to the end of the cells collection.
8846     */
8847    insertCell(index?: number): HTMLTableDataCellElement;
8848    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableRowElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8849    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8850    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableRowElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8851    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8852}
8853
8854declare var HTMLTableRowElement: {
8855    prototype: HTMLTableRowElement;
8856    new(): HTMLTableRowElement;
8857};
8858
8859/** Provides special properties and methods (beyond the HTMLElement interface it also has available to it by inheritance) for manipulating the layout and presentation of sections, that is headers, footers and bodies, in an HTML table. */
8860interface HTMLTableSectionElement extends HTMLElement {
8861    /**
8862     * Sets or retrieves a value that indicates the table alignment.
8863     */
8864    /** @deprecated */
8865    align: string;
8866    /** @deprecated */
8867    ch: string;
8868    /** @deprecated */
8869    chOff: string;
8870    /**
8871     * Sets or retrieves the number of horizontal rows contained in the object.
8872     */
8873    readonly rows: HTMLCollectionOf<HTMLTableRowElement>;
8874    /** @deprecated */
8875    vAlign: string;
8876    /**
8877     * Removes the specified row (tr) from the element and from the rows collection.
8878     * @param index Number that specifies the zero-based position in the rows collection of the row to remove.
8879     */
8880    deleteRow(index: number): void;
8881    /**
8882     * Creates a new row (tr) in the table, and adds the row to the rows collection.
8883     * @param index Number that specifies where to insert the row in the rows collection. The default value is -1, which appends the new row to the end of the rows collection.
8884     */
8885    insertRow(index?: number): HTMLTableRowElement;
8886    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableSectionElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8887    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8888    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableSectionElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8889    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8890}
8891
8892declare var HTMLTableSectionElement: {
8893    prototype: HTMLTableSectionElement;
8894    new(): HTMLTableSectionElement;
8895};
8896
8897/** Enables access to the contents of an HTML <template> element. */
8898interface HTMLTemplateElement extends HTMLElement {
8899    readonly content: DocumentFragment;
8900    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTemplateElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8901    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8902    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTemplateElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8903    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8904}
8905
8906declare var HTMLTemplateElement: {
8907    prototype: HTMLTemplateElement;
8908    new(): HTMLTemplateElement;
8909};
8910
8911/** Provides special properties and methods for manipulating the layout and presentation of <textarea> elements. */
8912interface HTMLTextAreaElement extends HTMLElement {
8913    autocomplete: string;
8914    /**
8915     * Provides a way to direct a user to a specific field when a document loads. This can provide both direction and convenience for a user, reducing the need to click or tab to a field when a page opens. This attribute is true when present on an element, and false when missing.
8916     */
8917    autofocus: boolean;
8918    /**
8919     * Sets or retrieves the width of the object.
8920     */
8921    cols: number;
8922    /**
8923     * Sets or retrieves the initial contents of the object.
8924     */
8925    defaultValue: string;
8926    dirName: string;
8927    disabled: boolean;
8928    /**
8929     * Retrieves a reference to the form that the object is embedded in.
8930     */
8931    readonly form: HTMLFormElement | null;
8932    readonly labels: NodeListOf<HTMLLabelElement>;
8933    /**
8934     * Sets or retrieves the maximum number of characters that the user can enter in a text control.
8935     */
8936    maxLength: number;
8937    minLength: number;
8938    /**
8939     * Sets or retrieves the name of the object.
8940     */
8941    name: string;
8942    /**
8943     * Gets or sets a text string that is displayed in an input field as a hint or prompt to users as the format or type of information they need to enter.The text appears in an input field until the user puts focus on the field.
8944     */
8945    placeholder: string;
8946    /**
8947     * Sets or retrieves the value indicated whether the content of the object is read-only.
8948     */
8949    readOnly: boolean;
8950    /**
8951     * When present, marks an element that can't be submitted without a value.
8952     */
8953    required: boolean;
8954    /**
8955     * Sets or retrieves the number of horizontal rows contained in the object.
8956     */
8957    rows: number;
8958    selectionDirection: string;
8959    /**
8960     * Gets or sets the end position or offset of a text selection.
8961     */
8962    selectionEnd: number;
8963    /**
8964     * Gets or sets the starting position or offset of a text selection.
8965     */
8966    selectionStart: number;
8967    readonly textLength: number;
8968    /**
8969     * Retrieves the type of control.
8970     */
8971    readonly type: string;
8972    /**
8973     * Returns the error message that would be displayed if the user submits the form, or an empty string if no error message. It also triggers the standard error message, such as "this is a required field". The result is that the user sees validation messages without actually submitting.
8974     */
8975    readonly validationMessage: string;
8976    /**
8977     * Returns a  ValidityState object that represents the validity states of an element.
8978     */
8979    readonly validity: ValidityState;
8980    /**
8981     * Retrieves or sets the text in the entry field of the textArea element.
8982     */
8983    value: string;
8984    /**
8985     * Returns whether an element will successfully validate based on forms validation rules and constraints.
8986     */
8987    readonly willValidate: boolean;
8988    /**
8989     * Sets or retrieves how to handle wordwrapping in the object.
8990     */
8991    wrap: string;
8992    /**
8993     * Returns whether a form will validate when it is submitted, without having to submit it.
8994     */
8995    checkValidity(): boolean;
8996    reportValidity(): boolean;
8997    /**
8998     * Highlights the input area of a form element.
8999     */
9000    select(): void;
9001    /**
9002     * Sets a custom error message that is displayed when a form is submitted.
9003     * @param error Sets a custom error message that is displayed when a form is submitted.
9004     */
9005    setCustomValidity(error: string): void;
9006    setRangeText(replacement: string): void;
9007    setRangeText(replacement: string, start: number, end: number, selectionMode?: SelectionMode): void;
9008    /**
9009     * Sets the start and end positions of a selection in a text field.
9010     * @param start The offset into the text field for the start of the selection.
9011     * @param end The offset into the text field for the end of the selection.
9012     * @param direction The direction in which the selection is performed.
9013     */
9014    setSelectionRange(start: number, end: number, direction?: "forward" | "backward" | "none"): void;
9015    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTextAreaElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9016    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9017    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTextAreaElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9018    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9019}
9020
9021declare var HTMLTextAreaElement: {
9022    prototype: HTMLTextAreaElement;
9023    new(): HTMLTextAreaElement;
9024};
9025
9026/** Provides special properties (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating <time> elements. */
9027interface HTMLTimeElement extends HTMLElement {
9028    dateTime: string;
9029    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTimeElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9030    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9031    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTimeElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9032    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9033}
9034
9035declare var HTMLTimeElement: {
9036    prototype: HTMLTimeElement;
9037    new(): HTMLTimeElement;
9038};
9039
9040/** Contains the title for a document. This element inherits all of the properties and methods of the HTMLElement interface. */
9041interface HTMLTitleElement extends HTMLElement {
9042    /**
9043     * Retrieves or sets the text of the object as a string.
9044     */
9045    text: string;
9046    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTitleElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9047    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9048    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTitleElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9049    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9050}
9051
9052declare var HTMLTitleElement: {
9053    prototype: HTMLTitleElement;
9054    new(): HTMLTitleElement;
9055};
9056
9057/** The HTMLTrackElement */
9058interface HTMLTrackElement extends HTMLElement {
9059    default: boolean;
9060    kind: string;
9061    label: string;
9062    readonly readyState: number;
9063    src: string;
9064    srclang: string;
9065    readonly track: TextTrack;
9066    readonly ERROR: number;
9067    readonly LOADED: number;
9068    readonly LOADING: number;
9069    readonly NONE: number;
9070    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTrackElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9071    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9072    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTrackElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9073    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9074}
9075
9076declare var HTMLTrackElement: {
9077    prototype: HTMLTrackElement;
9078    new(): HTMLTrackElement;
9079    readonly ERROR: number;
9080    readonly LOADED: number;
9081    readonly LOADING: number;
9082    readonly NONE: number;
9083};
9084
9085/** Provides special properties (beyond those defined on the regular HTMLElement interface it also has available to it by inheritance) for manipulating unordered list elements. */
9086interface HTMLUListElement extends HTMLElement {
9087    /** @deprecated */
9088    compact: boolean;
9089    /** @deprecated */
9090    type: string;
9091    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLUListElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9092    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9093    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLUListElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9094    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9095}
9096
9097declare var HTMLUListElement: {
9098    prototype: HTMLUListElement;
9099    new(): HTMLUListElement;
9100};
9101
9102/** An invalid HTML element and derives from the HTMLElement interface, but without implementing any additional properties or methods. */
9103interface HTMLUnknownElement extends HTMLElement {
9104    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLUnknownElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9105    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9106    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLUnknownElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9107    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9108}
9109
9110declare var HTMLUnknownElement: {
9111    prototype: HTMLUnknownElement;
9112    new(): HTMLUnknownElement;
9113};
9114
9115interface HTMLVideoElementEventMap extends HTMLMediaElementEventMap {
9116    "MSVideoFormatChanged": Event;
9117    "MSVideoFrameStepCompleted": Event;
9118    "MSVideoOptimalLayoutChanged": Event;
9119}
9120
9121/** Provides special properties and methods for manipulating video objects. It also inherits properties and methods of HTMLMediaElement and HTMLElement. */
9122interface HTMLVideoElement extends HTMLMediaElement {
9123    /**
9124     * Gets or sets the height of the video element.
9125     */
9126    height: number;
9127    msHorizontalMirror: boolean;
9128    readonly msIsLayoutOptimalForPlayback: boolean;
9129    readonly msIsStereo3D: boolean;
9130    msStereo3DPackingMode: string;
9131    msStereo3DRenderMode: string;
9132    msZoom: boolean;
9133    onMSVideoFormatChanged: ((this: HTMLVideoElement, ev: Event) => any) | null;
9134    onMSVideoFrameStepCompleted: ((this: HTMLVideoElement, ev: Event) => any) | null;
9135    onMSVideoOptimalLayoutChanged: ((this: HTMLVideoElement, ev: Event) => any) | null;
9136    /**
9137     * Gets or sets a URL of an image to display, for example, like a movie poster. This can be a still frame from the video, or another image if no video data is available.
9138     */
9139    poster: string;
9140    /**
9141     * Gets the intrinsic height of a video in CSS pixels, or zero if the dimensions are not known.
9142     */
9143    readonly videoHeight: number;
9144    /**
9145     * Gets the intrinsic width of a video in CSS pixels, or zero if the dimensions are not known.
9146     */
9147    readonly videoWidth: number;
9148    readonly webkitDisplayingFullscreen: boolean;
9149    readonly webkitSupportsFullscreen: boolean;
9150    /**
9151     * Gets or sets the width of the video element.
9152     */
9153    width: number;
9154    getVideoPlaybackQuality(): VideoPlaybackQuality;
9155    msFrameStep(forward: boolean): void;
9156    msInsertVideoEffect(activatableClassId: string, effectRequired: boolean, config?: any): void;
9157    msSetVideoRectangle(left: number, top: number, right: number, bottom: number): void;
9158    webkitEnterFullScreen(): void;
9159    webkitEnterFullscreen(): void;
9160    webkitExitFullScreen(): void;
9161    webkitExitFullscreen(): void;
9162    addEventListener<K extends keyof HTMLVideoElementEventMap>(type: K, listener: (this: HTMLVideoElement, ev: HTMLVideoElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9163    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9164    removeEventListener<K extends keyof HTMLVideoElementEventMap>(type: K, listener: (this: HTMLVideoElement, ev: HTMLVideoElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9165    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9166}
9167
9168declare var HTMLVideoElement: {
9169    prototype: HTMLVideoElement;
9170    new(): HTMLVideoElement;
9171};
9172
9173/** Events that fire when the fragment identifier of the URL has changed. */
9174interface HashChangeEvent extends Event {
9175    readonly newURL: string;
9176    readonly oldURL: string;
9177}
9178
9179declare var HashChangeEvent: {
9180    prototype: HashChangeEvent;
9181    new(type: string, eventInitDict?: HashChangeEventInit): HashChangeEvent;
9182};
9183
9184/** This Fetch API interface allows you to perform various actions on HTTP request and response headers. These actions include retrieving, setting, adding to, and removing. A Headers object has an associated header list, which is initially empty and consists of zero or more name and value pairs.  You can add to this using methods like append() (see Examples.) In all methods of this interface, header names are matched by case-insensitive byte sequence. */
9185interface Headers {
9186    append(name: string, value: string): void;
9187    delete(name: string): void;
9188    get(name: string): string | null;
9189    has(name: string): boolean;
9190    set(name: string, value: string): void;
9191    forEach(callbackfn: (value: string, key: string, parent: Headers) => void, thisArg?: any): void;
9192}
9193
9194declare var Headers: {
9195    prototype: Headers;
9196    new(init?: HeadersInit): Headers;
9197};
9198
9199/** Allows manipulation of the browser session history, that is the pages visited in the tab or frame that the current page is loaded in. */
9200interface History {
9201    readonly length: number;
9202    scrollRestoration: ScrollRestoration;
9203    readonly state: any;
9204    back(): void;
9205    forward(): void;
9206    go(delta?: number): void;
9207    pushState(data: any, title: string, url?: string | null): void;
9208    replaceState(data: any, title: string, url?: string | null): void;
9209}
9210
9211declare var History: {
9212    prototype: History;
9213    new(): History;
9214};
9215
9216interface HkdfCtrParams extends Algorithm {
9217    context: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;
9218    hash: string | Algorithm;
9219    label: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;
9220}
9221
9222interface IDBArrayKey extends Array<IDBValidKey> {
9223}
9224
9225/** This IndexedDB API interface represents a cursor for traversing or iterating over multiple records in a database. */
9226interface IDBCursor {
9227    /**
9228     * Returns the direction ("next", "nextunique", "prev" or "prevunique") of the cursor.
9229     */
9230    readonly direction: IDBCursorDirection;
9231    /**
9232     * Returns the key of the cursor. Throws a "InvalidStateError" DOMException if the cursor is advancing or is finished.
9233     */
9234    readonly key: IDBValidKey;
9235    /**
9236     * Returns the effective key of the cursor. Throws a "InvalidStateError" DOMException if the cursor is advancing or is finished.
9237     */
9238    readonly primaryKey: IDBValidKey;
9239    /**
9240     * Returns the IDBObjectStore or IDBIndex the cursor was opened from.
9241     */
9242    readonly source: IDBObjectStore | IDBIndex;
9243    /**
9244     * Advances the cursor through the next count records in range.
9245     */
9246    advance(count: number): void;
9247    /**
9248     * Advances the cursor to the next record in range.
9249     */
9250    continue(key?: IDBValidKey): void;
9251    /**
9252     * Advances the cursor to the next record in range matching or after key and primaryKey. Throws an "InvalidAccessError" DOMException if the source is not an index.
9253     */
9254    continuePrimaryKey(key: IDBValidKey, primaryKey: IDBValidKey): void;
9255    /**
9256     * Delete the record pointed at by the cursor with a new value.
9257     * 
9258     * If successful, request's result will be undefined.
9259     */
9260    delete(): IDBRequest<undefined>;
9261    /**
9262     * Updated the record pointed at by the cursor with a new value.
9263     * 
9264     * Throws a "DataError" DOMException if the effective object store uses in-line keys and the key would have changed.
9265     * 
9266     * If successful, request's result will be the record's key.
9267     */
9268    update(value: any): IDBRequest<IDBValidKey>;
9269}
9270
9271declare var IDBCursor: {
9272    prototype: IDBCursor;
9273    new(): IDBCursor;
9274};
9275
9276/** This IndexedDB API interface represents a cursor for traversing or iterating over multiple records in a database. It is the same as the IDBCursor, except that it includes the value property. */
9277interface IDBCursorWithValue extends IDBCursor {
9278    /**
9279     * Returns the cursor's current value.
9280     */
9281    readonly value: any;
9282}
9283
9284declare var IDBCursorWithValue: {
9285    prototype: IDBCursorWithValue;
9286    new(): IDBCursorWithValue;
9287};
9288
9289interface IDBDatabaseEventMap {
9290    "abort": Event;
9291    "close": Event;
9292    "error": Event;
9293    "versionchange": IDBVersionChangeEvent;
9294}
9295
9296/** This IndexedDB API interface provides a connection to a database; you can use an IDBDatabase object to open a transaction on your database then create, manipulate, and delete objects (data) in that database. The interface provides the only way to get and manage versions of the database. */
9297interface IDBDatabase extends EventTarget {
9298    /**
9299     * Returns the name of the database.
9300     */
9301    readonly name: string;
9302    /**
9303     * Returns a list of the names of object stores in the database.
9304     */
9305    readonly objectStoreNames: DOMStringList;
9306    onabort: ((this: IDBDatabase, ev: Event) => any) | null;
9307    onclose: ((this: IDBDatabase, ev: Event) => any) | null;
9308    onerror: ((this: IDBDatabase, ev: Event) => any) | null;
9309    onversionchange: ((this: IDBDatabase, ev: IDBVersionChangeEvent) => any) | null;
9310    /**
9311     * Returns the version of the database.
9312     */
9313    readonly version: number;
9314    /**
9315     * Closes the connection once all running transactions have finished.
9316     */
9317    close(): void;
9318    /**
9319     * Creates a new object store with the given name and options and returns a new IDBObjectStore.
9320     * 
9321     * Throws a "InvalidStateError" DOMException if not called within an upgrade transaction.
9322     */
9323    createObjectStore(name: string, optionalParameters?: IDBObjectStoreParameters): IDBObjectStore;
9324    /**
9325     * Deletes the object store with the given name.
9326     * 
9327     * Throws a "InvalidStateError" DOMException if not called within an upgrade transaction.
9328     */
9329    deleteObjectStore(name: string): void;
9330    /**
9331     * Returns a new transaction with the given mode ("readonly" or "readwrite") and scope which can be a single object store name or an array of names.
9332     */
9333    transaction(storeNames: string | string[], mode?: IDBTransactionMode): IDBTransaction;
9334    addEventListener<K extends keyof IDBDatabaseEventMap>(type: K, listener: (this: IDBDatabase, ev: IDBDatabaseEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9335    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9336    removeEventListener<K extends keyof IDBDatabaseEventMap>(type: K, listener: (this: IDBDatabase, ev: IDBDatabaseEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9337    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9338}
9339
9340declare var IDBDatabase: {
9341    prototype: IDBDatabase;
9342    new(): IDBDatabase;
9343};
9344
9345interface IDBEnvironment {
9346    readonly indexedDB: IDBFactory;
9347}
9348
9349/** In the following code snippet, we make a request to open a database, and include handlers for the success and error cases. For a full working example, see our To-do Notifications app (view example live.) */
9350interface IDBFactory {
9351    /**
9352     * Compares two values as keys. Returns -1 if key1 precedes key2, 1 if key2 precedes key1, and 0 if the keys are equal.
9353     * 
9354     * Throws a "DataError" DOMException if either input is not a valid key.
9355     */
9356    cmp(first: any, second: any): number;
9357    /**
9358     * Attempts to delete the named database. If the database already exists and there are open connections that don't close in response to a versionchange event, the request will be blocked until all they close. If the request is successful request's result will be null.
9359     */
9360    deleteDatabase(name: string): IDBOpenDBRequest;
9361    /**
9362     * Attempts to open a connection to the named database with the current version, or 1 if it does not already exist. If the request is successful request's result will be the connection.
9363     */
9364    open(name: string, version?: number): IDBOpenDBRequest;
9365}
9366
9367declare var IDBFactory: {
9368    prototype: IDBFactory;
9369    new(): IDBFactory;
9370};
9371
9372/** IDBIndex interface of the IndexedDB API provides asynchronous access to an index in a database. An index is a kind of object store for looking up records in another object store, called the referenced object store. You use this interface to retrieve data. */
9373interface IDBIndex {
9374    readonly keyPath: string | string[];
9375    readonly multiEntry: boolean;
9376    /**
9377     * Returns the name of the index.
9378     */
9379    name: string;
9380    /**
9381     * Returns the IDBObjectStore the index belongs to.
9382     */
9383    readonly objectStore: IDBObjectStore;
9384    readonly unique: boolean;
9385    /**
9386     * Retrieves the number of records matching the given key or key range in query.
9387     * 
9388     * If successful, request's result will be the count.
9389     */
9390    count(key?: IDBValidKey | IDBKeyRange): IDBRequest<number>;
9391    /**
9392     * Retrieves the value of the first record matching the given key or key range in query.
9393     * 
9394     * If successful, request's result will be the value, or undefined if there was no matching record.
9395     */
9396    get(key: IDBValidKey | IDBKeyRange): IDBRequest<any | undefined>;
9397    /**
9398     * Retrieves the values of the records matching the given key or key range in query (up to count if given).
9399     * 
9400     * If successful, request's result will be an Array of the values.
9401     */
9402    getAll(query?: IDBValidKey | IDBKeyRange | null, count?: number): IDBRequest<any[]>;
9403    /**
9404     * Retrieves the keys of records matching the given key or key range in query (up to count if given).
9405     * 
9406     * If successful, request's result will be an Array of the keys.
9407     */
9408    getAllKeys(query?: IDBValidKey | IDBKeyRange | null, count?: number): IDBRequest<IDBValidKey[]>;
9409    /**
9410     * Retrieves the key of the first record matching the given key or key range in query.
9411     * 
9412     * If successful, request's result will be the key, or undefined if there was no matching record.
9413     */
9414    getKey(key: IDBValidKey | IDBKeyRange): IDBRequest<IDBValidKey | undefined>;
9415    /**
9416     * Opens a cursor over the records matching query, ordered by direction. If query is null, all records in index are matched.
9417     * 
9418     * If successful, request's result will be an IDBCursorWithValue, or null if there were no matching records.
9419     */
9420    openCursor(query?: IDBValidKey | IDBKeyRange | null, direction?: IDBCursorDirection): IDBRequest<IDBCursorWithValue | null>;
9421    /**
9422     * Opens a cursor with key only flag set over the records matching query, ordered by direction. If query is null, all records in index are matched.
9423     * 
9424     * If successful, request's result will be an IDBCursor, or null if there were no matching records.
9425     */
9426    openKeyCursor(query?: IDBValidKey | IDBKeyRange | null, direction?: IDBCursorDirection): IDBRequest<IDBCursor | null>;
9427}
9428
9429declare var IDBIndex: {
9430    prototype: IDBIndex;
9431    new(): IDBIndex;
9432};
9433
9434/** A key range can be a single value or a range with upper and lower bounds or endpoints. If the key range has both upper and lower bounds, then it is bounded; if it has no bounds, it is unbounded. A bounded key range can either be open (the endpoints are excluded) or closed (the endpoints are included). To retrieve all keys within a certain range, you can use the following code constructs: */
9435interface IDBKeyRange {
9436    /**
9437     * Returns lower bound, or undefined if none.
9438     */
9439    readonly lower: any;
9440    /**
9441     * Returns true if the lower open flag is set, and false otherwise.
9442     */
9443    readonly lowerOpen: boolean;
9444    /**
9445     * Returns upper bound, or undefined if none.
9446     */
9447    readonly upper: any;
9448    /**
9449     * Returns true if the upper open flag is set, and false otherwise.
9450     */
9451    readonly upperOpen: boolean;
9452    /**
9453     * Returns true if key is included in the range, and false otherwise.
9454     */
9455    includes(key: any): boolean;
9456}
9457
9458declare var IDBKeyRange: {
9459    prototype: IDBKeyRange;
9460    new(): IDBKeyRange;
9461    /**
9462     * Returns a new IDBKeyRange spanning from lower to upper. If lowerOpen is true, lower is not included in the range. If upperOpen is true, upper is not included in the range.
9463     */
9464    bound(lower: any, upper: any, lowerOpen?: boolean, upperOpen?: boolean): IDBKeyRange;
9465    /**
9466     * Returns a new IDBKeyRange starting at key with no upper bound. If open is true, key is not included in the range.
9467     */
9468    lowerBound(lower: any, open?: boolean): IDBKeyRange;
9469    /**
9470     * Returns a new IDBKeyRange spanning only key.
9471     */
9472    only(value: any): IDBKeyRange;
9473    /**
9474     * Returns a new IDBKeyRange with no lower bound and ending at key. If open is true, key is not included in the range.
9475     */
9476    upperBound(upper: any, open?: boolean): IDBKeyRange;
9477};
9478
9479/** This example shows a variety of different uses of object stores, from updating the data structure with IDBObjectStore.createIndex inside an onupgradeneeded function, to adding a new item to our object store with IDBObjectStore.add. For a full working example, see our To-do Notifications app (view example live.) */
9480interface IDBObjectStore {
9481    /**
9482     * Returns true if the store has a key generator, and false otherwise.
9483     */
9484    readonly autoIncrement: boolean;
9485    /**
9486     * Returns a list of the names of indexes in the store.
9487     */
9488    readonly indexNames: DOMStringList;
9489    /**
9490     * Returns the key path of the store, or null if none.
9491     */
9492    readonly keyPath: string | string[];
9493    /**
9494     * Returns the name of the store.
9495     */
9496    name: string;
9497    /**
9498     * Returns the associated transaction.
9499     */
9500    readonly transaction: IDBTransaction;
9501    /**
9502     * Adds or updates a record in store with the given value and key.
9503     * 
9504     * If the store uses in-line keys and key is specified a "DataError" DOMException will be thrown.
9505     * 
9506     * If put() is used, any existing record with the key will be replaced. If add() is used, and if a record with the key already exists the request will fail, with request's error set to a "ConstraintError" DOMException.
9507     * 
9508     * If successful, request's result will be the record's key.
9509     */
9510    add(value: any, key?: IDBValidKey): IDBRequest<IDBValidKey>;
9511    /**
9512     * Deletes all records in store.
9513     * 
9514     * If successful, request's result will be undefined.
9515     */
9516    clear(): IDBRequest<undefined>;
9517    /**
9518     * Retrieves the number of records matching the given key or key range in query.
9519     * 
9520     * If successful, request's result will be the count.
9521     */
9522    count(key?: IDBValidKey | IDBKeyRange): IDBRequest<number>;
9523    /**
9524     * Creates a new index in store with the given name, keyPath and options and returns a new IDBIndex. If the keyPath and options define constraints that cannot be satisfied with the data already in store the upgrade transaction will abort with a "ConstraintError" DOMException.
9525     * 
9526     * Throws an "InvalidStateError" DOMException if not called within an upgrade transaction.
9527     */
9528    createIndex(name: string, keyPath: string | string[], options?: IDBIndexParameters): IDBIndex;
9529    /**
9530     * Deletes records in store with the given key or in the given key range in query.
9531     * 
9532     * If successful, request's result will be undefined.
9533     */
9534    delete(key: IDBValidKey | IDBKeyRange): IDBRequest<undefined>;
9535    /**
9536     * Deletes the index in store with the given name.
9537     * 
9538     * Throws an "InvalidStateError" DOMException if not called within an upgrade transaction.
9539     */
9540    deleteIndex(name: string): void;
9541    /**
9542     * Retrieves the value of the first record matching the given key or key range in query.
9543     * 
9544     * If successful, request's result will be the value, or undefined if there was no matching record.
9545     */
9546    get(query: IDBValidKey | IDBKeyRange): IDBRequest<any | undefined>;
9547    /**
9548     * Retrieves the values of the records matching the given key or key range in query (up to count if given).
9549     * 
9550     * If successful, request's result will be an Array of the values.
9551     */
9552    getAll(query?: IDBValidKey | IDBKeyRange | null, count?: number): IDBRequest<any[]>;
9553    /**
9554     * Retrieves the keys of records matching the given key or key range in query (up to count if given).
9555     * 
9556     * If successful, request's result will be an Array of the keys.
9557     */
9558    getAllKeys(query?: IDBValidKey | IDBKeyRange | null, count?: number): IDBRequest<IDBValidKey[]>;
9559    /**
9560     * Retrieves the key of the first record matching the given key or key range in query.
9561     * 
9562     * If successful, request's result will be the key, or undefined if there was no matching record.
9563     */
9564    getKey(query: IDBValidKey | IDBKeyRange): IDBRequest<IDBValidKey | undefined>;
9565    index(name: string): IDBIndex;
9566    /**
9567     * Opens a cursor over the records matching query, ordered by direction. If query is null, all records in store are matched.
9568     * 
9569     * If successful, request's result will be an IDBCursorWithValue pointing at the first matching record, or null if there were no matching records.
9570     */
9571    openCursor(query?: IDBValidKey | IDBKeyRange | null, direction?: IDBCursorDirection): IDBRequest<IDBCursorWithValue | null>;
9572    /**
9573     * Opens a cursor with key only flag set over the records matching query, ordered by direction. If query is null, all records in store are matched.
9574     * 
9575     * If successful, request's result will be an IDBCursor pointing at the first matching record, or null if there were no matching records.
9576     */
9577    openKeyCursor(query?: IDBValidKey | IDBKeyRange | null, direction?: IDBCursorDirection): IDBRequest<IDBCursor | null>;
9578    /**
9579     * Adds or updates a record in store with the given value and key.
9580     * 
9581     * If the store uses in-line keys and key is specified a "DataError" DOMException will be thrown.
9582     * 
9583     * If put() is used, any existing record with the key will be replaced. If add() is used, and if a record with the key already exists the request will fail, with request's error set to a "ConstraintError" DOMException.
9584     * 
9585     * If successful, request's result will be the record's key.
9586     */
9587    put(value: any, key?: IDBValidKey): IDBRequest<IDBValidKey>;
9588}
9589
9590declare var IDBObjectStore: {
9591    prototype: IDBObjectStore;
9592    new(): IDBObjectStore;
9593};
9594
9595interface IDBOpenDBRequestEventMap extends IDBRequestEventMap {
9596    "blocked": Event;
9597    "upgradeneeded": IDBVersionChangeEvent;
9598}
9599
9600/** Also inherits methods from its parents IDBRequest and EventTarget. */
9601interface IDBOpenDBRequest extends IDBRequest<IDBDatabase> {
9602    onblocked: ((this: IDBOpenDBRequest, ev: Event) => any) | null;
9603    onupgradeneeded: ((this: IDBOpenDBRequest, ev: IDBVersionChangeEvent) => any) | null;
9604    addEventListener<K extends keyof IDBOpenDBRequestEventMap>(type: K, listener: (this: IDBOpenDBRequest, ev: IDBOpenDBRequestEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9605    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9606    removeEventListener<K extends keyof IDBOpenDBRequestEventMap>(type: K, listener: (this: IDBOpenDBRequest, ev: IDBOpenDBRequestEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9607    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9608}
9609
9610declare var IDBOpenDBRequest: {
9611    prototype: IDBOpenDBRequest;
9612    new(): IDBOpenDBRequest;
9613};
9614
9615interface IDBRequestEventMap {
9616    "error": Event;
9617    "success": Event;
9618}
9619
9620/** The request object does not initially contain any information about the result of the operation, but once information becomes available, an event is fired on the request, and the information becomes available through the properties of the IDBRequest instance. */
9621interface IDBRequest<T = any> extends EventTarget {
9622    /**
9623     * When a request is completed, returns the error (a DOMException), or null if the request succeeded. Throws a "InvalidStateError" DOMException if the request is still pending.
9624     */
9625    readonly error: DOMException | null;
9626    onerror: ((this: IDBRequest<T>, ev: Event) => any) | null;
9627    onsuccess: ((this: IDBRequest<T>, ev: Event) => any) | null;
9628    /**
9629     * Returns "pending" until a request is complete, then returns "done".
9630     */
9631    readonly readyState: IDBRequestReadyState;
9632    /**
9633     * When a request is completed, returns the result, or undefined if the request failed. Throws a "InvalidStateError" DOMException if the request is still pending.
9634     */
9635    readonly result: T;
9636    /**
9637     * Returns the IDBObjectStore, IDBIndex, or IDBCursor the request was made against, or null if is was an open request.
9638     */
9639    readonly source: IDBObjectStore | IDBIndex | IDBCursor;
9640    /**
9641     * Returns the IDBTransaction the request was made within. If this as an open request, then it returns an upgrade transaction while it is running, or null otherwise.
9642     */
9643    readonly transaction: IDBTransaction | null;
9644    addEventListener<K extends keyof IDBRequestEventMap>(type: K, listener: (this: IDBRequest<T>, ev: IDBRequestEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9645    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9646    removeEventListener<K extends keyof IDBRequestEventMap>(type: K, listener: (this: IDBRequest<T>, ev: IDBRequestEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9647    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9648}
9649
9650declare var IDBRequest: {
9651    prototype: IDBRequest;
9652    new(): IDBRequest;
9653};
9654
9655interface IDBTransactionEventMap {
9656    "abort": Event;
9657    "complete": Event;
9658    "error": Event;
9659}
9660
9661interface IDBTransaction extends EventTarget {
9662    /**
9663     * Returns the transaction's connection.
9664     */
9665    readonly db: IDBDatabase;
9666    /**
9667     * If the transaction was aborted, returns the error (a DOMException) providing the reason.
9668     */
9669    readonly error: DOMException;
9670    /**
9671     * Returns the mode the transaction was created with ("readonly" or "readwrite"), or "versionchange" for an upgrade transaction.
9672     */
9673    readonly mode: IDBTransactionMode;
9674    /**
9675     * Returns a list of the names of object stores in the transaction's scope. For an upgrade transaction this is all object stores in the database.
9676     */
9677    readonly objectStoreNames: DOMStringList;
9678    onabort: ((this: IDBTransaction, ev: Event) => any) | null;
9679    oncomplete: ((this: IDBTransaction, ev: Event) => any) | null;
9680    onerror: ((this: IDBTransaction, ev: Event) => any) | null;
9681    /**
9682     * Aborts the transaction. All pending requests will fail with a "AbortError" DOMException and all changes made to the database will be reverted.
9683     */
9684    abort(): void;
9685    /**
9686     * Returns an IDBObjectStore in the transaction's scope.
9687     */
9688    objectStore(name: string): IDBObjectStore;
9689    addEventListener<K extends keyof IDBTransactionEventMap>(type: K, listener: (this: IDBTransaction, ev: IDBTransactionEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9690    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9691    removeEventListener<K extends keyof IDBTransactionEventMap>(type: K, listener: (this: IDBTransaction, ev: IDBTransactionEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9692    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9693}
9694
9695declare var IDBTransaction: {
9696    prototype: IDBTransaction;
9697    new(): IDBTransaction;
9698};
9699
9700/** This IndexedDB API interface indicates that the version of the database has changed, as the result of an IDBOpenDBRequest.onupgradeneeded event handler function. */
9701interface IDBVersionChangeEvent extends Event {
9702    readonly newVersion: number | null;
9703    readonly oldVersion: number;
9704}
9705
9706declare var IDBVersionChangeEvent: {
9707    prototype: IDBVersionChangeEvent;
9708    new(type: string, eventInitDict?: IDBVersionChangeEventInit): IDBVersionChangeEvent;
9709};
9710
9711/** The IIRFilterNode interface of the Web Audio API is a AudioNode processor which implements a general infinite impulse response (IIR)  filter; this type of filter can be used to implement tone control devices and graphic equalizers as well. It lets the parameters of the filter response be specified, so that it can be tuned as needed. */
9712interface IIRFilterNode extends AudioNode {
9713    getFrequencyResponse(frequencyHz: Float32Array, magResponse: Float32Array, phaseResponse: Float32Array): void;
9714}
9715
9716declare var IIRFilterNode: {
9717    prototype: IIRFilterNode;
9718    new(context: BaseAudioContext, options: IIRFilterOptions): IIRFilterNode;
9719};
9720
9721interface ImageBitmap {
9722    /**
9723     * Returns the intrinsic height of the image, in CSS pixels.
9724     */
9725    readonly height: number;
9726    /**
9727     * Returns the intrinsic width of the image, in CSS pixels.
9728     */
9729    readonly width: number;
9730    /**
9731     * Releases imageBitmap's underlying bitmap data.
9732     */
9733    close(): void;
9734}
9735
9736declare var ImageBitmap: {
9737    prototype: ImageBitmap;
9738    new(): ImageBitmap;
9739};
9740
9741interface ImageBitmapOptions {
9742    colorSpaceConversion?: "none" | "default";
9743    imageOrientation?: "none" | "flipY";
9744    premultiplyAlpha?: "none" | "premultiply" | "default";
9745    resizeHeight?: number;
9746    resizeQuality?: "pixelated" | "low" | "medium" | "high";
9747    resizeWidth?: number;
9748}
9749
9750interface ImageBitmapRenderingContext {
9751    /**
9752     * Returns the canvas element that the context is bound to.
9753     */
9754    readonly canvas: HTMLCanvasElement | OffscreenCanvas;
9755    /**
9756     * Transfers the underlying bitmap data from imageBitmap to context, and the bitmap becomes the contents of the canvas element to which context is bound.
9757     */
9758    transferFromImageBitmap(bitmap: ImageBitmap | null): void;
9759}
9760
9761declare var ImageBitmapRenderingContext: {
9762    prototype: ImageBitmapRenderingContext;
9763    new(): ImageBitmapRenderingContext;
9764};
9765
9766/** The underlying pixel data of an area of a <canvas> element. It is created using the ImageData() constructor or creator methods on the CanvasRenderingContext2D object associated with a canvas: createImageData() and getImageData(). It can also be used to set a part of the canvas by using putImageData(). */
9767interface ImageData {
9768    /**
9769     * Returns the one-dimensional array containing the data in RGBA order, as integers in the range 0 to 255.
9770     */
9771    readonly data: Uint8ClampedArray;
9772    /**
9773     * Returns the actual dimensions of the data in the ImageData object, in pixels.
9774     */
9775    readonly height: number;
9776    /**
9777     * Returns the actual dimensions of the data in the ImageData object, in pixels.
9778     */
9779    readonly width: number;
9780}
9781
9782declare var ImageData: {
9783    prototype: ImageData;
9784    new(width: number, height: number): ImageData;
9785    new(array: Uint8ClampedArray, width: number, height?: number): ImageData;
9786};
9787
9788interface InnerHTML {
9789    innerHTML: string;
9790}
9791
9792interface InputDeviceInfo extends MediaDeviceInfo {
9793    getCapabilities(): MediaTrackCapabilities;
9794}
9795
9796declare var InputDeviceInfo: {
9797    prototype: InputDeviceInfo;
9798    new(): InputDeviceInfo;
9799};
9800
9801interface InputEvent extends UIEvent {
9802    readonly data: string | null;
9803    readonly inputType: string;
9804    readonly isComposing: boolean;
9805}
9806
9807declare var InputEvent: {
9808    prototype: InputEvent;
9809    new(type: string, eventInitDict?: InputEventInit): InputEvent;
9810};
9811
9812/** provides a way to asynchronously observe changes in the intersection of a target element with an ancestor element or with a top-level document's viewport. */
9813interface IntersectionObserver {
9814    readonly root: Element | null;
9815    readonly rootMargin: string;
9816    readonly thresholds: ReadonlyArray<number>;
9817    disconnect(): void;
9818    observe(target: Element): void;
9819    takeRecords(): IntersectionObserverEntry[];
9820    unobserve(target: Element): void;
9821}
9822
9823declare var IntersectionObserver: {
9824    prototype: IntersectionObserver;
9825    new(callback: IntersectionObserverCallback, options?: IntersectionObserverInit): IntersectionObserver;
9826};
9827
9828/** This Intersection Observer API interface describes the intersection between the target element and its root container at a specific moment of transition. */
9829interface IntersectionObserverEntry {
9830    readonly boundingClientRect: DOMRectReadOnly;
9831    readonly intersectionRatio: number;
9832    readonly intersectionRect: DOMRectReadOnly;
9833    readonly isIntersecting: boolean;
9834    readonly rootBounds: DOMRectReadOnly | null;
9835    readonly target: Element;
9836    readonly time: number;
9837}
9838
9839declare var IntersectionObserverEntry: {
9840    prototype: IntersectionObserverEntry;
9841    new(intersectionObserverEntryInit: IntersectionObserverEntryInit): IntersectionObserverEntry;
9842};
9843
9844/** KeyboardEvent objects describe a user interaction with the keyboard; each event describes a single interaction between the user and a key (or combination of a key with modifier keys) on the keyboard. */
9845interface KeyboardEvent extends UIEvent {
9846    readonly altKey: boolean;
9847    /** @deprecated */
9848    char: string;
9849    /** @deprecated */
9850    readonly charCode: number;
9851    readonly code: string;
9852    readonly ctrlKey: boolean;
9853    readonly isComposing: boolean;
9854    readonly key: string;
9855    /** @deprecated */
9856    readonly keyCode: number;
9857    readonly location: number;
9858    readonly metaKey: boolean;
9859    readonly repeat: boolean;
9860    readonly shiftKey: boolean;
9861    getModifierState(keyArg: string): boolean;
9862    readonly DOM_KEY_LOCATION_LEFT: number;
9863    readonly DOM_KEY_LOCATION_NUMPAD: number;
9864    readonly DOM_KEY_LOCATION_RIGHT: number;
9865    readonly DOM_KEY_LOCATION_STANDARD: number;
9866}
9867
9868declare var KeyboardEvent: {
9869    prototype: KeyboardEvent;
9870    new(type: string, eventInitDict?: KeyboardEventInit): KeyboardEvent;
9871    readonly DOM_KEY_LOCATION_LEFT: number;
9872    readonly DOM_KEY_LOCATION_NUMPAD: number;
9873    readonly DOM_KEY_LOCATION_RIGHT: number;
9874    readonly DOM_KEY_LOCATION_STANDARD: number;
9875};
9876
9877interface KeyframeEffect extends AnimationEffect {
9878    composite: CompositeOperation;
9879    iterationComposite: IterationCompositeOperation;
9880    target: Element | null;
9881    getKeyframes(): ComputedKeyframe[];
9882    setKeyframes(keyframes: Keyframe[] | PropertyIndexedKeyframes | null): void;
9883}
9884
9885declare var KeyframeEffect: {
9886    prototype: KeyframeEffect;
9887    new(target: Element | null, keyframes: Keyframe[] | PropertyIndexedKeyframes | null, options?: number | KeyframeEffectOptions): KeyframeEffect;
9888    new(source: KeyframeEffect): KeyframeEffect;
9889};
9890
9891interface LinkStyle {
9892    readonly sheet: StyleSheet | null;
9893}
9894
9895interface ListeningStateChangedEvent extends Event {
9896    readonly label: string;
9897    readonly state: ListeningState;
9898}
9899
9900declare var ListeningStateChangedEvent: {
9901    prototype: ListeningStateChangedEvent;
9902    new(): ListeningStateChangedEvent;
9903};
9904
9905/** The location (URL) of the object it is linked to. Changes done on it are reflected on the object it relates to. Both the Document and Window interface have such a linked Location, accessible via Document.location and Window.location respectively. */
9906interface Location {
9907    /**
9908     * Returns a DOMStringList object listing the origins of the ancestor browsing contexts, from the parent browsing context to the top-level browsing context.
9909     */
9910    readonly ancestorOrigins: DOMStringList;
9911    /**
9912     * Returns the Location object's URL's fragment (includes leading "#" if non-empty).
9913     * 
9914     * Can be set, to navigate to the same URL with a changed fragment (ignores leading "#").
9915     */
9916    hash: string;
9917    /**
9918     * Returns the Location object's URL's host and port (if different from the default port for the scheme).
9919     * 
9920     * Can be set, to navigate to the same URL with a changed host and port.
9921     */
9922    host: string;
9923    /**
9924     * Returns the Location object's URL's host.
9925     * 
9926     * Can be set, to navigate to the same URL with a changed host.
9927     */
9928    hostname: string;
9929    /**
9930     * Returns the Location object's URL.
9931     * 
9932     * Can be set, to navigate to the given URL.
9933     */
9934    href: string;
9935    /**
9936     * Returns the Location object's URL's origin.
9937     */
9938    readonly origin: string;
9939    /**
9940     * Returns the Location object's URL's path.
9941     * 
9942     * Can be set, to navigate to the same URL with a changed path.
9943     */
9944    pathname: string;
9945    /**
9946     * Returns the Location object's URL's port.
9947     * 
9948     * Can be set, to navigate to the same URL with a changed port.
9949     */
9950    port: string;
9951    /**
9952     * Returns the Location object's URL's scheme.
9953     * 
9954     * Can be set, to navigate to the same URL with a changed scheme.
9955     */
9956    protocol: string;
9957    /**
9958     * Returns the Location object's URL's query (includes leading "?" if non-empty).
9959     * 
9960     * Can be set, to navigate to the same URL with a changed query (ignores leading "?").
9961     */
9962    search: string;
9963    /**
9964     * Navigates to the given URL.
9965     */
9966    assign(url: string): void;
9967    /**
9968     * Reloads the current page.
9969     */
9970    reload(): void;
9971    /** @deprecated */
9972    reload(forcedReload: boolean): void;
9973    /**
9974     * Removes the current page from the session history and navigates to the given URL.
9975     */
9976    replace(url: string): void;
9977}
9978
9979declare var Location: {
9980    prototype: Location;
9981    new(): Location;
9982};
9983
9984interface MSAssertion {
9985    readonly id: string;
9986    readonly type: MSCredentialType;
9987}
9988
9989declare var MSAssertion: {
9990    prototype: MSAssertion;
9991    new(): MSAssertion;
9992};
9993
9994interface MSBlobBuilder {
9995    append(data: any, endings?: string): void;
9996    getBlob(contentType?: string): Blob;
9997}
9998
9999declare var MSBlobBuilder: {
10000    prototype: MSBlobBuilder;