.config/coc/extensions/node_modules/coc-tsserver/node_modules/typescript/lib/lib.dom.d.ts

   1 /*! *****************************************************************************
   2 Copyright (c) Microsoft Corporation. All rights reserved.
   3 Licensed under the Apache License, Version 2.0 (the "License"); you may not use
   4 this file except in compliance with the License. You may obtain a copy of the
   5 License at http://www.apache.org/licenses/LICENSE-2.0
   6
   7 THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
   8 KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
   9 WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
  10 MERCHANTABLITY OR NON-INFRINGEMENT.
  11
  12 See the Apache Version 2.0 License for specific language governing permissions
  13 and limitations under the License.
  14 ***************************************************************************** */
  15
  16
  17
  18 /// <reference no-default-lib="true"/>\r
  19
  20
  21 /////////////////////////////
  22 /// DOM APIs
  23 /////////////////////////////
  24
  25 interface Account {
  26     displayName: string;
  27     id: string;
  28     imageURL?: string;
  29     name?: string;
  30     rpDisplayName: string;
  31 }
  32
  33 interface AddEventListenerOptions extends EventListenerOptions {
  34     once?: boolean;
  35     passive?: boolean;
  36 }
  37
  38 interface AesCbcParams extends Algorithm {
  39     iv: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;
  40 }
  41
  42 interface AesCtrParams extends Algorithm {
  43     counter: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;
  44     length: number;
  45 }
  46
  47 interface AesDerivedKeyParams extends Algorithm {
  48     length: number;
  49 }
  50
  51 interface 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
  57 interface AesKeyAlgorithm extends KeyAlgorithm {
  58     length: number;
  59 }
  60
  61 interface AesKeyGenParams extends Algorithm {
  62     length: number;
  63 }
  64
  65 interface Algorithm {
  66     name: string;
  67 }
  68
  69 interface AnalyserOptions extends AudioNodeOptions {
  70     fftSize?: number;
  71     maxDecibels?: number;
  72     minDecibels?: number;
  73     smoothingTimeConstant?: number;
  74 }
  75
  76 interface AnimationEventInit extends EventInit {
  77     animationName?: string;
  78     elapsedTime?: number;
  79     pseudoElement?: string;
  80 }
  81
  82 interface AnimationPlaybackEventInit extends EventInit {
  83     currentTime?: number | null;
  84     timelineTime?: number | null;
  85 }
  86
  87 interface AssertionOptions {
  88     allowList?: ScopedCredentialDescriptor[];
  89     extensions?: WebAuthnExtensions;
  90     rpId?: string;
  91     timeoutSeconds?: number;
  92 }
  93
  94 interface AssignedNodesOptions {
  95     flatten?: boolean;
  96 }
  97
  98 interface AudioBufferOptions {
  99     length: number;
 100     numberOfChannels?: number;
 101     sampleRate: number;
 102 }
 103
 104 interface AudioBufferSourceOptions {
 105     buffer?: AudioBuffer | null;
 106     detune?: number;
 107     loop?: boolean;
 108     loopEnd?: number;
 109     loopStart?: number;
 110     playbackRate?: number;
 111 }
 112
 113 interface AudioContextInfo {
 114     currentTime?: number;
 115     sampleRate?: number;
 116 }
 117
 118 interface AudioContextOptions {
 119     latencyHint?: AudioContextLatencyCategory | number;
 120     sampleRate?: number;
 121 }
 122
 123 interface AudioNodeOptions {
 124     channelCount?: number;
 125     channelCountMode?: ChannelCountMode;
 126     channelInterpretation?: ChannelInterpretation;
 127 }
 128
 129 interface AudioParamDescriptor {
 130     automationRate?: AutomationRate;
 131     defaultValue?: number;
 132     maxValue?: number;
 133     minValue?: number;
 134     name: string;
 135 }
 136
 137 interface AudioProcessingEventInit extends EventInit {
 138     inputBuffer: AudioBuffer;
 139     outputBuffer: AudioBuffer;
 140     playbackTime: number;
 141 }
 142
 143 interface AudioTimestamp {
 144     contextTime?: number;
 145     performanceTime?: number;
 146 }
 147
 148 interface AudioWorkletNodeOptions extends AudioNodeOptions {
 149     numberOfInputs?: number;
 150     numberOfOutputs?: number;
 151     outputChannelCount?: number[];
 152     parameterData?: Record<string, number>;
 153     processorOptions?: any;
 154 }
 155
 156 interface AuthenticationExtensionsClientInputs {
 157     appid?: string;
 158     appidExclude?: string;
 159     credProps?: boolean;
 160     uvm?: boolean;
 161 }
 162
 163 interface AuthenticationExtensionsClientOutputs {
 164     appid?: boolean;
 165     credProps?: CredentialPropertiesOutput;
 166     uvm?: UvmEntries;
 167 }
 168
 169 interface AuthenticatorSelectionCriteria {
 170     authenticatorAttachment?: AuthenticatorAttachment;
 171     requireResidentKey?: boolean;
 172     residentKey?: ResidentKeyRequirement;
 173     userVerification?: UserVerificationRequirement;
 174 }
 175
 176 interface BiquadFilterOptions extends AudioNodeOptions {
 177     Q?: number;
 178     detune?: number;
 179     frequency?: number;
 180     gain?: number;
 181     type?: BiquadFilterType;
 182 }
 183
 184 interface BlobPropertyBag {
 185     endings?: EndingType;
 186     type?: string;
 187 }
 188
 189 interface ByteLengthChunk {
 190     byteLength?: number;
 191 }
 192
 193 interface CacheQueryOptions {
 194     ignoreMethod?: boolean;
 195     ignoreSearch?: boolean;
 196     ignoreVary?: boolean;
 197 }
 198
 199 interface CanvasRenderingContext2DSettings {
 200     alpha?: boolean;
 201     desynchronized?: boolean;
 202 }
 203
 204 interface ChannelMergerOptions extends AudioNodeOptions {
 205     numberOfInputs?: number;
 206 }
 207
 208 interface ChannelSplitterOptions extends AudioNodeOptions {
 209     numberOfOutputs?: number;
 210 }
 211
 212 interface ClientData {
 213     challenge: string;
 214     extensions?: WebAuthnExtensions;
 215     hashAlg: string | Algorithm;
 216     origin: string;
 217     rpId: string;
 218     tokenBinding?: string;
 219 }
 220
 221 interface ClientQueryOptions {
 222     includeUncontrolled?: boolean;
 223     type?: ClientTypes;
 224 }
 225
 226 interface ClipboardEventInit extends EventInit {
 227     clipboardData?: DataTransfer | null;
 228 }
 229
 230 interface CloseEventInit extends EventInit {
 231     code?: number;
 232     reason?: string;
 233     wasClean?: boolean;
 234 }
 235
 236 interface CompositionEventInit extends UIEventInit {
 237     data?: string;
 238 }
 239
 240 interface ComputedEffectTiming extends EffectTiming {
 241     activeDuration?: number;
 242     currentIteration?: number | null;
 243     endTime?: number;
 244     localTime?: number | null;
 245     progress?: number | null;
 246 }
 247
 248 interface ComputedKeyframe {
 249     composite: CompositeOperationOrAuto;
 250     computedOffset: number;
 251     easing: string;
 252     offset: number | null;
 253     [property: string]: string | number | null | undefined;
 254 }
 255
 256 interface ConfirmSiteSpecificExceptionsInformation extends ExceptionInformation {
 257     arrayOfDomainStrings?: string[];
 258 }
 259
 260 interface ConstantSourceOptions {
 261     offset?: number;
 262 }
 263
 264 interface ConstrainBooleanParameters {
 265     exact?: boolean;
 266     ideal?: boolean;
 267 }
 268
 269 interface ConstrainDOMStringParameters {
 270     exact?: string | string[];
 271     ideal?: string | string[];
 272 }
 273
 274 interface ConstrainDoubleRange extends DoubleRange {
 275     exact?: number;
 276     ideal?: number;
 277 }
 278
 279 interface ConstrainULongRange extends ULongRange {
 280     exact?: number;
 281     ideal?: number;
 282 }
 283
 284 interface ConstrainVideoFacingModeParameters {
 285     exact?: VideoFacingModeEnum | VideoFacingModeEnum[];
 286     ideal?: VideoFacingModeEnum | VideoFacingModeEnum[];
 287 }
 288
 289 interface ConvolverOptions extends AudioNodeOptions {
 290     buffer?: AudioBuffer | null;
 291     disableNormalization?: boolean;
 292 }
 293
 294 interface CredentialCreationOptions {
 295     publicKey?: PublicKeyCredentialCreationOptions;
 296     signal?: AbortSignal;
 297 }
 298
 299 interface CredentialPropertiesOutput {
 300     rk?: boolean;
 301 }
 302
 303 interface CredentialRequestOptions {
 304     mediation?: CredentialMediationRequirement;
 305     publicKey?: PublicKeyCredentialRequestOptions;
 306     signal?: AbortSignal;
 307 }
 308
 309 interface CustomEventInit<T = any> extends EventInit {
 310     detail?: T;
 311 }
 312
 313 interface DOMMatrix2DInit {
 314     a?: number;
 315     b?: number;
 316     c?: number;
 317     d?: number;
 318     e?: number;
 319     f?: number;
 320     m11?: number;
 321     m12?: number;
 322     m21?: number;
 323     m22?: number;
 324     m41?: number;
 325     m42?: number;
 326 }
 327
 328 interface DOMMatrixInit extends DOMMatrix2DInit {
 329     is2D?: boolean;
 330     m13?: number;
 331     m14?: number;
 332     m23?: number;
 333     m24?: number;
 334     m31?: number;
 335     m32?: number;
 336     m33?: number;
 337     m34?: number;
 338     m43?: number;
 339     m44?: number;
 340 }
 341
 342 interface DOMPointInit {
 343     w?: number;
 344     x?: number;
 345     y?: number;
 346     z?: number;
 347 }
 348
 349 interface DOMQuadInit {
 350     p1?: DOMPointInit;
 351     p2?: DOMPointInit;
 352     p3?: DOMPointInit;
 353     p4?: DOMPointInit;
 354 }
 355
 356 interface DOMRectInit {
 357     height?: number;
 358     width?: number;
 359     x?: number;
 360     y?: number;
 361 }
 362
 363 interface DelayOptions extends AudioNodeOptions {
 364     delayTime?: number;
 365     maxDelayTime?: number;
 366 }
 367
 368 interface DeviceLightEventInit extends EventInit {
 369     value?: number;
 370 }
 371
 372 interface DeviceMotionEventAccelerationInit {
 373     x?: number | null;
 374     y?: number | null;
 375     z?: number | null;
 376 }
 377
 378 interface DeviceMotionEventInit extends EventInit {
 379     acceleration?: DeviceMotionEventAccelerationInit;
 380     accelerationIncludingGravity?: DeviceMotionEventAccelerationInit;
 381     interval?: number;
 382     rotationRate?: DeviceMotionEventRotationRateInit;
 383 }
 384
 385 interface DeviceMotionEventRotationRateInit {
 386     alpha?: number | null;
 387     beta?: number | null;
 388     gamma?: number | null;
 389 }
 390
 391 interface DeviceOrientationEventInit extends EventInit {
 392     absolute?: boolean;
 393     alpha?: number | null;
 394     beta?: number | null;
 395     gamma?: number | null;
 396 }
 397
 398 interface DevicePermissionDescriptor extends PermissionDescriptor {
 399     deviceId?: string;
 400     name: "camera" | "microphone" | "speaker";
 401 }
 402
 403 interface DocumentTimelineOptions {
 404     originTime?: number;
 405 }
 406
 407 interface DoubleRange {
 408     max?: number;
 409     min?: number;
 410 }
 411
 412 interface DragEventInit extends MouseEventInit {
 413     dataTransfer?: DataTransfer | null;
 414 }
 415
 416 interface DynamicsCompressorOptions extends AudioNodeOptions {
 417     attack?: number;
 418     knee?: number;
 419     ratio?: number;
 420     release?: number;
 421     threshold?: number;
 422 }
 423
 424 interface EcKeyAlgorithm extends KeyAlgorithm {
 425     namedCurve: NamedCurve;
 426 }
 427
 428 interface EcKeyGenParams extends Algorithm {
 429     namedCurve: NamedCurve;
 430 }
 431
 432 interface EcKeyImportParams extends Algorithm {
 433     namedCurve: NamedCurve;
 434 }
 435
 436 interface EcdhKeyDeriveParams extends Algorithm {
 437     public: CryptoKey;
 438 }
 439
 440 interface EcdsaParams extends Algorithm {
 441     hash: HashAlgorithmIdentifier;
 442 }
 443
 444 interface EffectTiming {
 445     delay?: number;
 446     direction?: PlaybackDirection;
 447     duration?: number | string;
 448     easing?: string;
 449     endDelay?: number;
 450     fill?: FillMode;
 451     iterationStart?: number;
 452     iterations?: number;
 453 }
 454
 455 interface ElementCreationOptions {
 456     is?: string;
 457 }
 458
 459 interface ElementDefinitionOptions {
 460     extends?: string;
 461 }
 462
 463 interface ErrorEventInit extends EventInit {
 464     colno?: number;
 465     error?: any;
 466     filename?: string;
 467     lineno?: number;
 468     message?: string;
 469 }
 470
 471 interface EventInit {
 472     bubbles?: boolean;
 473     cancelable?: boolean;
 474     composed?: boolean;
 475 }
 476
 477 interface EventListenerOptions {
 478     capture?: boolean;
 479 }
 480
 481 interface EventModifierInit extends UIEventInit {
 482     altKey?: boolean;
 483     ctrlKey?: boolean;
 484     metaKey?: boolean;
 485     modifierAltGraph?: boolean;
 486     modifierCapsLock?: boolean;
 487     modifierFn?: boolean;
 488     modifierFnLock?: boolean;
 489     modifierHyper?: boolean;
 490     modifierNumLock?: boolean;
 491     modifierScrollLock?: boolean;
 492     modifierSuper?: boolean;
 493     modifierSymbol?: boolean;
 494     modifierSymbolLock?: boolean;
 495     shiftKey?: boolean;
 496 }
 497
 498 interface EventSourceInit {
 499     withCredentials?: boolean;
 500 }
 501
 502 interface ExceptionInformation {
 503     domain?: string | null;
 504 }
 505
 506 interface FilePropertyBag extends BlobPropertyBag {
 507     lastModified?: number;
 508 }
 509
 510 interface FocusEventInit extends UIEventInit {
 511     relatedTarget?: EventTarget | null;
 512 }
 513
 514 interface FocusNavigationEventInit extends EventInit {
 515     navigationReason?: string | null;
 516     originHeight?: number;
 517     originLeft?: number;
 518     originTop?: number;
 519     originWidth?: number;
 520 }
 521
 522 interface FocusNavigationOrigin {
 523     originHeight?: number;
 524     originLeft?: number;
 525     originTop?: number;
 526     originWidth?: number;
 527 }
 528
 529 interface FocusOptions {
 530     preventScroll?: boolean;
 531 }
 532
 533 interface FullscreenOptions {
 534     navigationUI?: FullscreenNavigationUI;
 535 }
 536
 537 interface GainOptions extends AudioNodeOptions {
 538     gain?: number;
 539 }
 540
 541 interface GamepadEventInit extends EventInit {
 542     gamepad: Gamepad;
 543 }
 544
 545 interface GetNotificationOptions {
 546     tag?: string;
 547 }
 548
 549 interface GetRootNodeOptions {
 550     composed?: boolean;
 551 }
 552
 553 interface HashChangeEventInit extends EventInit {
 554     newURL?: string;
 555     oldURL?: string;
 556 }
 557
 558 interface HkdfParams extends Algorithm {
 559     hash: HashAlgorithmIdentifier;
 560     info: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;
 561     salt: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;
 562 }
 563
 564 interface HmacImportParams extends Algorithm {
 565     hash: HashAlgorithmIdentifier;
 566     length?: number;
 567 }
 568
 569 interface HmacKeyAlgorithm extends KeyAlgorithm {
 570     hash: KeyAlgorithm;
 571     length: number;
 572 }
 573
 574 interface HmacKeyGenParams extends Algorithm {
 575     hash: HashAlgorithmIdentifier;
 576     length?: number;
 577 }
 578
 579 interface IDBIndexParameters {
 580     multiEntry?: boolean;
 581     unique?: boolean;
 582 }
 583
 584 interface IDBObjectStoreParameters {
 585     autoIncrement?: boolean;
 586     keyPath?: string | string[] | null;
 587 }
 588
 589 interface IDBVersionChangeEventInit extends EventInit {
 590     newVersion?: number | null;
 591     oldVersion?: number;
 592 }
 593
 594 interface IIRFilterOptions extends AudioNodeOptions {
 595     feedback: number[];
 596     feedforward: number[];
 597 }
 598
 599 interface ImageBitmapOptions {
 600     colorSpaceConversion?: ColorSpaceConversion;
 601     imageOrientation?: ImageOrientation;
 602     premultiplyAlpha?: PremultiplyAlpha;
 603     resizeHeight?: number;
 604     resizeQuality?: ResizeQuality;
 605     resizeWidth?: number;
 606 }
 607
 608 interface ImageBitmapRenderingContextSettings {
 609     alpha?: boolean;
 610 }
 611
 612 interface ImageEncodeOptions {
 613     quality?: number;
 614     type?: string;
 615 }
 616
 617 interface ImportMeta {
 618     url: string;
 619 }
 620
 621 interface InputEventInit extends UIEventInit {
 622     data?: string | null;
 623     inputType?: string;
 624     isComposing?: boolean;
 625 }
 626
 627 interface IntersectionObserverEntryInit {
 628     boundingClientRect: DOMRectInit;
 629     intersectionRatio: number;
 630     intersectionRect: DOMRectInit;
 631     isIntersecting: boolean;
 632     rootBounds: DOMRectInit | null;
 633     target: Element;
 634     time: number;
 635 }
 636
 637 interface IntersectionObserverInit {
 638     root?: Element | Document | null;
 639     rootMargin?: string;
 640     threshold?: number | number[];
 641 }
 642
 643 interface JsonWebKey {
 644     alg?: string;
 645     crv?: string;
 646     d?: string;
 647     dp?: string;
 648     dq?: string;
 649     e?: string;
 650     ext?: boolean;
 651     k?: string;
 652     key_ops?: string[];
 653     kty?: string;
 654     n?: string;
 655     oth?: RsaOtherPrimesInfo[];
 656     p?: string;
 657     q?: string;
 658     qi?: string;
 659     use?: string;
 660     x?: string;
 661     y?: string;
 662 }
 663
 664 interface KeyAlgorithm {
 665     name: string;
 666 }
 667
 668 interface KeyboardEventInit extends EventModifierInit {
 669     /** @deprecated */
 670     charCode?: number;
 671     code?: string;
 672     isComposing?: boolean;
 673     key?: string;
 674     /** @deprecated */
 675     keyCode?: number;
 676     location?: number;
 677     repeat?: boolean;
 678 }
 679
 680 interface Keyframe {
 681     composite?: CompositeOperationOrAuto;
 682     easing?: string;
 683     offset?: number | null;
 684     [property: string]: string | number | null | undefined;
 685 }
 686
 687 interface KeyframeAnimationOptions extends KeyframeEffectOptions {
 688     id?: string;
 689 }
 690
 691 interface KeyframeEffectOptions extends EffectTiming {
 692     composite?: CompositeOperation;
 693     iterationComposite?: IterationCompositeOperation;
 694 }
 695
 696 interface MediaElementAudioSourceOptions {
 697     mediaElement: HTMLMediaElement;
 698 }
 699
 700 interface MediaEncryptedEventInit extends EventInit {
 701     initData?: ArrayBuffer | null;
 702     initDataType?: string;
 703 }
 704
 705 interface MediaKeyMessageEventInit extends EventInit {
 706     message: ArrayBuffer;
 707     messageType: MediaKeyMessageType;
 708 }
 709
 710 interface MediaKeySystemConfiguration {
 711     audioCapabilities?: MediaKeySystemMediaCapability[];
 712     distinctiveIdentifier?: MediaKeysRequirement;
 713     initDataTypes?: string[];
 714     label?: string;
 715     persistentState?: MediaKeysRequirement;
 716     sessionTypes?: string[];
 717     videoCapabilities?: MediaKeySystemMediaCapability[];
 718 }
 719
 720 interface MediaKeySystemMediaCapability {
 721     contentType?: string;
 722     robustness?: string;
 723 }
 724
 725 interface MediaQueryListEventInit extends EventInit {
 726     matches?: boolean;
 727     media?: string;
 728 }
 729
 730 interface MediaStreamAudioSourceOptions {
 731     mediaStream: MediaStream;
 732 }
 733
 734 interface MediaStreamConstraints {
 735     audio?: boolean | MediaTrackConstraints;
 736     peerIdentity?: string;
 737     video?: boolean | MediaTrackConstraints;
 738 }
 739
 740 interface MediaStreamErrorEventInit extends EventInit {
 741     error?: MediaStreamError | null;
 742 }
 743
 744 interface MediaStreamEventInit extends EventInit {
 745     stream?: MediaStream;
 746 }
 747
 748 interface MediaStreamTrackAudioSourceOptions {
 749     mediaStreamTrack: MediaStreamTrack;
 750 }
 751
 752 interface MediaStreamTrackEventInit extends EventInit {
 753     track: MediaStreamTrack;
 754 }
 755
 756 interface MediaTrackCapabilities {
 757     aspectRatio?: DoubleRange;
 758     autoGainControl?: boolean[];
 759     channelCount?: ULongRange;
 760     deviceId?: string;
 761     echoCancellation?: boolean[];
 762     facingMode?: string[];
 763     frameRate?: DoubleRange;
 764     groupId?: string;
 765     height?: ULongRange;
 766     latency?: DoubleRange;
 767     noiseSuppression?: boolean[];
 768     resizeMode?: string[];
 769     sampleRate?: ULongRange;
 770     sampleSize?: ULongRange;
 771     width?: ULongRange;
 772 }
 773
 774 interface MediaTrackConstraintSet {
 775     aspectRatio?: ConstrainDouble;
 776     autoGainControl?: ConstrainBoolean;
 777     channelCount?: ConstrainULong;
 778     deviceId?: ConstrainDOMString;
 779     echoCancellation?: ConstrainBoolean;
 780     facingMode?: ConstrainDOMString;
 781     frameRate?: ConstrainDouble;
 782     groupId?: ConstrainDOMString;
 783     height?: ConstrainULong;
 784     latency?: ConstrainDouble;
 785     noiseSuppression?: ConstrainBoolean;
 786     resizeMode?: ConstrainDOMString;
 787     sampleRate?: ConstrainULong;
 788     sampleSize?: ConstrainULong;
 789     width?: ConstrainULong;
 790 }
 791
 792 interface MediaTrackConstraints extends MediaTrackConstraintSet {
 793     advanced?: MediaTrackConstraintSet[];
 794 }
 795
 796 interface MediaTrackSettings {
 797     aspectRatio?: number;
 798     autoGainControl?: boolean;
 799     channelCount?: number;
 800     deviceId?: string;
 801     echoCancellation?: boolean;
 802     facingMode?: string;
 803     frameRate?: number;
 804     groupId?: string;
 805     height?: number;
 806     latency?: number;
 807     noiseSuppression?: boolean;
 808     resizeMode?: string;
 809     sampleRate?: number;
 810     sampleSize?: number;
 811     width?: number;
 812 }
 813
 814 interface MediaTrackSupportedConstraints {
 815     aspectRatio?: boolean;
 816     autoGainControl?: boolean;
 817     channelCount?: boolean;
 818     deviceId?: boolean;
 819     echoCancellation?: boolean;
 820     facingMode?: boolean;
 821     frameRate?: boolean;
 822     groupId?: boolean;
 823     height?: boolean;
 824     latency?: boolean;
 825     noiseSuppression?: boolean;
 826     resizeMode?: boolean;
 827     sampleRate?: boolean;
 828     sampleSize?: boolean;
 829     width?: boolean;
 830 }
 831
 832 interface MessageEventInit<T = any> extends EventInit {
 833     data?: T;
 834     lastEventId?: string;
 835     origin?: string;
 836     ports?: MessagePort[];
 837     source?: MessageEventSource | null;
 838 }
 839
 840 interface MidiPermissionDescriptor extends PermissionDescriptor {
 841     name: "midi";
 842     sysex?: boolean;
 843 }
 844
 845 interface MouseEventInit extends EventModifierInit {
 846     button?: number;
 847     buttons?: number;
 848     clientX?: number;
 849     clientY?: number;
 850     movementX?: number;
 851     movementY?: number;
 852     relatedTarget?: EventTarget | null;
 853     screenX?: number;
 854     screenY?: number;
 855 }
 856
 857 interface MultiCacheQueryOptions extends CacheQueryOptions {
 858     cacheName?: string;
 859 }
 860
 861 interface MutationObserverInit {
 862     /**
 863      * 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.
 864      */
 865     attributeFilter?: string[];
 866     /**
 867      * Set to true if attributes is true or omitted and target's attribute value before the mutation needs to be recorded.
 868      */
 869     attributeOldValue?: boolean;
 870     /**
 871      * Set to true if mutations to target's attributes are to be observed. Can be omitted if attributeOldValue or attributeFilter is specified.
 872      */
 873     attributes?: boolean;
 874     /**
 875      * Set to true if mutations to target's data are to be observed. Can be omitted if characterDataOldValue is specified.
 876      */
 877     characterData?: boolean;
 878     /**
 879      * Set to true if characterData is set to true or omitted and target's data before the mutation needs to be recorded.
 880      */
 881     characterDataOldValue?: boolean;
 882     /**
 883      * Set to true if mutations to target's children are to be observed.
 884      */
 885     childList?: boolean;
 886     /**
 887      * Set to true if mutations to not just target, but also target's descendants are to be observed.
 888      */
 889     subtree?: boolean;
 890 }
 891
 892 interface NavigationPreloadState {
 893     enabled?: boolean;
 894     headerValue?: string;
 895 }
 896
 897 interface NotificationAction {
 898     action: string;
 899     icon?: string;
 900     title: string;
 901 }
 902
 903 interface NotificationOptions {
 904     actions?: NotificationAction[];
 905     badge?: string;
 906     body?: string;
 907     data?: any;
 908     dir?: NotificationDirection;
 909     icon?: string;
 910     image?: string;
 911     lang?: string;
 912     renotify?: boolean;
 913     requireInteraction?: boolean;
 914     silent?: boolean;
 915     tag?: string;
 916     timestamp?: number;
 917     vibrate?: VibratePattern;
 918 }
 919
 920 interface OfflineAudioCompletionEventInit extends EventInit {
 921     renderedBuffer: AudioBuffer;
 922 }
 923
 924 interface OfflineAudioContextOptions {
 925     length: number;
 926     numberOfChannels?: number;
 927     sampleRate: number;
 928 }
 929
 930 interface OptionalEffectTiming {
 931     delay?: number;
 932     direction?: PlaybackDirection;
 933     duration?: number | string;
 934     easing?: string;
 935     endDelay?: number;
 936     fill?: FillMode;
 937     iterationStart?: number;
 938     iterations?: number;
 939 }
 940
 941 interface OscillatorOptions extends AudioNodeOptions {
 942     detune?: number;
 943     frequency?: number;
 944     periodicWave?: PeriodicWave;
 945     type?: OscillatorType;
 946 }
 947
 948 interface PageTransitionEventInit extends EventInit {
 949     persisted?: boolean;
 950 }
 951
 952 interface PannerOptions extends AudioNodeOptions {
 953     coneInnerAngle?: number;
 954     coneOuterAngle?: number;
 955     coneOuterGain?: number;
 956     distanceModel?: DistanceModelType;
 957     maxDistance?: number;
 958     orientationX?: number;
 959     orientationY?: number;
 960     orientationZ?: number;
 961     panningModel?: PanningModelType;
 962     positionX?: number;
 963     positionY?: number;
 964     positionZ?: number;
 965     refDistance?: number;
 966     rolloffFactor?: number;
 967 }
 968
 969 interface PaymentCurrencyAmount {
 970     currency: string;
 971     currencySystem?: string;
 972     value: string;
 973 }
 974
 975 interface PaymentDetailsBase {
 976     displayItems?: PaymentItem[];
 977     modifiers?: PaymentDetailsModifier[];
 978     shippingOptions?: PaymentShippingOption[];
 979 }
 980
 981 interface PaymentDetailsInit extends PaymentDetailsBase {
 982     id?: string;
 983     total: PaymentItem;
 984 }
 985
 986 interface PaymentDetailsModifier {
 987     additionalDisplayItems?: PaymentItem[];
 988     data?: any;
 989     supportedMethods: string | string[];
 990     total?: PaymentItem;
 991 }
 992
 993 interface PaymentDetailsUpdate extends PaymentDetailsBase {
 994     error?: string;
 995     total?: PaymentItem;
 996 }
 997
 998 interface PaymentItem {
 999     amount: PaymentCurrencyAmount;
1000     label: string;
1001     pending?: boolean;
1002 }
1003
1004 interface PaymentMethodData {
1005     data?: any;
1006     supportedMethods: string | string[];
1007 }
1008
1009 interface PaymentOptions {
1010     requestPayerEmail?: boolean;
1011     requestPayerName?: boolean;
1012     requestPayerPhone?: boolean;
1013     requestShipping?: boolean;
1014     shippingType?: string;
1015 }
1016
1017 interface PaymentRequestUpdateEventInit extends EventInit {
1018 }
1019
1020 interface PaymentShippingOption {
1021     amount: PaymentCurrencyAmount;
1022     id: string;
1023     label: string;
1024     selected?: boolean;
1025 }
1026
1027 interface Pbkdf2Params extends Algorithm {
1028     hash: HashAlgorithmIdentifier;
1029     iterations: number;
1030     salt: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;
1031 }
1032
1033 interface PerformanceObserverInit {
1034     buffered?: boolean;
1035     entryTypes?: string[];
1036     type?: string;
1037 }
1038
1039 interface PeriodicWaveConstraints {
1040     disableNormalization?: boolean;
1041 }
1042
1043 interface PeriodicWaveOptions extends PeriodicWaveConstraints {
1044     imag?: number[] | Float32Array;
1045     real?: number[] | Float32Array;
1046 }
1047
1048 interface PermissionDescriptor {
1049     name: PermissionName;
1050 }
1051
1052 interface PointerEventInit extends MouseEventInit {
1053     coalescedEvents?: PointerEvent[];
1054     height?: number;
1055     isPrimary?: boolean;
1056     pointerId?: number;
1057     pointerType?: string;
1058     predictedEvents?: PointerEvent[];
1059     pressure?: number;
1060     tangentialPressure?: number;
1061     tiltX?: number;
1062     tiltY?: number;
1063     twist?: number;
1064     width?: number;
1065 }
1066
1067 interface PopStateEventInit extends EventInit {
1068     state?: any;
1069 }
1070
1071 interface PositionOptions {
1072     enableHighAccuracy?: boolean;
1073     maximumAge?: number;
1074     timeout?: number;
1075 }
1076
1077 interface PostMessageOptions {
1078     transfer?: any[];
1079 }
1080
1081 interface ProgressEventInit extends EventInit {
1082     lengthComputable?: boolean;
1083     loaded?: number;
1084     total?: number;
1085 }
1086
1087 interface PromiseRejectionEventInit extends EventInit {
1088     promise: Promise<any>;
1089     reason?: any;
1090 }
1091
1092 interface PropertyIndexedKeyframes {
1093     composite?: CompositeOperationOrAuto | CompositeOperationOrAuto[];
1094     easing?: string | string[];
1095     offset?: number | (number | null)[];
1096     [property: string]: string | string[] | number | null | (number | null)[] | undefined;
1097 }
1098
1099 interface PublicKeyCredentialCreationOptions {
1100     attestation?: AttestationConveyancePreference;
1101     authenticatorSelection?: AuthenticatorSelectionCriteria;
1102     challenge: BufferSource;
1103     excludeCredentials?: PublicKeyCredentialDescriptor[];
1104     extensions?: AuthenticationExtensionsClientInputs;
1105     pubKeyCredParams: PublicKeyCredentialParameters[];
1106     rp: PublicKeyCredentialRpEntity;
1107     timeout?: number;
1108     user: PublicKeyCredentialUserEntity;
1109 }
1110
1111 interface PublicKeyCredentialDescriptor {
1112     id: BufferSource;
1113     transports?: AuthenticatorTransport[];
1114     type: PublicKeyCredentialType;
1115 }
1116
1117 interface PublicKeyCredentialEntity {
1118     name: string;
1119 }
1120
1121 interface PublicKeyCredentialParameters {
1122     alg: COSEAlgorithmIdentifier;
1123     type: PublicKeyCredentialType;
1124 }
1125
1126 interface PublicKeyCredentialRequestOptions {
1127     allowCredentials?: PublicKeyCredentialDescriptor[];
1128     challenge: BufferSource;
1129     extensions?: AuthenticationExtensionsClientInputs;
1130     rpId?: string;
1131     timeout?: number;
1132     userVerification?: UserVerificationRequirement;
1133 }
1134
1135 interface PublicKeyCredentialRpEntity extends PublicKeyCredentialEntity {
1136     id?: string;
1137 }
1138
1139 interface PublicKeyCredentialUserEntity extends PublicKeyCredentialEntity {
1140     displayName: string;
1141     id: BufferSource;
1142 }
1143
1144 interface PushPermissionDescriptor extends PermissionDescriptor {
1145     name: "push";
1146     userVisibleOnly?: boolean;
1147 }
1148
1149 interface PushSubscriptionJSON {
1150     endpoint?: string;
1151     expirationTime?: number | null;
1152     keys?: Record<string, string>;
1153 }
1154
1155 interface PushSubscriptionOptionsInit {
1156     applicationServerKey?: BufferSource | string | null;
1157     userVisibleOnly?: boolean;
1158 }
1159
1160 interface QueuingStrategy<T = any> {
1161     highWaterMark?: number;
1162     size?: QueuingStrategySize<T>;
1163 }
1164
1165 interface QueuingStrategyInit {
1166     /**
1167      * Creates a new ByteLengthQueuingStrategy with the provided high water mark.
1168      *
1169      * Note that the provided high water mark will not be validated ahead of time. Instead, if it is negative, NaN, or not a number, the resulting ByteLengthQueuingStrategy will cause the corresponding stream constructor to throw.
1170      */
1171     highWaterMark: number;
1172 }
1173
1174 interface RTCAnswerOptions extends RTCOfferAnswerOptions {
1175 }
1176
1177 interface RTCCertificateExpiration {
1178     expires?: number;
1179 }
1180
1181 interface RTCConfiguration {
1182     bundlePolicy?: RTCBundlePolicy;
1183     certificates?: RTCCertificate[];
1184     iceCandidatePoolSize?: number;
1185     iceServers?: RTCIceServer[];
1186     iceTransportPolicy?: RTCIceTransportPolicy;
1187     peerIdentity?: string;
1188     rtcpMuxPolicy?: RTCRtcpMuxPolicy;
1189 }
1190
1191 interface RTCDTMFToneChangeEventInit extends EventInit {
1192     tone: string;
1193 }
1194
1195 interface RTCDataChannelEventInit extends EventInit {
1196     channel: RTCDataChannel;
1197 }
1198
1199 interface RTCDataChannelInit {
1200     id?: number;
1201     maxPacketLifeTime?: number;
1202     maxRetransmits?: number;
1203     negotiated?: boolean;
1204     ordered?: boolean;
1205     priority?: RTCPriorityType;
1206     protocol?: string;
1207 }
1208
1209 interface RTCDtlsFingerprint {
1210     algorithm?: string;
1211     value?: string;
1212 }
1213
1214 interface RTCDtlsParameters {
1215     fingerprints?: RTCDtlsFingerprint[];
1216     role?: RTCDtlsRole;
1217 }
1218
1219 interface RTCErrorEventInit extends EventInit {
1220     error: RTCError;
1221 }
1222
1223 interface RTCErrorInit {
1224     errorDetail: RTCErrorDetailType;
1225     httpRequestStatusCode?: number;
1226     receivedAlert?: number;
1227     sctpCauseCode?: number;
1228     sdpLineNumber?: number;
1229     sentAlert?: number;
1230 }
1231
1232 interface RTCIceCandidateAttributes extends RTCStats {
1233     addressSourceUrl?: string;
1234     candidateType?: RTCStatsIceCandidateType;
1235     ipAddress?: string;
1236     portNumber?: number;
1237     priority?: number;
1238     transport?: string;
1239 }
1240
1241 interface RTCIceCandidateComplete {
1242 }
1243
1244 interface RTCIceCandidateDictionary {
1245     foundation?: string;
1246     ip?: string;
1247     msMTurnSessionId?: string;
1248     port?: number;
1249     priority?: number;
1250     protocol?: RTCIceProtocol;
1251     relatedAddress?: string;
1252     relatedPort?: number;
1253     tcpType?: RTCIceTcpCandidateType;
1254     type?: RTCIceCandidateType;
1255 }
1256
1257 interface RTCIceCandidateInit {
1258     candidate?: string;
1259     sdpMLineIndex?: number | null;
1260     sdpMid?: string | null;
1261     usernameFragment?: string | null;
1262 }
1263
1264 interface RTCIceCandidatePair {
1265     local?: RTCIceCandidate;
1266     remote?: RTCIceCandidate;
1267 }
1268
1269 interface RTCIceCandidatePairStats extends RTCStats {
1270     availableIncomingBitrate?: number;
1271     availableOutgoingBitrate?: number;
1272     bytesDiscardedOnSend?: number;
1273     bytesReceived?: number;
1274     bytesSent?: number;
1275     circuitBreakerTriggerCount?: number;
1276     consentExpiredTimestamp?: number;
1277     consentRequestsSent?: number;
1278     currentRoundTripTime?: number;
1279     currentRtt?: number;
1280     firstRequestTimestamp?: number;
1281     lastPacketReceivedTimestamp?: number;
1282     lastPacketSentTimestamp?: number;
1283     lastRequestTimestamp?: number;
1284     lastResponseTimestamp?: number;
1285     localCandidateId?: string;
1286     nominated?: boolean;
1287     packetsDiscardedOnSend?: number;
1288     packetsReceived?: number;
1289     packetsSent?: number;
1290     priority?: number;
1291     remoteCandidateId?: string;
1292     requestsReceived?: number;
1293     requestsSent?: number;
1294     responsesReceived?: number;
1295     responsesSent?: number;
1296     retransmissionsReceived?: number;
1297     retransmissionsSent?: number;
1298     state?: RTCStatsIceCandidatePairState;
1299     totalRoundTripTime?: number;
1300     totalRtt?: number;
1301     transportId?: string;
1302 }
1303
1304 interface RTCIceGatherOptions {
1305     gatherPolicy?: RTCIceGatherPolicy;
1306     iceservers?: RTCIceServer[];
1307 }
1308
1309 interface RTCIceParameters {
1310     password?: string;
1311     usernameFragment?: string;
1312 }
1313
1314 interface RTCIceServer {
1315     credential?: string | RTCOAuthCredential;
1316     credentialType?: RTCIceCredentialType;
1317     urls: string | string[];
1318     username?: string;
1319 }
1320
1321 interface RTCIdentityProviderOptions {
1322     peerIdentity?: string;
1323     protocol?: string;
1324     usernameHint?: string;
1325 }
1326
1327 interface RTCInboundRTPStreamStats extends RTCRTPStreamStats {
1328     bytesReceived?: number;
1329     fractionLost?: number;
1330     jitter?: number;
1331     packetsLost?: number;
1332     packetsReceived?: number;
1333 }
1334
1335 interface RTCMediaStreamTrackStats extends RTCStats {
1336     audioLevel?: number;
1337     echoReturnLoss?: number;
1338     echoReturnLossEnhancement?: number;
1339     frameHeight?: number;
1340     frameWidth?: number;
1341     framesCorrupted?: number;
1342     framesDecoded?: number;
1343     framesDropped?: number;
1344     framesPerSecond?: number;
1345     framesReceived?: number;
1346     framesSent?: number;
1347     remoteSource?: boolean;
1348     ssrcIds?: string[];
1349     trackIdentifier?: string;
1350 }
1351
1352 interface RTCOAuthCredential {
1353     accessToken: string;
1354     macKey: string;
1355 }
1356
1357 interface RTCOfferAnswerOptions {
1358     voiceActivityDetection?: boolean;
1359 }
1360
1361 interface RTCOfferOptions extends RTCOfferAnswerOptions {
1362     iceRestart?: boolean;
1363     offerToReceiveAudio?: boolean;
1364     offerToReceiveVideo?: boolean;
1365 }
1366
1367 interface RTCOutboundRTPStreamStats extends RTCRTPStreamStats {
1368     bytesSent?: number;
1369     packetsSent?: number;
1370     roundTripTime?: number;
1371     targetBitrate?: number;
1372 }
1373
1374 interface RTCPeerConnectionIceErrorEventInit extends EventInit {
1375     errorCode: number;
1376     hostCandidate?: string;
1377     statusText?: string;
1378     url?: string;
1379 }
1380
1381 interface RTCPeerConnectionIceEventInit extends EventInit {
1382     candidate?: RTCIceCandidate | null;
1383     url?: string | null;
1384 }
1385
1386 interface RTCRTPStreamStats extends RTCStats {
1387     associateStatsId?: string;
1388     codecId?: string;
1389     firCount?: number;
1390     isRemote?: boolean;
1391     mediaTrackId?: string;
1392     mediaType?: string;
1393     nackCount?: number;
1394     pliCount?: number;
1395     sliCount?: number;
1396     ssrc?: string;
1397     transportId?: string;
1398 }
1399
1400 interface RTCRtcpFeedback {
1401     parameter?: string;
1402     type?: string;
1403 }
1404
1405 interface RTCRtcpParameters {
1406     cname?: string;
1407     reducedSize?: boolean;
1408 }
1409
1410 interface RTCRtpCapabilities {
1411     codecs: RTCRtpCodecCapability[];
1412     headerExtensions: RTCRtpHeaderExtensionCapability[];
1413 }
1414
1415 interface RTCRtpCodecCapability {
1416     channels?: number;
1417     clockRate: number;
1418     mimeType: string;
1419     sdpFmtpLine?: string;
1420 }
1421
1422 interface RTCRtpCodecParameters {
1423     channels?: number;
1424     clockRate: number;
1425     mimeType: string;
1426     payloadType: number;
1427     sdpFmtpLine?: string;
1428 }
1429
1430 interface RTCRtpCodingParameters {
1431     rid?: string;
1432 }
1433
1434 interface RTCRtpContributingSource {
1435     audioLevel?: number;
1436     rtpTimestamp: number;
1437     source: number;
1438     timestamp: number;
1439 }
1440
1441 interface RTCRtpDecodingParameters extends RTCRtpCodingParameters {
1442 }
1443
1444 interface RTCRtpEncodingParameters extends RTCRtpCodingParameters {
1445     active?: boolean;
1446     codecPayloadType?: number;
1447     dtx?: RTCDtxStatus;
1448     maxBitrate?: number;
1449     maxFramerate?: number;
1450     ptime?: number;
1451     scaleResolutionDownBy?: number;
1452 }
1453
1454 interface RTCRtpFecParameters {
1455     mechanism?: string;
1456     ssrc?: number;
1457 }
1458
1459 interface RTCRtpHeaderExtension {
1460     kind?: string;
1461     preferredEncrypt?: boolean;
1462     preferredId?: number;
1463     uri?: string;
1464 }
1465
1466 interface RTCRtpHeaderExtensionCapability {
1467     uri?: string;
1468 }
1469
1470 interface RTCRtpHeaderExtensionParameters {
1471     encrypted?: boolean;
1472     id: number;
1473     uri: string;
1474 }
1475
1476 interface RTCRtpParameters {
1477     codecs: RTCRtpCodecParameters[];
1478     headerExtensions: RTCRtpHeaderExtensionParameters[];
1479     rtcp: RTCRtcpParameters;
1480 }
1481
1482 interface RTCRtpReceiveParameters extends RTCRtpParameters {
1483     encodings: RTCRtpDecodingParameters[];
1484 }
1485
1486 interface RTCRtpRtxParameters {
1487     ssrc?: number;
1488 }
1489
1490 interface RTCRtpSendParameters extends RTCRtpParameters {
1491     degradationPreference?: RTCDegradationPreference;
1492     encodings: RTCRtpEncodingParameters[];
1493     priority?: RTCPriorityType;
1494     transactionId: string;
1495 }
1496
1497 interface RTCRtpSynchronizationSource extends RTCRtpContributingSource {
1498     voiceActivityFlag?: boolean;
1499 }
1500
1501 interface RTCRtpTransceiverInit {
1502     direction?: RTCRtpTransceiverDirection;
1503     sendEncodings?: RTCRtpEncodingParameters[];
1504     streams?: MediaStream[];
1505 }
1506
1507 interface RTCRtpUnhandled {
1508     muxId?: string;
1509     payloadType?: number;
1510     ssrc?: number;
1511 }
1512
1513 interface RTCSessionDescriptionInit {
1514     sdp?: string;
1515     type?: RTCSdpType;
1516 }
1517
1518 interface RTCSrtpKeyParam {
1519     keyMethod?: string;
1520     keySalt?: string;
1521     lifetime?: string;
1522     mkiLength?: number;
1523     mkiValue?: number;
1524 }
1525
1526 interface RTCSrtpSdesParameters {
1527     cryptoSuite?: string;
1528     keyParams?: RTCSrtpKeyParam[];
1529     sessionParams?: string[];
1530     tag?: number;
1531 }
1532
1533 interface RTCSsrcRange {
1534     max?: number;
1535     min?: number;
1536 }
1537
1538 interface RTCStats {
1539     id?: string;
1540     timestamp?: number;
1541     type?: RTCStatsType;
1542 }
1543
1544 interface RTCStatsEventInit extends EventInit {
1545     report: RTCStatsReport;
1546 }
1547
1548 interface RTCStatsReport {
1549 }
1550
1551 interface RTCTrackEventInit extends EventInit {
1552     receiver: RTCRtpReceiver;
1553     streams?: MediaStream[];
1554     track: MediaStreamTrack;
1555     transceiver: RTCRtpTransceiver;
1556 }
1557
1558 interface RTCTransportStats extends RTCStats {
1559     bytesReceived?: number;
1560     bytesSent?: number;
1561     dtlsCipher?: string;
1562     dtlsState?: RTCDtlsTransportState;
1563     iceRole?: RTCIceRole;
1564     localCertificateId?: string;
1565     packetsReceived?: number;
1566     packetsSent?: number;
1567     remoteCertificateId?: string;
1568     rtcpTransportStatsId?: string;
1569     selectedCandidatePairChanges?: number;
1570     selectedCandidatePairId?: string;
1571     srtpCipher?: string;
1572     tlsGroup?: string;
1573     tlsVersion?: string;
1574 }
1575
1576 interface ReadableStreamDefaultReadDoneResult {
1577     done: true;
1578     value?: undefined;
1579 }
1580
1581 interface ReadableStreamDefaultReadValueResult<T> {
1582     done: false;
1583     value: T;
1584 }
1585
1586 interface ReadableWritablePair<R = any, W = any> {
1587     readable: ReadableStream<R>;
1588     /**
1589      * Provides a convenient, chainable way of piping this readable stream through a transform stream (or any other { writable, readable } pair). It simply pipes the stream into the writable side of the supplied pair, and returns the readable side for further use.
1590      *
1591      * Piping a stream will lock it for the duration of the pipe, preventing any other consumer from acquiring a reader.
1592      */
1593     writable: WritableStream<W>;
1594 }
1595
1596 interface RegistrationOptions {
1597     scope?: string;
1598     type?: WorkerType;
1599     updateViaCache?: ServiceWorkerUpdateViaCache;
1600 }
1601
1602 interface RequestInit {
1603     /**
1604      * A BodyInit object or null to set request's body.
1605      */
1606     body?: BodyInit | null;
1607     /**
1608      * A string indicating how the request will interact with the browser's cache to set request's cache.
1609      */
1610     cache?: RequestCache;
1611     /**
1612      * 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.
1613      */
1614     credentials?: RequestCredentials;
1615     /**
1616      * A Headers object, an object literal, or an array of two-item arrays to set request's headers.
1617      */
1618     headers?: HeadersInit;
1619     /**
1620      * A cryptographic hash of the resource to be fetched by request. Sets request's integrity.
1621      */
1622     integrity?: string;
1623     /**
1624      * A boolean to set request's keepalive.
1625      */
1626     keepalive?: boolean;
1627     /**
1628      * A string to set request's method.
1629      */
1630     method?: string;
1631     /**
1632      * A string to indicate whether the request will use CORS, or will be restricted to same-origin URLs. Sets request's mode.
1633      */
1634     mode?: RequestMode;
1635     /**
1636      * 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.
1637      */
1638     redirect?: RequestRedirect;
1639     /**
1640      * A string whose value is a same-origin URL, "about:client", or the empty string, to set request's referrer.
1641      */
1642     referrer?: string;
1643     /**
1644      * A referrer policy to set request's referrerPolicy.
1645      */
1646     referrerPolicy?: ReferrerPolicy;
1647     /**
1648      * An AbortSignal to set request's signal.
1649      */
1650     signal?: AbortSignal | null;
1651     /**
1652      * Can only be null. Used to disassociate request from any Window.
1653      */
1654     window?: any;
1655 }
1656
1657 interface ResizeObserverOptions {
1658     box?: ResizeObserverBoxOptions;
1659 }
1660
1661 interface ResponseInit {
1662     headers?: HeadersInit;
1663     status?: number;
1664     statusText?: string;
1665 }
1666
1667 interface RsaHashedImportParams extends Algorithm {
1668     hash: HashAlgorithmIdentifier;
1669 }
1670
1671 interface RsaHashedKeyAlgorithm extends RsaKeyAlgorithm {
1672     hash: KeyAlgorithm;
1673 }
1674
1675 interface RsaHashedKeyGenParams extends RsaKeyGenParams {
1676     hash: HashAlgorithmIdentifier;
1677 }
1678
1679 interface RsaKeyAlgorithm extends KeyAlgorithm {
1680     modulusLength: number;
1681     publicExponent: BigInteger;
1682 }
1683
1684 interface RsaKeyGenParams extends Algorithm {
1685     modulusLength: number;
1686     publicExponent: BigInteger;
1687 }
1688
1689 interface RsaOaepParams extends Algorithm {
1690     label?: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;
1691 }
1692
1693 interface RsaOtherPrimesInfo {
1694     d?: string;
1695     r?: string;
1696     t?: string;
1697 }
1698
1699 interface RsaPssParams extends Algorithm {
1700     saltLength: number;
1701 }
1702
1703 interface SVGBoundingBoxOptions {
1704     clipped?: boolean;
1705     fill?: boolean;
1706     markers?: boolean;
1707     stroke?: boolean;
1708 }
1709
1710 interface ScopedCredentialDescriptor {
1711     id: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer | null;
1712     transports?: Transport[];
1713     type: ScopedCredentialType;
1714 }
1715
1716 interface ScopedCredentialOptions {
1717     excludeList?: ScopedCredentialDescriptor[];
1718     extensions?: WebAuthnExtensions;
1719     rpId?: string;
1720     timeoutSeconds?: number;
1721 }
1722
1723 interface ScopedCredentialParameters {
1724     algorithm: string | Algorithm;
1725     type: ScopedCredentialType;
1726 }
1727
1728 interface ScrollIntoViewOptions extends ScrollOptions {
1729     block?: ScrollLogicalPosition;
1730     inline?: ScrollLogicalPosition;
1731 }
1732
1733 interface ScrollOptions {
1734     behavior?: ScrollBehavior;
1735 }
1736
1737 interface ScrollToOptions extends ScrollOptions {
1738     left?: number;
1739     top?: number;
1740 }
1741
1742 interface SecurityPolicyViolationEventInit extends EventInit {
1743     blockedURI?: string;
1744     columnNumber?: number;
1745     documentURI?: string;
1746     effectiveDirective?: string;
1747     lineNumber?: number;
1748     originalPolicy?: string;
1749     referrer?: string;
1750     sourceFile?: string;
1751     statusCode?: number;
1752     violatedDirective?: string;
1753 }
1754
1755 interface ServiceWorkerMessageEventInit extends EventInit {
1756     data?: any;
1757     lastEventId?: string;
1758     origin?: string;
1759     ports?: MessagePort[] | null;
1760     source?: ServiceWorker | MessagePort | null;
1761 }
1762
1763 interface ShadowRootInit {
1764     delegatesFocus?: boolean;
1765     mode: ShadowRootMode;
1766 }
1767
1768 interface ShareData {
1769     text?: string;
1770     title?: string;
1771     url?: string;
1772 }
1773
1774 interface SpeechRecognitionErrorEventInit extends EventInit {
1775     error: SpeechRecognitionErrorCode;
1776     message?: string;
1777 }
1778
1779 interface SpeechRecognitionEventInit extends EventInit {
1780     resultIndex?: number;
1781     results: SpeechRecognitionResultList;
1782 }
1783
1784 interface SpeechSynthesisErrorEventInit extends SpeechSynthesisEventInit {
1785     error: SpeechSynthesisErrorCode;
1786 }
1787
1788 interface SpeechSynthesisEventInit extends EventInit {
1789     charIndex?: number;
1790     charLength?: number;
1791     elapsedTime?: number;
1792     name?: string;
1793     utterance: SpeechSynthesisUtterance;
1794 }
1795
1796 interface StaticRangeInit {
1797     endContainer: Node;
1798     endOffset: number;
1799     startContainer: Node;
1800     startOffset: number;
1801 }
1802
1803 interface StereoPannerOptions extends AudioNodeOptions {
1804     pan?: number;
1805 }
1806
1807 interface StorageEstimate {
1808     quota?: number;
1809     usage?: number;
1810 }
1811
1812 interface StorageEventInit extends EventInit {
1813     key?: string | null;
1814     newValue?: string | null;
1815     oldValue?: string | null;
1816     storageArea?: Storage | null;
1817     url?: string;
1818 }
1819
1820 interface StoreExceptionsInformation extends ExceptionInformation {
1821     detailURI?: string | null;
1822     explanationString?: string | null;
1823     siteName?: string | null;
1824 }
1825
1826 interface StoreSiteSpecificExceptionsInformation extends StoreExceptionsInformation {
1827     arrayOfDomainStrings?: string[];
1828 }
1829
1830 interface StreamPipeOptions {
1831     preventAbort?: boolean;
1832     preventCancel?: boolean;
1833     /**
1834      * Pipes this readable stream to a given writable stream destination. The way in which the piping process behaves under various error conditions can be customized with a number of passed options. It returns a promise that fulfills when the piping process completes successfully, or rejects if any errors were encountered.
1835      *
1836      * Piping a stream will lock it for the duration of the pipe, preventing any other consumer from acquiring a reader.
1837      *
1838      * Errors and closures of the source and destination streams propagate as follows:
1839      *
1840      * An error in this source readable stream will abort destination, unless preventAbort is truthy. The returned promise will be rejected with the source's error, or with any error that occurs during aborting the destination.
1841      *
1842      * An error in destination will cancel this source readable stream, unless preventCancel is truthy. The returned promise will be rejected with the destination's error, or with any error that occurs during canceling the source.
1843      *
1844      * When this source readable stream closes, destination will be closed, unless preventClose is truthy. The returned promise will be fulfilled once this process completes, unless an error is encountered while closing the destination, in which case it will be rejected with that error.
1845      *
1846      * If destination starts out closed or closing, this source readable stream will be canceled, unless preventCancel is true. The returned promise will be rejected with an error indicating piping to a closed stream failed, or with any error that occurs during canceling the source.
1847      *
1848      * The signal option can be set to an AbortSignal to allow aborting an ongoing pipe operation via the corresponding AbortController. In this case, this source readable stream will be canceled, and destination aborted, unless the respective options preventCancel or preventAbort are set.
1849      */
1850     preventClose?: boolean;
1851     signal?: AbortSignal;
1852 }
1853
1854 interface TextDecodeOptions {
1855     stream?: boolean;
1856 }
1857
1858 interface TextDecoderOptions {
1859     fatal?: boolean;
1860     ignoreBOM?: boolean;
1861 }
1862
1863 interface TextEncoderEncodeIntoResult {
1864     read?: number;
1865     written?: number;
1866 }
1867
1868 interface TouchEventInit extends EventModifierInit {
1869     changedTouches?: Touch[];
1870     targetTouches?: Touch[];
1871     touches?: Touch[];
1872 }
1873
1874 interface TouchInit {
1875     altitudeAngle?: number;
1876     azimuthAngle?: number;
1877     clientX?: number;
1878     clientY?: number;
1879     force?: number;
1880     identifier: number;
1881     pageX?: number;
1882     pageY?: number;
1883     radiusX?: number;
1884     radiusY?: number;
1885     rotationAngle?: number;
1886     screenX?: number;
1887     screenY?: number;
1888     target: EventTarget;
1889     touchType?: TouchType;
1890 }
1891
1892 interface TrackEventInit extends EventInit {
1893     track?: TextTrack | null;
1894 }
1895
1896 interface Transformer<I = any, O = any> {
1897     flush?: TransformerFlushCallback<O>;
1898     readableType?: undefined;
1899     start?: TransformerStartCallback<O>;
1900     transform?: TransformerTransformCallback<I, O>;
1901     writableType?: undefined;
1902 }
1903
1904 interface TransitionEventInit extends EventInit {
1905     elapsedTime?: number;
1906     propertyName?: string;
1907     pseudoElement?: string;
1908 }
1909
1910 interface UIEventInit extends EventInit {
1911     detail?: number;
1912     view?: Window | null;
1913 }
1914
1915 interface ULongRange {
1916     max?: number;
1917     min?: number;
1918 }
1919
1920 interface UnderlyingSink<W = any> {
1921     abort?: UnderlyingSinkAbortCallback;
1922     close?: UnderlyingSinkCloseCallback;
1923     start?: UnderlyingSinkStartCallback;
1924     type?: undefined;
1925     write?: UnderlyingSinkWriteCallback<W>;
1926 }
1927
1928 interface UnderlyingSource<R = any> {
1929     cancel?: UnderlyingSourceCancelCallback;
1930     pull?: UnderlyingSourcePullCallback<R>;
1931     start?: UnderlyingSourceStartCallback<R>;
1932     type?: undefined;
1933 }
1934
1935 interface VRDisplayEventInit extends EventInit {
1936     display: VRDisplay;
1937     reason?: VRDisplayEventReason;
1938 }
1939
1940 interface VRLayer {
1941     leftBounds?: number[] | Float32Array | null;
1942     rightBounds?: number[] | Float32Array | null;
1943     source?: HTMLCanvasElement | null;
1944 }
1945
1946 interface VRStageParameters {
1947     sittingToStandingTransform?: Float32Array;
1948     sizeX?: number;
1949     sizeY?: number;
1950 }
1951
1952 interface WaveShaperOptions extends AudioNodeOptions {
1953     curve?: number[] | Float32Array;
1954     oversample?: OverSampleType;
1955 }
1956
1957 interface WebAuthnExtensions {
1958 }
1959
1960 interface WebGLContextAttributes {
1961     alpha?: boolean;
1962     antialias?: boolean;
1963     depth?: boolean;
1964     desynchronized?: boolean;
1965     failIfMajorPerformanceCaveat?: boolean;
1966     powerPreference?: WebGLPowerPreference;
1967     premultipliedAlpha?: boolean;
1968     preserveDrawingBuffer?: boolean;
1969     stencil?: boolean;
1970 }
1971
1972 interface WebGLContextEventInit extends EventInit {
1973     statusMessage?: string;
1974 }
1975
1976 interface WheelEventInit extends MouseEventInit {
1977     deltaMode?: number;
1978     deltaX?: number;
1979     deltaY?: number;
1980     deltaZ?: number;
1981 }
1982
1983 interface WorkerOptions {
1984     credentials?: RequestCredentials;
1985     name?: string;
1986     type?: WorkerType;
1987 }
1988
1989 interface WorkletOptions {
1990     credentials?: RequestCredentials;
1991 }
1992
1993 interface EventListener {
1994     (evt: Event): void;
1995 }
1996
1997 type XPathNSResolver = ((prefix: string | null) => string | null) | { lookupNamespaceURI(prefix: string | null): string | null; };
1998
1999 /** 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. */
2000 interface ANGLE_instanced_arrays {
2001     drawArraysInstancedANGLE(mode: GLenum, first: GLint, count: GLsizei, primcount: GLsizei): void;
2002     drawElementsInstancedANGLE(mode: GLenum, count: GLsizei, type: GLenum, offset: GLintptr, primcount: GLsizei): void;
2003     vertexAttribDivisorANGLE(index: GLuint, divisor: GLuint): void;
2004     readonly VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE: GLenum;
2005 }
2006
2007 /** A controller object that allows you to abort one or more DOM requests as and when desired. */
2008 interface AbortController {
2009     /**
2010      * Returns the AbortSignal object associated with this object.
2011      */
2012     readonly signal: AbortSignal;
2013     /**
2014      * 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.
2015      */
2016     abort(): void;
2017 }
2018
2019 declare var AbortController: {
2020     prototype: AbortController;
2021     new(): AbortController;
2022 };
2023
2024 interface AbortSignalEventMap {
2025     "abort": Event;
2026 }
2027
2028 /** 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. */
2029 interface AbortSignal extends EventTarget {
2030     /**
2031      * Returns true if this AbortSignal's AbortController has signaled to abort, and false otherwise.
2032      */
2033     readonly aborted: boolean;
2034     onabort: ((this: AbortSignal, ev: Event) => any) | null;
2035     addEventListener<K extends keyof AbortSignalEventMap>(type: K, listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
2036     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
2037     removeEventListener<K extends keyof AbortSignalEventMap>(type: K, listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
2038     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
2039 }
2040
2041 declare var AbortSignal: {
2042     prototype: AbortSignal;
2043     new(): AbortSignal;
2044 };
2045
2046 interface AbstractRange {
2047     /**
2048      * Returns true if range is collapsed, and false otherwise.
2049      */
2050     readonly collapsed: boolean;
2051     /**
2052      * Returns range's end node.
2053      */
2054     readonly endContainer: Node;
2055     /**
2056      * Returns range's end offset.
2057      */
2058     readonly endOffset: number;
2059     /**
2060      * Returns range's start node.
2061      */
2062     readonly startContainer: Node;
2063     /**
2064      * Returns range's start offset.
2065      */
2066     readonly startOffset: number;
2067 }
2068
2069 declare var AbstractRange: {
2070     prototype: AbstractRange;
2071     new(): AbstractRange;
2072 };
2073
2074 interface AbstractWorkerEventMap {
2075     "error": ErrorEvent;
2076 }
2077
2078 interface AbstractWorker {
2079     onerror: ((this: AbstractWorker, ev: ErrorEvent) => any) | null;
2080     addEventListener<K extends keyof AbstractWorkerEventMap>(type: K, listener: (this: AbstractWorker, ev: AbstractWorkerEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
2081     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
2082     removeEventListener<K extends keyof AbstractWorkerEventMap>(type: K, listener: (this: AbstractWorker, ev: AbstractWorkerEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
2083     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
2084 }
2085
2086 interface AesCfbParams extends Algorithm {
2087     iv: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;
2088 }
2089
2090 interface AesCmacParams extends Algorithm {
2091     length: number;
2092 }
2093
2094 /** 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. */
2095 interface AnalyserNode extends AudioNode {
2096     fftSize: number;
2097     readonly frequencyBinCount: number;
2098     maxDecibels: number;
2099     minDecibels: number;
2100     smoothingTimeConstant: number;
2101     getByteFrequencyData(array: Uint8Array): void;
2102     getByteTimeDomainData(array: Uint8Array): void;
2103     getFloatFrequencyData(array: Float32Array): void;
2104     getFloatTimeDomainData(array: Float32Array): void;
2105 }
2106
2107 declare var AnalyserNode: {
2108     prototype: AnalyserNode;
2109     new(context: BaseAudioContext, options?: AnalyserOptions): AnalyserNode;
2110 };
2111
2112 interface Animatable {
2113     animate(keyframes: Keyframe[] | PropertyIndexedKeyframes | null, options?: number | KeyframeAnimationOptions): Animation;
2114     getAnimations(): Animation[];
2115 }
2116
2117 interface AnimationEventMap {
2118     "cancel": AnimationPlaybackEvent;
2119     "finish": AnimationPlaybackEvent;
2120 }
2121
2122 interface Animation extends EventTarget {
2123     currentTime: number | null;
2124     effect: AnimationEffect | null;
2125     readonly finished: Promise<Animation>;
2126     id: string;
2127     oncancel: ((this: Animation, ev: AnimationPlaybackEvent) => any) | null;
2128     onfinish: ((this: Animation, ev: AnimationPlaybackEvent) => any) | null;
2129     readonly pending: boolean;
2130     readonly playState: AnimationPlayState;
2131     playbackRate: number;
2132     readonly ready: Promise<Animation>;
2133     startTime: number | null;
2134     timeline: AnimationTimeline | null;
2135     cancel(): void;
2136     finish(): void;
2137     pause(): void;
2138     play(): void;
2139     reverse(): void;
2140     updatePlaybackRate(playbackRate: number): void;
2141     addEventListener<K extends keyof AnimationEventMap>(type: K, listener: (this: Animation, ev: AnimationEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
2142     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
2143     removeEventListener<K extends keyof AnimationEventMap>(type: K, listener: (this: Animation, ev: AnimationEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
2144     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
2145 }
2146
2147 declare var Animation: {
2148     prototype: Animation;
2149     new(effect?: AnimationEffect | null, timeline?: AnimationTimeline | null): Animation;
2150 };
2151
2152 interface AnimationEffect {
2153     getComputedTiming(): ComputedEffectTiming;
2154     getTiming(): EffectTiming;
2155     updateTiming(timing?: OptionalEffectTiming): void;
2156 }
2157
2158 declare var AnimationEffect: {
2159     prototype: AnimationEffect;
2160     new(): AnimationEffect;
2161 };
2162
2163 /** Events providing information related to animations. */
2164 interface AnimationEvent extends Event {
2165     readonly animationName: string;
2166     readonly elapsedTime: number;
2167     readonly pseudoElement: string;
2168 }
2169
2170 declare var AnimationEvent: {
2171     prototype: AnimationEvent;
2172     new(type: string, animationEventInitDict?: AnimationEventInit): AnimationEvent;
2173 };
2174
2175 interface AnimationFrameProvider {
2176     cancelAnimationFrame(handle: number): void;
2177     requestAnimationFrame(callback: FrameRequestCallback): number;
2178 }
2179
2180 interface AnimationPlaybackEvent extends Event {
2181     readonly currentTime: number | null;
2182     readonly timelineTime: number | null;
2183 }
2184
2185 declare var AnimationPlaybackEvent: {
2186     prototype: AnimationPlaybackEvent;
2187     new(type: string, eventInitDict?: AnimationPlaybackEventInit): AnimationPlaybackEvent;
2188 };
2189
2190 interface AnimationTimeline {
2191     readonly currentTime: number | null;
2192 }
2193
2194 declare var AnimationTimeline: {
2195     prototype: AnimationTimeline;
2196     new(): AnimationTimeline;
2197 };
2198
2199 interface ApplicationCacheEventMap {
2200     "cached": Event;
2201     "checking": Event;
2202     "downloading": Event;
2203     "error": Event;
2204     "noupdate": Event;
2205     "obsolete": Event;
2206     "progress": ProgressEvent<ApplicationCache>;
2207     "updateready": Event;
2208 }
2209
2210 interface ApplicationCache extends EventTarget {
2211     /** @deprecated */
2212     oncached: ((this: ApplicationCache, ev: Event) => any) | null;
2213     /** @deprecated */
2214     onchecking: ((this: ApplicationCache, ev: Event) => any) | null;
2215     /** @deprecated */
2216     ondownloading: ((this: ApplicationCache, ev: Event) => any) | null;
2217     /** @deprecated */
2218     onerror: ((this: ApplicationCache, ev: Event) => any) | null;
2219     /** @deprecated */
2220     onnoupdate: ((this: ApplicationCache, ev: Event) => any) | null;
2221     /** @deprecated */
2222     onobsolete: ((this: ApplicationCache, ev: Event) => any) | null;
2223     /** @deprecated */
2224     onprogress: ((this: ApplicationCache, ev: ProgressEvent<ApplicationCache>) => any) | null;
2225     /** @deprecated */
2226     onupdateready: ((this: ApplicationCache, ev: Event) => any) | null;
2227     /** @deprecated */
2228     readonly status: number;
2229     /** @deprecated */
2230     abort(): void;
2231     /** @deprecated */
2232     swapCache(): void;
2233     /** @deprecated */
2234     update(): void;
2235     readonly CHECKING: number;
2236     readonly DOWNLOADING: number;
2237     readonly IDLE: number;
2238     readonly OBSOLETE: number;
2239     readonly UNCACHED: number;
2240     readonly UPDATEREADY: number;
2241     addEventListener<K extends keyof ApplicationCacheEventMap>(type: K, listener: (this: ApplicationCache, ev: ApplicationCacheEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
2242     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
2243     removeEventListener<K extends keyof ApplicationCacheEventMap>(type: K, listener: (this: ApplicationCache, ev: ApplicationCacheEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
2244     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
2245 }
2246
2247 declare var ApplicationCache: {
2248     prototype: ApplicationCache;
2249     new(): ApplicationCache;
2250     readonly CHECKING: number;
2251     readonly DOWNLOADING: number;
2252     readonly IDLE: number;
2253     readonly OBSOLETE: number;
2254     readonly UNCACHED: number;
2255     readonly UPDATEREADY: number;
2256 };
2257
2258 /** 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. */
2259 interface Attr extends Node {
2260     readonly localName: string;
2261     readonly name: string;
2262     readonly namespaceURI: string | null;
2263     readonly ownerDocument: Document;
2264     readonly ownerElement: Element | null;
2265     readonly prefix: string | null;
2266     readonly specified: boolean;
2267     value: string;
2268 }
2269
2270 declare var Attr: {
2271     prototype: Attr;
2272     new(): Attr;
2273 };
2274
2275 /** 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. */
2276 interface AudioBuffer {
2277     readonly duration: number;
2278     readonly length: number;
2279     readonly numberOfChannels: number;
2280     readonly sampleRate: number;
2281     copyFromChannel(destination: Float32Array, channelNumber: number, bufferOffset?: number): void;
2282     copyToChannel(source: Float32Array, channelNumber: number, bufferOffset?: number): void;
2283     getChannelData(channel: number): Float32Array;
2284 }
2285
2286 declare var AudioBuffer: {
2287     prototype: AudioBuffer;
2288     new(options: AudioBufferOptions): AudioBuffer;
2289 };
2290
2291 /** 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. */
2292 interface AudioBufferSourceNode extends AudioScheduledSourceNode {
2293     buffer: AudioBuffer | null;
2294     readonly detune: AudioParam;
2295     loop: boolean;
2296     loopEnd: number;
2297     loopStart: number;
2298     readonly playbackRate: AudioParam;
2299     start(when?: number, offset?: number, duration?: number): void;
2300     addEventListener<K extends keyof AudioScheduledSourceNodeEventMap>(type: K, listener: (this: AudioBufferSourceNode, ev: AudioScheduledSourceNodeEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
2301     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
2302     removeEventListener<K extends keyof AudioScheduledSourceNodeEventMap>(type: K, listener: (this: AudioBufferSourceNode, ev: AudioScheduledSourceNodeEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
2303     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
2304 }
2305
2306 declare var AudioBufferSourceNode: {
2307     prototype: AudioBufferSourceNode;
2308     new(context: BaseAudioContext, options?: AudioBufferSourceOptions): AudioBufferSourceNode;
2309 };
2310
2311 /** An audio-processing graph built from audio modules linked together, each represented by an AudioNode. */
2312 interface AudioContext extends BaseAudioContext {
2313     readonly baseLatency: number;
2314     readonly outputLatency: number;
2315     close(): Promise<void>;
2316     createMediaElementSource(mediaElement: HTMLMediaElement): MediaElementAudioSourceNode;
2317     createMediaStreamDestination(): MediaStreamAudioDestinationNode;
2318     createMediaStreamSource(mediaStream: MediaStream): MediaStreamAudioSourceNode;
2319     createMediaStreamTrackSource(mediaStreamTrack: MediaStreamTrack): MediaStreamTrackAudioSourceNode;
2320     getOutputTimestamp(): AudioTimestamp;
2321     resume(): Promise<void>;
2322     suspend(): Promise<void>;
2323     addEventListener<K extends keyof BaseAudioContextEventMap>(type: K, listener: (this: AudioContext, ev: BaseAudioContextEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
2324     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
2325     removeEventListener<K extends keyof BaseAudioContextEventMap>(type: K, listener: (this: AudioContext, ev: BaseAudioContextEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
2326     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
2327 }
2328
2329 declare var AudioContext: {
2330     prototype: AudioContext;
2331     new(contextOptions?: AudioContextOptions): AudioContext;
2332 };
2333
2334 /** 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. */
2335 interface AudioDestinationNode extends AudioNode {
2336     readonly maxChannelCount: number;
2337 }
2338
2339 declare var AudioDestinationNode: {
2340     prototype: AudioDestinationNode;
2341     new(): AudioDestinationNode;
2342 };
2343
2344 /** 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. */
2345 interface AudioListener {
2346     readonly forwardX: AudioParam;
2347     readonly forwardY: AudioParam;
2348     readonly forwardZ: AudioParam;
2349     readonly positionX: AudioParam;
2350     readonly positionY: AudioParam;
2351     readonly positionZ: AudioParam;
2352     readonly upX: AudioParam;
2353     readonly upY: AudioParam;
2354     readonly upZ: AudioParam;
2355     /** @deprecated */
2356     setOrientation(x: number, y: number, z: number, xUp: number, yUp: number, zUp: number): void;
2357     /** @deprecated */
2358     setPosition(x: number, y: number, z: number): void;
2359 }
2360
2361 declare var AudioListener: {
2362     prototype: AudioListener;
2363     new(): AudioListener;
2364 };
2365
2366 /** A generic interface for representing an audio processing module. Examples include: */
2367 interface AudioNode extends EventTarget {
2368     channelCount: number;
2369     channelCountMode: ChannelCountMode;
2370     channelInterpretation: ChannelInterpretation;
2371     readonly context: BaseAudioContext;
2372     readonly numberOfInputs: number;
2373     readonly numberOfOutputs: number;
2374     connect(destinationNode: AudioNode, output?: number, input?: number): AudioNode;
2375     connect(destinationParam: AudioParam, output?: number): void;
2376     disconnect(): void;
2377     disconnect(output: number): void;
2378     disconnect(destinationNode: AudioNode): void;
2379     disconnect(destinationNode: AudioNode, output: number): void;
2380     disconnect(destinationNode: AudioNode, output: number, input: number): void;
2381     disconnect(destinationParam: AudioParam): void;
2382     disconnect(destinationParam: AudioParam, output: number): void;
2383 }
2384
2385 declare var AudioNode: {
2386     prototype: AudioNode;
2387     new(): AudioNode;
2388 };
2389
2390 /** The Web Audio API's AudioParam interface represents an audio-related parameter, usually a parameter of an AudioNode (such as GainNode.gain). */
2391 interface AudioParam {
2392     automationRate: AutomationRate;
2393     readonly defaultValue: number;
2394     readonly maxValue: number;
2395     readonly minValue: number;
2396     value: number;
2397     cancelAndHoldAtTime(cancelTime: number): AudioParam;
2398     cancelScheduledValues(cancelTime: number): AudioParam;
2399     exponentialRampToValueAtTime(value: number, endTime: number): AudioParam;
2400     linearRampToValueAtTime(value: number, endTime: number): AudioParam;
2401     setTargetAtTime(target: number, startTime: number, timeConstant: number): AudioParam;
2402     setValueAtTime(value: number, startTime: number): AudioParam;
2403     setValueCurveAtTime(values: number[] | Float32Array, startTime: number, duration: number): AudioParam;
2404 }
2405
2406 declare var AudioParam: {
2407     prototype: AudioParam;
2408     new(): AudioParam;
2409 };
2410
2411 interface AudioParamMap {
2412     forEach(callbackfn: (value: AudioParam, key: string, parent: AudioParamMap) => void, thisArg?: any): void;
2413 }
2414
2415 declare var AudioParamMap: {
2416     prototype: AudioParamMap;
2417     new(): AudioParamMap;
2418 };
2419
2420 /** The Web Audio API events that occur when a ScriptProcessorNode input buffer is ready to be processed.
2421  * @deprecated As of the August 29 2014 Web Audio API spec publication, this feature has been marked as deprecated, and is soon to be replaced by AudioWorklet.
2422  */
2423 interface AudioProcessingEvent extends Event {
2424     readonly inputBuffer: AudioBuffer;
2425     readonly outputBuffer: AudioBuffer;
2426     readonly playbackTime: number;
2427 }
2428
2429 declare var AudioProcessingEvent: {
2430     prototype: AudioProcessingEvent;
2431     new(type: string, eventInitDict: AudioProcessingEventInit): AudioProcessingEvent;
2432 };
2433
2434 interface AudioScheduledSourceNodeEventMap {
2435     "ended": Event;
2436 }
2437
2438 interface AudioScheduledSourceNode extends AudioNode {
2439     onended: ((this: AudioScheduledSourceNode, ev: Event) => any) | null;
2440     start(when?: number): void;
2441     stop(when?: number): void;
2442     addEventListener<K extends keyof AudioScheduledSourceNodeEventMap>(type: K, listener: (this: AudioScheduledSourceNode, ev: AudioScheduledSourceNodeEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
2443     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
2444     removeEventListener<K extends keyof AudioScheduledSourceNodeEventMap>(type: K, listener: (this: AudioScheduledSourceNode, ev: AudioScheduledSourceNodeEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
2445     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
2446 }
2447
2448 declare var AudioScheduledSourceNode: {
2449     prototype: AudioScheduledSourceNode;
2450     new(): AudioScheduledSourceNode;
2451 };
2452
2453 interface AudioWorklet extends Worklet {
2454 }
2455
2456 declare var AudioWorklet: {
2457     prototype: AudioWorklet;
2458     new(): AudioWorklet;
2459 };
2460
2461 interface AudioWorkletNodeEventMap {
2462     "processorerror": Event;
2463 }
2464
2465 interface AudioWorkletNode extends AudioNode {
2466     onprocessorerror: ((this: AudioWorkletNode, ev: Event) => any) | null;
2467     readonly parameters: AudioParamMap;
2468     readonly port: MessagePort;
2469     addEventListener<K extends keyof AudioWorkletNodeEventMap>(type: K, listener: (this: AudioWorkletNode, ev: AudioWorkletNodeEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
2470     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
2471     removeEventListener<K extends keyof AudioWorkletNodeEventMap>(type: K, listener: (this: AudioWorkletNode, ev: AudioWorkletNodeEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
2472     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
2473 }
2474
2475 declare var AudioWorkletNode: {
2476     prototype: AudioWorkletNode;
2477     new(context: BaseAudioContext, name: string, options?: AudioWorkletNodeOptions): AudioWorkletNode;
2478 };
2479
2480 interface AuthenticatorAssertionResponse extends AuthenticatorResponse {
2481     readonly authenticatorData: ArrayBuffer;
2482     readonly signature: ArrayBuffer;
2483     readonly userHandle: ArrayBuffer | null;
2484 }
2485
2486 declare var AuthenticatorAssertionResponse: {
2487     prototype: AuthenticatorAssertionResponse;
2488     new(): AuthenticatorAssertionResponse;
2489 };
2490
2491 interface AuthenticatorAttestationResponse extends AuthenticatorResponse {
2492     readonly attestationObject: ArrayBuffer;
2493 }
2494
2495 declare var AuthenticatorAttestationResponse: {
2496     prototype: AuthenticatorAttestationResponse;
2497     new(): AuthenticatorAttestationResponse;
2498 };
2499
2500 interface AuthenticatorResponse {
2501     readonly clientDataJSON: ArrayBuffer;
2502 }
2503
2504 declare var AuthenticatorResponse: {
2505     prototype: AuthenticatorResponse;
2506     new(): AuthenticatorResponse;
2507 };
2508
2509 interface BarProp {
2510     readonly visible: boolean;
2511 }
2512
2513 declare var BarProp: {
2514     prototype: BarProp;
2515     new(): BarProp;
2516 };
2517
2518 interface BaseAudioContextEventMap {
2519     "statechange": Event;
2520 }
2521
2522 interface BaseAudioContext extends EventTarget {
2523     readonly audioWorklet: AudioWorklet;
2524     readonly currentTime: number;
2525     readonly destination: AudioDestinationNode;
2526     readonly listener: AudioListener;
2527     onstatechange: ((this: BaseAudioContext, ev: Event) => any) | null;
2528     readonly sampleRate: number;
2529     readonly state: AudioContextState;
2530     createAnalyser(): AnalyserNode;
2531     createBiquadFilter(): BiquadFilterNode;
2532     createBuffer(numberOfChannels: number, length: number, sampleRate: number): AudioBuffer;
2533     createBufferSource(): AudioBufferSourceNode;
2534     createChannelMerger(numberOfInputs?: number): ChannelMergerNode;
2535     createChannelSplitter(numberOfOutputs?: number): ChannelSplitterNode;
2536     createConstantSource(): ConstantSourceNode;
2537     createConvolver(): ConvolverNode;
2538     createDelay(maxDelayTime?: number): DelayNode;
2539     createDynamicsCompressor(): DynamicsCompressorNode;
2540     createGain(): GainNode;
2541     createIIRFilter(feedforward: number[], feedback: number[]): IIRFilterNode;
2542     createOscillator(): OscillatorNode;
2543     createPanner(): PannerNode;
2544     createPeriodicWave(real: number[] | Float32Array, imag: number[] | Float32Array, constraints?: PeriodicWaveConstraints): PeriodicWave;
2545     createScriptProcessor(bufferSize?: number, numberOfInputChannels?: number, numberOfOutputChannels?: number): ScriptProcessorNode;
2546     createStereoPanner(): StereoPannerNode;
2547     createWaveShaper(): WaveShaperNode;
2548     decodeAudioData(audioData: ArrayBuffer, successCallback?: DecodeSuccessCallback | null, errorCallback?: DecodeErrorCallback | null): Promise<AudioBuffer>;
2549     addEventListener<K extends keyof BaseAudioContextEventMap>(type: K, listener: (this: BaseAudioContext, ev: BaseAudioContextEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
2550     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
2551     removeEventListener<K extends keyof BaseAudioContextEventMap>(type: K, listener: (this: BaseAudioContext, ev: BaseAudioContextEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
2552     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
2553 }
2554
2555 declare var BaseAudioContext: {
2556     prototype: BaseAudioContext;
2557     new(): BaseAudioContext;
2558 };
2559
2560 /** The beforeunload event is fired when the window, the document and its resources are about to be unloaded. */
2561 interface BeforeUnloadEvent extends Event {
2562     returnValue: any;
2563 }
2564
2565 declare var BeforeUnloadEvent: {
2566     prototype: BeforeUnloadEvent;
2567     new(): BeforeUnloadEvent;
2568 };
2569
2570 interface BhxBrowser {
2571     readonly lastError: DOMException;
2572     checkMatchesGlobExpression(pattern: string, value: string): boolean;
2573     checkMatchesUriExpression(pattern: string, value: string): boolean;
2574     clearLastError(): void;
2575     currentWindowId(): number;
2576     fireExtensionApiTelemetry(functionName: string, isSucceeded: boolean, isSupported: boolean, errorString: string): void;
2577     genericFunction(functionId: number, destination: any, parameters?: string, callbackId?: number): void;
2578     genericSynchronousFunction(functionId: number, parameters?: string): string;
2579     getExtensionId(): string;
2580     getThisAddress(): any;
2581     registerGenericFunctionCallbackHandler(callbackHandler: Function): void;
2582     registerGenericListenerHandler(eventHandler: Function): void;
2583     setLastError(parameters: string): void;
2584     webPlatformGenericFunction(destination: any, parameters?: string, callbackId?: number): void;
2585 }
2586
2587 declare var BhxBrowser: {
2588     prototype: BhxBrowser;
2589     new(): BhxBrowser;
2590 };
2591
2592 /** 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. */
2593 interface BiquadFilterNode extends AudioNode {
2594     readonly Q: AudioParam;
2595     readonly detune: AudioParam;
2596     readonly frequency: AudioParam;
2597     readonly gain: AudioParam;
2598     type: BiquadFilterType;
2599     getFrequencyResponse(frequencyHz: Float32Array, magResponse: Float32Array, phaseResponse: Float32Array): void;
2600 }
2601
2602 declare var BiquadFilterNode: {
2603     prototype: BiquadFilterNode;
2604     new(context: BaseAudioContext, options?: BiquadFilterOptions): BiquadFilterNode;
2605 };
2606
2607 /** 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. */
2608 interface Blob {
2609     readonly size: number;
2610     readonly type: string;
2611     arrayBuffer(): Promise<ArrayBuffer>;
2612     slice(start?: number, end?: number, contentType?: string): Blob;
2613     stream(): ReadableStream;
2614     text(): Promise<string>;
2615 }
2616
2617 declare var Blob: {
2618     prototype: Blob;
2619     new(blobParts?: BlobPart[], options?: BlobPropertyBag): Blob;
2620 };
2621
2622 interface Body {
2623     readonly body: ReadableStream<Uint8Array> | null;
2624     readonly bodyUsed: boolean;
2625     arrayBuffer(): Promise<ArrayBuffer>;
2626     blob(): Promise<Blob>;
2627     formData(): Promise<FormData>;
2628     json(): Promise<any>;
2629     text(): Promise<string>;
2630 }
2631
2632 interface BroadcastChannelEventMap {
2633     "message": MessageEvent;
2634     "messageerror": MessageEvent;
2635 }
2636
2637 interface BroadcastChannel extends EventTarget {
2638     /**
2639      * Returns the channel name (as passed to the constructor).
2640      */
2641     readonly name: string;
2642     onmessage: ((this: BroadcastChannel, ev: MessageEvent) => any) | null;
2643     onmessageerror: ((this: BroadcastChannel, ev: MessageEvent) => any) | null;
2644     /**
2645      * Closes the BroadcastChannel object, opening it up to garbage collection.
2646      */
2647     close(): void;
2648     /**
2649      * Sends the given message to other BroadcastChannel objects set up for this channel. Messages can be structured objects, e.g. nested objects and arrays.
2650      */
2651     postMessage(message: any): void;
2652     addEventListener<K extends keyof BroadcastChannelEventMap>(type: K, listener: (this: BroadcastChannel, ev: BroadcastChannelEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
2653     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
2654     removeEventListener<K extends keyof BroadcastChannelEventMap>(type: K, listener: (this: BroadcastChannel, ev: BroadcastChannelEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
2655     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
2656 }
2657
2658 declare var BroadcastChannel: {
2659     prototype: BroadcastChannel;
2660     new(name: string): BroadcastChannel;
2661 };
2662
2663 /** This Streams API interface provides a built-in byte length queuing strategy that can be used when constructing streams. */
2664 interface ByteLengthQueuingStrategy extends QueuingStrategy<ArrayBufferView> {
2665     readonly highWaterMark: number;
2666     readonly size: QueuingStrategySize<ArrayBufferView>;
2667 }
2668
2669 declare var ByteLengthQueuingStrategy: {
2670     prototype: ByteLengthQueuingStrategy;
2671     new(init: QueuingStrategyInit): ByteLengthQueuingStrategy;
2672 };
2673
2674 /** 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. */
2675 interface CDATASection extends Text {
2676 }
2677
2678 declare var CDATASection: {
2679     prototype: CDATASection;
2680     new(): CDATASection;
2681 };
2682
2683 /** A single condition CSS at-rule, which consists of a condition and a statement block. It is a child of CSSGroupingRule. */
2684 interface CSSConditionRule extends CSSGroupingRule {
2685     conditionText: string;
2686 }
2687
2688 declare var CSSConditionRule: {
2689     prototype: CSSConditionRule;
2690     new(): CSSConditionRule;
2691 };
2692
2693 interface CSSFontFaceRule extends CSSRule {
2694     readonly style: CSSStyleDeclaration;
2695 }
2696
2697 declare var CSSFontFaceRule: {
2698     prototype: CSSFontFaceRule;
2699     new(): CSSFontFaceRule;
2700 };
2701
2702 /** Any CSS at-rule that contains other rules nested within it. */
2703 interface CSSGroupingRule extends CSSRule {
2704     readonly cssRules: CSSRuleList;
2705     deleteRule(index: number): void;
2706     insertRule(rule: string, index?: number): number;
2707 }
2708
2709 declare var CSSGroupingRule: {
2710     prototype: CSSGroupingRule;
2711     new(): CSSGroupingRule;
2712 };
2713
2714 interface CSSImportRule extends CSSRule {
2715     readonly href: string;
2716     readonly media: MediaList;
2717     readonly styleSheet: CSSStyleSheet;
2718 }
2719
2720 declare var CSSImportRule: {
2721     prototype: CSSImportRule;
2722     new(): CSSImportRule;
2723 };
2724
2725 /** 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). */
2726 interface CSSKeyframeRule extends CSSRule {
2727     keyText: string;
2728     readonly style: CSSStyleDeclaration;
2729 }
2730
2731 declare var CSSKeyframeRule: {
2732     prototype: CSSKeyframeRule;
2733     new(): CSSKeyframeRule;
2734 };
2735
2736 /** 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). */
2737 interface CSSKeyframesRule extends CSSRule {
2738     readonly cssRules: CSSRuleList;
2739     name: string;
2740     appendRule(rule: string): void;
2741     deleteRule(select: string): void;
2742     findRule(select: string): CSSKeyframeRule | null;
2743 }
2744
2745 declare var CSSKeyframesRule: {
2746     prototype: CSSKeyframesRule;
2747     new(): CSSKeyframesRule;
2748 };
2749
2750 /** 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). */
2751 interface CSSMediaRule extends CSSConditionRule {
2752     readonly media: MediaList;
2753 }
2754
2755 declare var CSSMediaRule: {
2756     prototype: CSSMediaRule;
2757     new(): CSSMediaRule;
2758 };
2759
2760 /** An object representing a single CSS @namespace at-rule. It implements the CSSRule interface, with a type value of 10 (CSSRule.NAMESPACE_RULE). */
2761 interface CSSNamespaceRule extends CSSRule {
2762     readonly namespaceURI: string;
2763     readonly prefix: string;
2764 }
2765
2766 declare var CSSNamespaceRule: {
2767     prototype: CSSNamespaceRule;
2768     new(): CSSNamespaceRule;
2769 };
2770
2771 /** CSSPageRule is an interface representing a single CSS @page rule. It implements the CSSRule interface with a type value of 6 (CSSRule.PAGE_RULE). */
2772 interface CSSPageRule extends CSSGroupingRule {
2773     selectorText: string;
2774     readonly style: CSSStyleDeclaration;
2775 }
2776
2777 declare var CSSPageRule: {
2778     prototype: CSSPageRule;
2779     new(): CSSPageRule;
2780 };
2781
2782 /** A single CSS rule. There are several types of rules, listed in the Type constants section below. */
2783 interface CSSRule {
2784     cssText: string;
2785     readonly parentRule: CSSRule | null;
2786     readonly parentStyleSheet: CSSStyleSheet | null;
2787     readonly type: number;
2788     readonly CHARSET_RULE: number;
2789     readonly FONT_FACE_RULE: number;
2790     readonly IMPORT_RULE: number;
2791     readonly KEYFRAMES_RULE: number;
2792     readonly KEYFRAME_RULE: number;
2793     readonly MEDIA_RULE: number;
2794     readonly NAMESPACE_RULE: number;
2795     readonly PAGE_RULE: number;
2796     readonly STYLE_RULE: number;
2797     readonly SUPPORTS_RULE: number;
2798 }
2799
2800 declare var CSSRule: {
2801     prototype: CSSRule;
2802     new(): CSSRule;
2803     readonly CHARSET_RULE: number;
2804     readonly FONT_FACE_RULE: number;
2805     readonly IMPORT_RULE: number;
2806     readonly KEYFRAMES_RULE: number;
2807     readonly KEYFRAME_RULE: number;
2808     readonly MEDIA_RULE: number;
2809     readonly NAMESPACE_RULE: number;
2810     readonly PAGE_RULE: number;
2811     readonly STYLE_RULE: number;
2812     readonly SUPPORTS_RULE: number;
2813 };
2814
2815 /** A CSSRuleList is an (indirect-modify only) array-like object containing an ordered collection of CSSRule objects. */
2816 interface CSSRuleList {
2817     readonly length: number;
2818     item(index: number): CSSRule | null;
2819     [index: number]: CSSRule;
2820 }
2821
2822 declare var CSSRuleList: {
2823     prototype: CSSRuleList;
2824     new(): CSSRuleList;
2825 };
2826
2827 /** An object that is a CSS declaration block, and exposes style information and various style-related methods and properties. */
2828 interface CSSStyleDeclaration {
2829     alignContent: string;
2830     alignItems: string;
2831     alignSelf: string;
2832     alignmentBaseline: string;
2833     all: string;
2834     animation: string;
2835     animationDelay: string;
2836     animationDirection: string;
2837     animationDuration: string;
2838     animationFillMode: string;
2839     animationIterationCount: string;
2840     animationName: string;
2841     animationPlayState: string;
2842     animationTimingFunction: string;
2843     backfaceVisibility: string;
2844     background: string;
2845     backgroundAttachment: string;
2846     backgroundClip: string;
2847     backgroundColor: string;
2848     backgroundImage: string;
2849     backgroundOrigin: string;
2850     backgroundPosition: string;
2851     backgroundPositionX: string;
2852     backgroundPositionY: string;
2853     backgroundRepeat: string;
2854     backgroundSize: string;
2855     baselineShift: string;
2856     blockSize: string;
2857     border: string;
2858     borderBlockEnd: string;
2859     borderBlockEndColor: string;
2860     borderBlockEndStyle: string;
2861     borderBlockEndWidth: string;
2862     borderBlockStart: string;
2863     borderBlockStartColor: string;
2864     borderBlockStartStyle: string;
2865     borderBlockStartWidth: string;
2866     borderBottom: string;
2867     borderBottomColor: string;
2868     borderBottomLeftRadius: string;
2869     borderBottomRightRadius: string;
2870     borderBottomStyle: string;
2871     borderBottomWidth: string;
2872     borderCollapse: string;
2873     borderColor: string;
2874     borderImage: string;
2875     borderImageOutset: string;
2876     borderImageRepeat: string;
2877     borderImageSlice: string;
2878     borderImageSource: string;
2879     borderImageWidth: string;
2880     borderInlineEnd: string;
2881     borderInlineEndColor: string;
2882     borderInlineEndStyle: string;
2883     borderInlineEndWidth: string;
2884     borderInlineStart: string;
2885     borderInlineStartColor: string;
2886     borderInlineStartStyle: string;
2887     borderInlineStartWidth: string;
2888     borderLeft: string;
2889     borderLeftColor: string;
2890     borderLeftStyle: string;
2891     borderLeftWidth: string;
2892     borderRadius: string;
2893     borderRight: string;
2894     borderRightColor: string;
2895     borderRightStyle: string;
2896     borderRightWidth: string;
2897     borderSpacing: string;
2898     borderStyle: string;
2899     borderTop: string;
2900     borderTopColor: string;
2901     borderTopLeftRadius: string;
2902     borderTopRightRadius: string;
2903     borderTopStyle: string;
2904     borderTopWidth: string;
2905     borderWidth: string;
2906     bottom: string;
2907     boxShadow: string;
2908     boxSizing: string;
2909     breakAfter: string;
2910     breakBefore: string;
2911     breakInside: string;
2912     captionSide: string;
2913     caretColor: string;
2914     clear: string;
2915     clip: string;
2916     clipPath: string;
2917     clipRule: string;
2918     color: string;
2919     colorInterpolation: string;
2920     colorInterpolationFilters: string;
2921     columnCount: string;
2922     columnFill: string;
2923     columnGap: string;
2924     columnRule: string;
2925     columnRuleColor: string;
2926     columnRuleStyle: string;
2927     columnRuleWidth: string;
2928     columnSpan: string;
2929     columnWidth: string;
2930     columns: string;
2931     content: string;
2932     counterIncrement: string;
2933     counterReset: string;
2934     cssFloat: string;
2935     cssText: string;
2936     cursor: string;
2937     direction: string;
2938     display: string;
2939     dominantBaseline: string;
2940     emptyCells: string;
2941     fill: string;
2942     fillOpacity: string;
2943     fillRule: string;
2944     filter: string;
2945     flex: string;
2946     flexBasis: string;
2947     flexDirection: string;
2948     flexFlow: string;
2949     flexGrow: string;
2950     flexShrink: string;
2951     flexWrap: string;
2952     float: string;
2953     floodColor: string;
2954     floodOpacity: string;
2955     font: string;
2956     fontFamily: string;
2957     fontFeatureSettings: string;
2958     fontKerning: string;
2959     fontSize: string;
2960     fontSizeAdjust: string;
2961     fontStretch: string;
2962     fontStyle: string;
2963     fontSynthesis: string;
2964     fontVariant: string;
2965     fontVariantCaps: string;
2966     fontVariantEastAsian: string;
2967     fontVariantLigatures: string;
2968     fontVariantNumeric: string;
2969     fontVariantPosition: string;
2970     fontWeight: string;
2971     gap: string;
2972     glyphOrientationVertical: string;
2973     grid: string;
2974     gridArea: string;
2975     gridAutoColumns: string;
2976     gridAutoFlow: string;
2977     gridAutoRows: string;
2978     gridColumn: string;
2979     gridColumnEnd: string;
2980     gridColumnGap: string;
2981     gridColumnStart: string;
2982     gridGap: string;
2983     gridRow: string;
2984     gridRowEnd: string;
2985     gridRowGap: string;
2986     gridRowStart: string;
2987     gridTemplate: string;
2988     gridTemplateAreas: string;
2989     gridTemplateColumns: string;
2990     gridTemplateRows: string;
2991     height: string;
2992     hyphens: string;
2993     imageOrientation: string;
2994     imageRendering: string;
2995     inlineSize: string;
2996     justifyContent: string;
2997     justifyItems: string;
2998     justifySelf: string;
2999     left: string;
3000     readonly length: number;
3001     letterSpacing: string;
3002     lightingColor: string;
3003     lineBreak: string;
3004     lineHeight: string;
3005     listStyle: string;
3006     listStyleImage: string;
3007     listStylePosition: string;
3008     listStyleType: string;
3009     margin: string;
3010     marginBlockEnd: string;
3011     marginBlockStart: string;
3012     marginBottom: string;
3013     marginInlineEnd: string;
3014     marginInlineStart: string;
3015     marginLeft: string;
3016     marginRight: string;
3017     marginTop: string;
3018     marker: string;
3019     markerEnd: string;
3020     markerMid: string;
3021     markerStart: string;
3022     mask: string;
3023     maskComposite: string;
3024     maskImage: string;
3025     maskPosition: string;
3026     maskRepeat: string;
3027     maskSize: string;
3028     maskType: string;
3029     maxBlockSize: string;
3030     maxHeight: string;
3031     maxInlineSize: string;
3032     maxWidth: string;
3033     minBlockSize: string;
3034     minHeight: string;
3035     minInlineSize: string;
3036     minWidth: string;
3037     objectFit: string;
3038     objectPosition: string;
3039     opacity: string;
3040     order: string;
3041     orphans: string;
3042     outline: string;
3043     outlineColor: string;
3044     outlineOffset: string;
3045     outlineStyle: string;
3046     outlineWidth: string;
3047     overflow: string;
3048     overflowAnchor: string;
3049     overflowWrap: string;
3050     overflowX: string;
3051     overflowY: string;
3052     overscrollBehavior: string;
3053     overscrollBehaviorBlock: string;
3054     overscrollBehaviorInline: string;
3055     overscrollBehaviorX: string;
3056     overscrollBehaviorY: string;
3057     padding: string;
3058     paddingBlockEnd: string;
3059     paddingBlockStart: string;
3060     paddingBottom: string;
3061     paddingInlineEnd: string;
3062     paddingInlineStart: string;
3063     paddingLeft: string;
3064     paddingRight: string;
3065     paddingTop: string;
3066     pageBreakAfter: string;
3067     pageBreakBefore: string;
3068     pageBreakInside: string;
3069     paintOrder: string;
3070     readonly parentRule: CSSRule | null;
3071     perspective: string;
3072     perspectiveOrigin: string;
3073     placeContent: string;
3074     placeItems: string;
3075     placeSelf: string;
3076     pointerEvents: string;
3077     position: string;
3078     quotes: string;
3079     resize: string;
3080     right: string;
3081     rotate: string;
3082     rowGap: string;
3083     rubyAlign: string;
3084     rubyPosition: string;
3085     scale: string;
3086     scrollBehavior: string;
3087     shapeRendering: string;
3088     stopColor: string;
3089     stopOpacity: string;
3090     stroke: string;
3091     strokeDasharray: string;
3092     strokeDashoffset: string;
3093     strokeLinecap: string;
3094     strokeLinejoin: string;
3095     strokeMiterlimit: string;
3096     strokeOpacity: string;
3097     strokeWidth: string;
3098     tabSize: string;
3099     tableLayout: string;
3100     textAlign: string;
3101     textAlignLast: string;
3102     textAnchor: string;
3103     textCombineUpright: string;
3104     textDecoration: string;
3105     textDecorationColor: string;
3106     textDecorationLine: string;
3107     textDecorationStyle: string;
3108     textEmphasis: string;
3109     textEmphasisColor: string;
3110     textEmphasisPosition: string;
3111     textEmphasisStyle: string;
3112     textIndent: string;
3113     textJustify: string;
3114     textOrientation: string;
3115     textOverflow: string;
3116     textRendering: string;
3117     textShadow: string;
3118     textTransform: string;
3119     textUnderlinePosition: string;
3120     top: string;
3121     touchAction: string;
3122     transform: string;
3123     transformBox: string;
3124     transformOrigin: string;
3125     transformStyle: string;
3126     transition: string;
3127     transitionDelay: string;
3128     transitionDuration: string;
3129     transitionProperty: string;
3130     transitionTimingFunction: string;
3131     translate: string;
3132     unicodeBidi: string;
3133     userSelect: string;
3134     verticalAlign: string;
3135     visibility: string;
3136     /** @deprecated */
3137     webkitAlignContent: string;
3138     /** @deprecated */
3139     webkitAlignItems: string;
3140     /** @deprecated */
3141     webkitAlignSelf: string;
3142     /** @deprecated */
3143     webkitAnimation: string;
3144     /** @deprecated */
3145     webkitAnimationDelay: string;
3146     /** @deprecated */
3147     webkitAnimationDirection: string;
3148     /** @deprecated */
3149     webkitAnimationDuration: string;
3150     /** @deprecated */
3151     webkitAnimationFillMode: string;
3152     /** @deprecated */
3153     webkitAnimationIterationCount: string;
3154     /** @deprecated */
3155     webkitAnimationName: string;
3156     /** @deprecated */
3157     webkitAnimationPlayState: string;
3158     /** @deprecated */
3159     webkitAnimationTimingFunction: string;
3160     /** @deprecated */
3161     webkitAppearance: string;
3162     /** @deprecated */
3163     webkitBackfaceVisibility: string;
3164     /** @deprecated */
3165     webkitBackgroundClip: string;
3166     /** @deprecated */
3167     webkitBackgroundOrigin: string;
3168     /** @deprecated */
3169     webkitBackgroundSize: string;
3170     /** @deprecated */
3171     webkitBorderBottomLeftRadius: string;
3172     /** @deprecated */
3173     webkitBorderBottomRightRadius: string;
3174     /** @deprecated */
3175     webkitBorderRadius: string;
3176     /** @deprecated */
3177     webkitBorderTopLeftRadius: string;
3178     /** @deprecated */
3179     webkitBorderTopRightRadius: string;
3180     /** @deprecated */
3181     webkitBoxAlign: string;
3182     /** @deprecated */
3183     webkitBoxFlex: string;
3184     /** @deprecated */
3185     webkitBoxOrdinalGroup: string;
3186     /** @deprecated */
3187     webkitBoxOrient: string;
3188     /** @deprecated */
3189     webkitBoxPack: string;
3190     /** @deprecated */
3191     webkitBoxShadow: string;
3192     /** @deprecated */
3193     webkitBoxSizing: string;
3194     /** @deprecated */
3195     webkitFilter: string;
3196     /** @deprecated */
3197     webkitFlex: string;
3198     /** @deprecated */
3199     webkitFlexBasis: string;
3200     /** @deprecated */
3201     webkitFlexDirection: string;
3202     /** @deprecated */
3203     webkitFlexFlow: string;
3204     /** @deprecated */
3205     webkitFlexGrow: string;
3206     /** @deprecated */
3207     webkitFlexShrink: string;
3208     /** @deprecated */
3209     webkitFlexWrap: string;
3210     /** @deprecated */
3211     webkitJustifyContent: string;
3212     webkitLineClamp: string;
3213     /** @deprecated */
3214     webkitMask: string;
3215     /** @deprecated */
3216     webkitMaskBoxImage: string;
3217     /** @deprecated */
3218     webkitMaskBoxImageOutset: string;
3219     /** @deprecated */
3220     webkitMaskBoxImageRepeat: string;
3221     /** @deprecated */
3222     webkitMaskBoxImageSlice: string;
3223     /** @deprecated */
3224     webkitMaskBoxImageSource: string;
3225     /** @deprecated */
3226     webkitMaskBoxImageWidth: string;
3227     /** @deprecated */
3228     webkitMaskClip: string;
3229     /** @deprecated */
3230     webkitMaskComposite: string;
3231     /** @deprecated */
3232     webkitMaskImage: string;
3233     /** @deprecated */
3234     webkitMaskOrigin: string;
3235     /** @deprecated */
3236     webkitMaskPosition: string;
3237     /** @deprecated */
3238     webkitMaskRepeat: string;
3239     /** @deprecated */
3240     webkitMaskSize: string;
3241     /** @deprecated */
3242     webkitOrder: string;
3243     /** @deprecated */
3244     webkitPerspective: string;
3245     /** @deprecated */
3246     webkitPerspectiveOrigin: string;
3247     webkitTapHighlightColor: string;
3248     /** @deprecated */
3249     webkitTextFillColor: string;
3250     /** @deprecated */
3251     webkitTextSizeAdjust: string;
3252     /** @deprecated */
3253     webkitTextStroke: string;
3254     /** @deprecated */
3255     webkitTextStrokeColor: string;
3256     /** @deprecated */
3257     webkitTextStrokeWidth: string;
3258     /** @deprecated */
3259     webkitTransform: string;
3260     /** @deprecated */
3261     webkitTransformOrigin: string;
3262     /** @deprecated */
3263     webkitTransformStyle: string;
3264     /** @deprecated */
3265     webkitTransition: string;
3266     /** @deprecated */
3267     webkitTransitionDelay: string;
3268     /** @deprecated */
3269     webkitTransitionDuration: string;
3270     /** @deprecated */
3271     webkitTransitionProperty: string;
3272     /** @deprecated */
3273     webkitTransitionTimingFunction: string;
3274     /** @deprecated */
3275     webkitUserSelect: string;
3276     whiteSpace: string;
3277     widows: string;
3278     width: string;
3279     willChange: string;
3280     wordBreak: string;
3281     wordSpacing: string;
3282     wordWrap: string;
3283     writingMode: string;
3284     zIndex: string;
3285     /** @deprecated */
3286     zoom: string;
3287     getPropertyPriority(property: string): string;
3288     getPropertyValue(property: string): string;
3289     item(index: number): string;
3290     removeProperty(property: string): string;
3291     setProperty(property: string, value: string | null, priority?: string): void;
3292     [index: number]: string;
3293 }
3294
3295 declare var CSSStyleDeclaration: {
3296     prototype: CSSStyleDeclaration;
3297     new(): CSSStyleDeclaration;
3298 };
3299
3300 /** CSSStyleRule represents a single CSS style rule. It implements the CSSRule interface with a type value of 1 (CSSRule.STYLE_RULE). */
3301 interface CSSStyleRule extends CSSRule {
3302     selectorText: string;
3303     readonly style: CSSStyleDeclaration;
3304 }
3305
3306 declare var CSSStyleRule: {
3307     prototype: CSSStyleRule;
3308     new(): CSSStyleRule;
3309 };
3310
3311 /** A single CSS style sheet. It inherits properties and methods from its parent, StyleSheet. */
3312 interface CSSStyleSheet extends StyleSheet {
3313     readonly cssRules: CSSRuleList;
3314     readonly ownerRule: CSSRule | null;
3315     readonly rules: CSSRuleList;
3316     addRule(selector?: string, style?: string, index?: number): number;
3317     deleteRule(index: number): void;
3318     insertRule(rule: string, index?: number): number;
3319     removeRule(index?: number): void;
3320 }
3321
3322 declare var CSSStyleSheet: {
3323     prototype: CSSStyleSheet;
3324     new(): CSSStyleSheet;
3325 };
3326
3327 /** 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). */
3328 interface CSSSupportsRule extends CSSConditionRule {
3329 }
3330
3331 declare var CSSSupportsRule: {
3332     prototype: CSSSupportsRule;
3333     new(): CSSSupportsRule;
3334 };
3335
3336 /** 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. */
3337 interface Cache {
3338     add(request: RequestInfo): Promise<void>;
3339     addAll(requests: RequestInfo[]): Promise<void>;
3340     delete(request: RequestInfo, options?: CacheQueryOptions): Promise<boolean>;
3341     keys(request?: RequestInfo, options?: CacheQueryOptions): Promise<ReadonlyArray<Request>>;
3342     match(request: RequestInfo, options?: CacheQueryOptions): Promise<Response | undefined>;
3343     matchAll(request?: RequestInfo, options?: CacheQueryOptions): Promise<ReadonlyArray<Response>>;
3344     put(request: RequestInfo, response: Response): Promise<void>;
3345 }
3346
3347 declare var Cache: {
3348     prototype: Cache;
3349     new(): Cache;
3350 };
3351
3352 /** The storage for Cache objects. */
3353 interface CacheStorage {
3354     delete(cacheName: string): Promise<boolean>;
3355     has(cacheName: string): Promise<boolean>;
3356     keys(): Promise<string[]>;
3357     match(request: RequestInfo, options?: MultiCacheQueryOptions): Promise<Response | undefined>;
3358     open(cacheName: string): Promise<Cache>;
3359 }
3360
3361 declare var CacheStorage: {
3362     prototype: CacheStorage;
3363     new(): CacheStorage;
3364 };
3365
3366 interface CanvasCompositing {
3367     globalAlpha: number;
3368     globalCompositeOperation: string;
3369 }
3370
3371 interface CanvasDrawImage {
3372     drawImage(image: CanvasImageSource, dx: number, dy: number): void;
3373     drawImage(image: CanvasImageSource, dx: number, dy: number, dw: number, dh: number): void;
3374     drawImage(image: CanvasImageSource, sx: number, sy: number, sw: number, sh: number, dx: number, dy: number, dw: number, dh: number): void;
3375 }
3376
3377 interface CanvasDrawPath {
3378     beginPath(): void;
3379     clip(fillRule?: CanvasFillRule): void;
3380     clip(path: Path2D, fillRule?: CanvasFillRule): void;
3381     fill(fillRule?: CanvasFillRule): void;
3382     fill(path: Path2D, fillRule?: CanvasFillRule): void;
3383     isPointInPath(x: number, y: number, fillRule?: CanvasFillRule): boolean;
3384     isPointInPath(path: Path2D, x: number, y: number, fillRule?: CanvasFillRule): boolean;
3385     isPointInStroke(x: number, y: number): boolean;
3386     isPointInStroke(path: Path2D, x: number, y: number): boolean;
3387     stroke(): void;
3388     stroke(path: Path2D): void;
3389 }
3390
3391 interface CanvasFillStrokeStyles {
3392     fillStyle: string | CanvasGradient | CanvasPattern;
3393     strokeStyle: string | CanvasGradient | CanvasPattern;
3394     createLinearGradient(x0: number, y0: number, x1: number, y1: number): CanvasGradient;
3395     createPattern(image: CanvasImageSource, repetition: string | null): CanvasPattern | null;
3396     createRadialGradient(x0: number, y0: number, r0: number, x1: number, y1: number, r1: number): CanvasGradient;
3397 }
3398
3399 interface CanvasFilters {
3400     filter: string;
3401 }
3402
3403 /** An opaque object describing a gradient. It is returned by the methods CanvasRenderingContext2D.createLinearGradient() or CanvasRenderingContext2D.createRadialGradient(). */
3404 interface CanvasGradient {
3405     /**
3406      * 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.
3407      *
3408      * Throws an "IndexSizeError" DOMException if the offset is out of range. Throws a "SyntaxError" DOMException if the color cannot be parsed.
3409      */
3410     addColorStop(offset: number, color: string): void;
3411 }
3412
3413 declare var CanvasGradient: {
3414     prototype: CanvasGradient;
3415     new(): CanvasGradient;
3416 };
3417
3418 interface CanvasImageData {
3419     createImageData(sw: number, sh: number): ImageData;
3420     createImageData(imagedata: ImageData): ImageData;
3421     getImageData(sx: number, sy: number, sw: number, sh: number): ImageData;
3422     putImageData(imagedata: ImageData, dx: number, dy: number): void;
3423     putImageData(imagedata: ImageData, dx: number, dy: number, dirtyX: number, dirtyY: number, dirtyWidth: number, dirtyHeight: number): void;
3424 }
3425
3426 interface CanvasImageSmoothing {
3427     imageSmoothingEnabled: boolean;
3428     imageSmoothingQuality: ImageSmoothingQuality;
3429 }
3430
3431 interface CanvasPath {
3432     arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, anticlockwise?: boolean): void;
3433     arcTo(x1: number, y1: number, x2: number, y2: number, radius: number): void;
3434     bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number): void;
3435     closePath(): void;
3436     ellipse(x: number, y: number, radiusX: number, radiusY: number, rotation: number, startAngle: number, endAngle: number, anticlockwise?: boolean): void;
3437     lineTo(x: number, y: number): void;
3438     moveTo(x: number, y: number): void;
3439     quadraticCurveTo(cpx: number, cpy: number, x: number, y: number): void;
3440     rect(x: number, y: number, w: number, h: number): void;
3441 }
3442
3443 interface CanvasPathDrawingStyles {
3444     lineCap: CanvasLineCap;
3445     lineDashOffset: number;
3446     lineJoin: CanvasLineJoin;
3447     lineWidth: number;
3448     miterLimit: number;
3449     getLineDash(): number[];
3450     setLineDash(segments: number[]): void;
3451 }
3452
3453 /** An opaque object describing a pattern, based on an image, a canvas, or a video, created by the CanvasRenderingContext2D.createPattern() method. */
3454 interface CanvasPattern {
3455     /**
3456      * Sets the transformation matrix that will be used when rendering the pattern during a fill or stroke painting operation.
3457      */
3458     setTransform(transform?: DOMMatrix2DInit): void;
3459 }
3460
3461 declare var CanvasPattern: {
3462     prototype: CanvasPattern;
3463     new(): CanvasPattern;
3464 };
3465
3466 interface CanvasRect {
3467     clearRect(x: number, y: number, w: number, h: number): void;
3468     fillRect(x: number, y: number, w: number, h: number): void;
3469     strokeRect(x: number, y: number, w: number, h: number): void;
3470 }
3471
3472 /** 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. */
3473 interface CanvasRenderingContext2D extends CanvasCompositing, CanvasDrawImage, CanvasDrawPath, CanvasFillStrokeStyles, CanvasFilters, CanvasImageData, CanvasImageSmoothing, CanvasPath, CanvasPathDrawingStyles, CanvasRect, CanvasShadowStyles, CanvasState, CanvasText, CanvasTextDrawingStyles, CanvasTransform, CanvasUserInterface {
3474     readonly canvas: HTMLCanvasElement;
3475 }
3476
3477 declare var CanvasRenderingContext2D: {
3478     prototype: CanvasRenderingContext2D;
3479     new(): CanvasRenderingContext2D;
3480 };
3481
3482 interface CanvasShadowStyles {
3483     shadowBlur: number;
3484     shadowColor: string;
3485     shadowOffsetX: number;
3486     shadowOffsetY: number;
3487 }
3488
3489 interface CanvasState {
3490     restore(): void;
3491     save(): void;
3492 }
3493
3494 interface CanvasText {
3495     fillText(text: string, x: number, y: number, maxWidth?: number): void;
3496     measureText(text: string): TextMetrics;
3497     strokeText(text: string, x: number, y: number, maxWidth?: number): void;
3498 }
3499
3500 interface CanvasTextDrawingStyles {
3501     direction: CanvasDirection;
3502     font: string;
3503     textAlign: CanvasTextAlign;
3504     textBaseline: CanvasTextBaseline;
3505 }
3506
3507 interface CanvasTransform {
3508     getTransform(): DOMMatrix;
3509     resetTransform(): void;
3510     rotate(angle: number): void;
3511     scale(x: number, y: number): void;
3512     setTransform(a: number, b: number, c: number, d: number, e: number, f: number): void;
3513     setTransform(transform?: DOMMatrix2DInit): void;
3514     transform(a: number, b: number, c: number, d: number, e: number, f: number): void;
3515     translate(x: number, y: number): void;
3516 }
3517
3518 interface CanvasUserInterface {
3519     drawFocusIfNeeded(element: Element): void;
3520     drawFocusIfNeeded(path: Path2D, element: Element): void;
3521     scrollPathIntoView(): void;
3522     scrollPathIntoView(path: Path2D): void;
3523 }
3524
3525 interface CaretPosition {
3526     readonly offset: number;
3527     readonly offsetNode: Node;
3528     getClientRect(): DOMRect | null;
3529 }
3530
3531 declare var CaretPosition: {
3532     prototype: CaretPosition;
3533     new(): CaretPosition;
3534 };
3535
3536 /** 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. */
3537 interface ChannelMergerNode extends AudioNode {
3538 }
3539
3540 declare var ChannelMergerNode: {
3541     prototype: ChannelMergerNode;
3542     new(context: BaseAudioContext, options?: ChannelMergerOptions): ChannelMergerNode;
3543 };
3544
3545 /** 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. */
3546 interface ChannelSplitterNode extends AudioNode {
3547 }
3548
3549 declare var ChannelSplitterNode: {
3550     prototype: ChannelSplitterNode;
3551     new(context: BaseAudioContext, options?: ChannelSplitterOptions): ChannelSplitterNode;
3552 };
3553
3554 /** 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. */
3555 interface CharacterData extends Node, ChildNode, NonDocumentTypeChildNode {
3556     data: string;
3557     readonly length: number;
3558     readonly ownerDocument: Document;
3559     appendData(data: string): void;
3560     deleteData(offset: number, count: number): void;
3561     insertData(offset: number, data: string): void;
3562     replaceData(offset: number, count: number, data: string): void;
3563     substringData(offset: number, count: number): string;
3564 }
3565
3566 declare var CharacterData: {
3567     prototype: CharacterData;
3568     new(): CharacterData;
3569 };
3570
3571 interface ChildNode extends Node {
3572     /**
3573      * Inserts nodes just after node, while replacing strings in nodes with equivalent Text nodes.
3574      *
3575      * Throws a "HierarchyRequestError" DOMException if the constraints of the node tree are violated.
3576      */
3577     after(...nodes: (Node | string)[]): void;
3578     /**
3579      * Inserts nodes just before node, while replacing strings in nodes with equivalent Text nodes.
3580      *
3581      * Throws a "HierarchyRequestError" DOMException if the constraints of the node tree are violated.
3582      */
3583     before(...nodes: (Node | string)[]): void;
3584     /**
3585      * Removes node.
3586      */
3587     remove(): void;
3588     /**
3589      * Replaces node with nodes, while replacing strings in nodes with equivalent Text nodes.
3590      *
3591      * Throws a "HierarchyRequestError" DOMException if the constraints of the node tree are violated.
3592      */
3593     replaceWith(...nodes: (Node | string)[]): void;
3594 }
3595
3596 interface ClientRect {
3597     bottom: number;
3598     readonly height: number;
3599     left: number;
3600     right: number;
3601     top: number;
3602     readonly width: number;
3603 }
3604
3605 declare var ClientRect: {
3606     prototype: ClientRect;
3607     new(): ClientRect;
3608 };
3609
3610 interface ClientRectList {
3611     readonly length: number;
3612     item(index: number): ClientRect;
3613     [index: number]: ClientRect;
3614 }
3615
3616 declare var ClientRectList: {
3617     prototype: ClientRectList;
3618     new(): ClientRectList;
3619 };
3620
3621 interface Clipboard extends EventTarget {
3622     readText(): Promise<string>;
3623     writeText(data: string): Promise<void>;
3624 }
3625
3626 declare var Clipboard: {
3627     prototype: Clipboard;
3628     new(): Clipboard;
3629 };
3630
3631 /** Events providing information related to modification of the clipboard, that is cut, copy, and paste events. */
3632 interface ClipboardEvent extends Event {
3633     readonly clipboardData: DataTransfer | null;
3634 }
3635
3636 declare var ClipboardEvent: {
3637     prototype: ClipboardEvent;
3638     new(type: string, eventInitDict?: ClipboardEventInit): ClipboardEvent;
3639 };
3640
3641 /** 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. */
3642 interface CloseEvent extends Event {
3643     /**
3644      * Returns the WebSocket connection close code provided by the server.
3645      */
3646     readonly code: number;
3647     /**
3648      * Returns the WebSocket connection close reason provided by the server.
3649      */
3650     readonly reason: string;
3651     /**
3652      * Returns true if the connection closed cleanly; false otherwise.
3653      */
3654     readonly wasClean: boolean;
3655 }
3656
3657 declare var CloseEvent: {
3658     prototype: CloseEvent;
3659     new(type: string, eventInitDict?: CloseEventInit): CloseEvent;
3660 };
3661
3662 /** Textual notations within markup; although it is generally not visually shown, such comments are available to be read in the source view. */
3663 interface Comment extends CharacterData {
3664 }
3665
3666 declare var Comment: {
3667     prototype: Comment;
3668     new(data?: string): Comment;
3669 };
3670
3671 /** The DOM CompositionEvent represents events that occur due to the user indirectly entering text. */
3672 interface CompositionEvent extends UIEvent {
3673     readonly data: string;
3674 }
3675
3676 declare var CompositionEvent: {
3677     prototype: CompositionEvent;
3678     new(type: string, eventInitDict?: CompositionEventInit): CompositionEvent;
3679 };
3680
3681 interface ConcatParams extends Algorithm {
3682     algorithmId: Uint8Array;
3683     hash?: string | Algorithm;
3684     partyUInfo: Uint8Array;
3685     partyVInfo: Uint8Array;
3686     privateInfo?: Uint8Array;
3687     publicInfo?: Uint8Array;
3688 }
3689
3690 interface ConstantSourceNode extends AudioScheduledSourceNode {
3691     readonly offset: AudioParam;
3692     addEventListener<K extends keyof AudioScheduledSourceNodeEventMap>(type: K, listener: (this: ConstantSourceNode, ev: AudioScheduledSourceNodeEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
3693     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
3694     removeEventListener<K extends keyof AudioScheduledSourceNodeEventMap>(type: K, listener: (this: ConstantSourceNode, ev: AudioScheduledSourceNodeEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
3695     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
3696 }
3697
3698 declare var ConstantSourceNode: {
3699     prototype: ConstantSourceNode;
3700     new(context: BaseAudioContext, options?: ConstantSourceOptions): ConstantSourceNode;
3701 };
3702
3703 /** 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. */
3704 interface ConvolverNode extends AudioNode {
3705     buffer: AudioBuffer | null;
3706     normalize: boolean;
3707 }
3708
3709 declare var ConvolverNode: {
3710     prototype: ConvolverNode;
3711     new(context: BaseAudioContext, options?: ConvolverOptions): ConvolverNode;
3712 };
3713
3714 /** This Streams API interface provides a built-in byte length queuing strategy that can be used when constructing streams. */
3715 interface CountQueuingStrategy extends QueuingStrategy {
3716     readonly highWaterMark: number;
3717     readonly size: QueuingStrategySize;
3718 }
3719
3720 declare var CountQueuingStrategy: {
3721     prototype: CountQueuingStrategy;
3722     new(init: QueuingStrategyInit): CountQueuingStrategy;
3723 };
3724
3725 interface Credential {
3726     readonly id: string;
3727     readonly type: string;
3728 }
3729
3730 declare var Credential: {
3731     prototype: Credential;
3732     new(): Credential;
3733 };
3734
3735 interface CredentialsContainer {
3736     create(options?: CredentialCreationOptions): Promise<Credential | null>;
3737     get(options?: CredentialRequestOptions): Promise<Credential | null>;
3738     preventSilentAccess(): Promise<void>;
3739     store(credential: Credential): Promise<Credential>;
3740 }
3741
3742 declare var CredentialsContainer: {
3743     prototype: CredentialsContainer;
3744     new(): CredentialsContainer;
3745 };
3746
3747 /** Basic cryptography features available in the current context. It allows access to a cryptographically strong random number generator and to cryptographic primitives. */
3748 interface Crypto {
3749     readonly subtle: SubtleCrypto;
3750     getRandomValues<T extends Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | null>(array: T): T;
3751 }
3752
3753 declare var Crypto: {
3754     prototype: Crypto;
3755     new(): Crypto;
3756 };
3757
3758 /** The CryptoKey dictionary of the Web Crypto API represents a cryptographic key. */
3759 interface CryptoKey {
3760     readonly algorithm: KeyAlgorithm;
3761     readonly extractable: boolean;
3762     readonly type: KeyType;
3763     readonly usages: KeyUsage[];
3764 }
3765
3766 declare var CryptoKey: {
3767     prototype: CryptoKey;
3768     new(): CryptoKey;
3769 };
3770
3771 /** The CryptoKeyPair dictionary of the Web Crypto API represents a key pair for an asymmetric cryptography algorithm, also known as a public-key algorithm. */
3772 interface CryptoKeyPair {
3773     privateKey: CryptoKey;
3774     publicKey: CryptoKey;
3775 }
3776
3777 declare var CryptoKeyPair: {
3778     prototype: CryptoKeyPair;
3779     new(): CryptoKeyPair;
3780 };
3781
3782 interface CustomElementRegistry {
3783     define(name: string, constructor: CustomElementConstructor, options?: ElementDefinitionOptions): void;
3784     get(name: string): any;
3785     upgrade(root: Node): void;
3786     whenDefined(name: string): Promise<void>;
3787 }
3788
3789 declare var CustomElementRegistry: {
3790     prototype: CustomElementRegistry;
3791     new(): CustomElementRegistry;
3792 };
3793
3794 interface CustomEvent<T = any> extends Event {
3795     /**
3796      * Returns any custom data event was created with. Typically used for synthetic events.
3797      */
3798     readonly detail: T;
3799     initCustomEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, detailArg: T): void;
3800 }
3801
3802 declare var CustomEvent: {
3803     prototype: CustomEvent;
3804     new<T>(typeArg: string, eventInitDict?: CustomEventInit<T>): CustomEvent<T>;
3805 };
3806
3807 /** An error object that contains an error name. */
3808 interface DOMError {
3809     readonly name: string;
3810     toString(): string;
3811 }
3812
3813 declare var DOMError: {
3814     prototype: DOMError;
3815     new(): DOMError;
3816 };
3817
3818 /** An abnormal event (called an exception) which occurs as a result of calling a method or accessing a property of a web API. */
3819 interface DOMException {
3820     readonly code: number;
3821     readonly message: string;
3822     readonly name: string;
3823     readonly ABORT_ERR: number;
3824     readonly DATA_CLONE_ERR: number;
3825     readonly DOMSTRING_SIZE_ERR: number;
3826     readonly HIERARCHY_REQUEST_ERR: number;
3827     readonly INDEX_SIZE_ERR: number;
3828     readonly INUSE_ATTRIBUTE_ERR: number;
3829     readonly INVALID_ACCESS_ERR: number;
3830     readonly INVALID_CHARACTER_ERR: number;
3831     readonly INVALID_MODIFICATION_ERR: number;
3832     readonly INVALID_NODE_TYPE_ERR: number;
3833     readonly INVALID_STATE_ERR: number;
3834     readonly NAMESPACE_ERR: number;
3835     readonly NETWORK_ERR: number;
3836     readonly NOT_FOUND_ERR: number;
3837     readonly NOT_SUPPORTED_ERR: number;
3838     readonly NO_DATA_ALLOWED_ERR: number;
3839     readonly NO_MODIFICATION_ALLOWED_ERR: number;
3840     readonly QUOTA_EXCEEDED_ERR: number;
3841     readonly SECURITY_ERR: number;
3842     readonly SYNTAX_ERR: number;
3843     readonly TIMEOUT_ERR: number;
3844     readonly TYPE_MISMATCH_ERR: number;
3845     readonly URL_MISMATCH_ERR: number;
3846     readonly VALIDATION_ERR: number;
3847     readonly WRONG_DOCUMENT_ERR: number;
3848 }
3849
3850 declare var DOMException: {
3851     prototype: DOMException;
3852     new(message?: string, name?: string): DOMException;
3853     readonly ABORT_ERR: number;
3854     readonly DATA_CLONE_ERR: number;
3855     readonly DOMSTRING_SIZE_ERR: number;
3856     readonly HIERARCHY_REQUEST_ERR: number;
3857     readonly INDEX_SIZE_ERR: number;
3858     readonly INUSE_ATTRIBUTE_ERR: number;
3859     readonly INVALID_ACCESS_ERR: number;
3860     readonly INVALID_CHARACTER_ERR: number;
3861     readonly INVALID_MODIFICATION_ERR: number;
3862     readonly INVALID_NODE_TYPE_ERR: number;
3863     readonly INVALID_STATE_ERR: number;
3864     readonly NAMESPACE_ERR: number;
3865     readonly NETWORK_ERR: number;
3866     readonly NOT_FOUND_ERR: number;
3867     readonly NOT_SUPPORTED_ERR: number;
3868     readonly NO_DATA_ALLOWED_ERR: number;
3869     readonly NO_MODIFICATION_ALLOWED_ERR: number;
3870     readonly QUOTA_EXCEEDED_ERR: number;
3871     readonly SECURITY_ERR: number;
3872     readonly SYNTAX_ERR: number;
3873     readonly TIMEOUT_ERR: number;
3874     readonly TYPE_MISMATCH_ERR: number;
3875     readonly URL_MISMATCH_ERR: number;
3876     readonly VALIDATION_ERR: number;
3877     readonly WRONG_DOCUMENT_ERR: number;
3878 };
3879
3880 /** An object providing methods which are not dependent on any particular document. Such an object is returned by the Document.implementation property. */
3881 interface DOMImplementation {
3882     createDocument(namespace: string | null, qualifiedName: string | null, doctype?: DocumentType | null): XMLDocument;
3883     createDocumentType(qualifiedName: string, publicId: string, systemId: string): DocumentType;
3884     createHTMLDocument(title?: string): Document;
3885     /** @deprecated */
3886     hasFeature(...args: any[]): true;
3887 }
3888
3889 declare var DOMImplementation: {
3890     prototype: DOMImplementation;
3891     new(): DOMImplementation;
3892 };
3893
3894 interface DOML2DeprecatedColorProperty {
3895     color: string;
3896 }
3897
3898 interface DOMMatrix extends DOMMatrixReadOnly {
3899     a: number;
3900     b: number;
3901     c: number;
3902     d: number;
3903     e: number;
3904     f: number;
3905     m11: number;
3906     m12: number;
3907     m13: number;
3908     m14: number;
3909     m21: number;
3910     m22: number;
3911     m23: number;
3912     m24: number;
3913     m31: number;
3914     m32: number;
3915     m33: number;
3916     m34: number;
3917     m41: number;
3918     m42: number;
3919     m43: number;
3920     m44: number;
3921     invertSelf(): DOMMatrix;
3922     multiplySelf(other?: DOMMatrixInit): DOMMatrix;
3923     preMultiplySelf(other?: DOMMatrixInit): DOMMatrix;
3924     rotateAxisAngleSelf(x?: number, y?: number, z?: number, angle?: number): DOMMatrix;
3925     rotateFromVectorSelf(x?: number, y?: number): DOMMatrix;
3926     rotateSelf(rotX?: number, rotY?: number, rotZ?: number): DOMMatrix;
3927     scale3dSelf(scale?: number, originX?: number, originY?: number, originZ?: number): DOMMatrix;
3928     scaleSelf(scaleX?: number, scaleY?: number, scaleZ?: number, originX?: number, originY?: number, originZ?: number): DOMMatrix;
3929     setMatrixValue(transformList: string): DOMMatrix;
3930     skewXSelf(sx?: number): DOMMatrix;
3931     skewYSelf(sy?: number): DOMMatrix;
3932     translateSelf(tx?: number, ty?: number, tz?: number): DOMMatrix;
3933 }
3934
3935 declare var DOMMatrix: {
3936     prototype: DOMMatrix;
3937     new(init?: string | number[]): DOMMatrix;
3938     fromFloat32Array(array32: Float32Array): DOMMatrix;
3939     fromFloat64Array(array64: Float64Array): DOMMatrix;
3940     fromMatrix(other?: DOMMatrixInit): DOMMatrix;
3941 };
3942
3943 type SVGMatrix = DOMMatrix;
3944 declare var SVGMatrix: typeof DOMMatrix;
3945
3946 type WebKitCSSMatrix = DOMMatrix;
3947 declare var WebKitCSSMatrix: typeof DOMMatrix;
3948
3949 interface DOMMatrixReadOnly {
3950     readonly a: number;
3951     readonly b: number;
3952     readonly c: number;
3953     readonly d: number;
3954     readonly e: number;
3955     readonly f: number;
3956     readonly is2D: boolean;
3957     readonly isIdentity: boolean;
3958     readonly m11: number;
3959     readonly m12: number;
3960     readonly m13: number;
3961     readonly m14: number;
3962     readonly m21: number;
3963     readonly m22: number;
3964     readonly m23: number;
3965     readonly m24: number;
3966     readonly m31: number;
3967     readonly m32: number;
3968     readonly m33: number;
3969     readonly m34: number;
3970     readonly m41: number;
3971     readonly m42: number;
3972     readonly m43: number;
3973     readonly m44: number;
3974     flipX(): DOMMatrix;
3975     flipY(): DOMMatrix;
3976     inverse(): DOMMatrix;
3977     multiply(other?: DOMMatrixInit): DOMMatrix;
3978     rotate(rotX?: number, rotY?: number, rotZ?: number): DOMMatrix;
3979     rotateAxisAngle(x?: number, y?: number, z?: number, angle?: number): DOMMatrix;
3980     rotateFromVector(x?: number, y?: number): DOMMatrix;
3981     scale(scaleX?: number, scaleY?: number, scaleZ?: number, originX?: number, originY?: number, originZ?: number): DOMMatrix;
3982     scale3d(scale?: number, originX?: number, originY?: number, originZ?: number): DOMMatrix;
3983     /** @deprecated */
3984     scaleNonUniform(scaleX?: number, scaleY?: number): DOMMatrix;
3985     skewX(sx?: number): DOMMatrix;
3986     skewY(sy?: number): DOMMatrix;
3987     toFloat32Array(): Float32Array;
3988     toFloat64Array(): Float64Array;
3989     toJSON(): any;
3990     transformPoint(point?: DOMPointInit): DOMPoint;
3991     translate(tx?: number, ty?: number, tz?: number): DOMMatrix;
3992     toString(): string;
3993 }
3994
3995 declare var DOMMatrixReadOnly: {
3996     prototype: DOMMatrixReadOnly;
3997     new(init?: string | number[]): DOMMatrixReadOnly;
3998     fromFloat32Array(array32: Float32Array): DOMMatrixReadOnly;
3999     fromFloat64Array(array64: Float64Array): DOMMatrixReadOnly;
4000     fromMatrix(other?: DOMMatrixInit): DOMMatrixReadOnly;
4001     toString(): string;
4002 };
4003
4004 /** Provides the ability to parse XML or HTML source code from a string into a DOM Document. */
4005 interface DOMParser {
4006     /**
4007      * Parses string using either the HTML or XML parser, according to type, and returns the resulting Document. type can be "text/html" (which will invoke the HTML parser), or any of "text/xml", "application/xml", "application/xhtml+xml", or "image/svg+xml" (which will invoke the XML parser).
4008      *
4009      * For the XML parser, if string cannot be parsed, then the returned Document will contain elements describing the resulting error.
4010      *
4011      * Note that script elements are not evaluated during parsing, and the resulting document's encoding will always be UTF-8.
4012      *
4013      * Values other than the above for type will cause a TypeError exception to be thrown.
4014      */
4015     parseFromString(string: string, type: DOMParserSupportedType): Document;
4016 }
4017
4018 declare var DOMParser: {
4019     prototype: DOMParser;
4020     new(): DOMParser;
4021 };
4022
4023 interface DOMPoint extends DOMPointReadOnly {
4024     w: number;
4025     x: number;
4026     y: number;
4027     z: number;
4028 }
4029
4030 declare var DOMPoint: {
4031     prototype: DOMPoint;
4032     new(x?: number, y?: number, z?: number, w?: number): DOMPoint;
4033     fromPoint(other?: DOMPointInit): DOMPoint;
4034 };
4035
4036 type SVGPoint = DOMPoint;
4037 declare var SVGPoint: typeof DOMPoint;
4038
4039 interface DOMPointReadOnly {
4040     readonly w: number;
4041     readonly x: number;
4042     readonly y: number;
4043     readonly z: number;
4044     matrixTransform(matrix?: DOMMatrixInit): DOMPoint;
4045     toJSON(): any;
4046 }
4047
4048 declare var DOMPointReadOnly: {
4049     prototype: DOMPointReadOnly;
4050     new(x?: number, y?: number, z?: number, w?: number): DOMPointReadOnly;
4051     fromPoint(other?: DOMPointInit): DOMPointReadOnly;
4052 };
4053
4054 interface DOMQuad {
4055     readonly p1: DOMPoint;
4056     readonly p2: DOMPoint;
4057     readonly p3: DOMPoint;
4058     readonly p4: DOMPoint;
4059     getBounds(): DOMRect;
4060     toJSON(): any;
4061 }
4062
4063 declare var DOMQuad: {
4064     prototype: DOMQuad;
4065     new(p1?: DOMPointInit, p2?: DOMPointInit, p3?: DOMPointInit, p4?: DOMPointInit): DOMQuad;
4066     fromQuad(other?: DOMQuadInit): DOMQuad;
4067     fromRect(other?: DOMRectInit): DOMQuad;
4068 };
4069
4070 interface DOMRect extends DOMRectReadOnly {
4071     height: number;
4072     width: number;
4073     x: number;
4074     y: number;
4075 }
4076
4077 declare var DOMRect: {
4078     prototype: DOMRect;
4079     new(x?: number, y?: number, width?: number, height?: number): DOMRect;
4080     fromRect(other?: DOMRectInit): DOMRect;
4081 };
4082
4083 type SVGRect = DOMRect;
4084 declare var SVGRect: typeof DOMRect;
4085
4086 interface DOMRectList {
4087     readonly length: number;
4088     item(index: number): DOMRect | null;
4089     [index: number]: DOMRect;
4090 }
4091
4092 declare var DOMRectList: {
4093     prototype: DOMRectList;
4094     new(): DOMRectList;
4095 };
4096
4097 interface DOMRectReadOnly {
4098     readonly bottom: number;
4099     readonly height: number;
4100     readonly left: number;
4101     readonly right: number;
4102     readonly top: number;
4103     readonly width: number;
4104     readonly x: number;
4105     readonly y: number;
4106     toJSON(): any;
4107 }
4108
4109 declare var DOMRectReadOnly: {
4110     prototype: DOMRectReadOnly;
4111     new(x?: number, y?: number, width?: number, height?: number): DOMRectReadOnly;
4112     fromRect(other?: DOMRectInit): DOMRectReadOnly;
4113 };
4114
4115 interface DOMSettableTokenList extends DOMTokenList {
4116     value: string;
4117 }
4118
4119 declare var DOMSettableTokenList: {
4120     prototype: DOMSettableTokenList;
4121     new(): DOMSettableTokenList;
4122 };
4123
4124 /** A type returned by some APIs which contains a list of DOMString (strings). */
4125 interface DOMStringList {
4126     /**
4127      * Returns the number of strings in strings.
4128      */
4129     readonly length: number;
4130     /**
4131      * Returns true if strings contains string, and false otherwise.
4132      */
4133     contains(string: string): boolean;
4134     /**
4135      * Returns the string with index index from strings.
4136      */
4137     item(index: number): string | null;
4138     [index: number]: string;
4139 }
4140
4141 declare var DOMStringList: {
4142     prototype: DOMStringList;
4143     new(): DOMStringList;
4144 };
4145
4146 /** Used by the dataset HTML attribute to represent data for custom attributes added to elements. */
4147 interface DOMStringMap {
4148     [name: string]: string | undefined;
4149 }
4150
4151 declare var DOMStringMap: {
4152     prototype: DOMStringMap;
4153     new(): DOMStringMap;
4154 };
4155
4156 /** 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. */
4157 interface DOMTokenList {
4158     /**
4159      * Returns the number of tokens.
4160      */
4161     readonly length: number;
4162     /**
4163      * Returns the associated set as string.
4164      *
4165      * Can be set, to change the associated attribute.
4166      */
4167     value: string;
4168     toString(): string;
4169     /**
4170      * Adds all arguments passed, except those already present.
4171      *
4172      * Throws a "SyntaxError" DOMException if one of the arguments is the empty string.
4173      *
4174      * Throws an "InvalidCharacterError" DOMException if one of the arguments contains any ASCII whitespace.
4175      */
4176     add(...tokens: string[]): void;
4177     /**
4178      * Returns true if token is present, and false otherwise.
4179      */
4180     contains(token: string): boolean;
4181     /**
4182      * Returns the token with index index.
4183      */
4184     item(index: number): string | null;
4185     /**
4186      * Removes arguments passed, if they are present.
4187      *
4188      * Throws a "SyntaxError" DOMException if one of the arguments is the empty string.
4189      *
4190      * Throws an "InvalidCharacterError" DOMException if one of the arguments contains any ASCII whitespace.
4191      */
4192     remove(...tokens: string[]): void;
4193     /**
4194      * Replaces token with newToken.
4195      *
4196      * Returns true if token was replaced with newToken, and false otherwise.
4197      *
4198      * Throws a "SyntaxError" DOMException if one of the arguments is the empty string.
4199      *
4200      * Throws an "InvalidCharacterError" DOMException if one of the arguments contains any ASCII whitespace.
4201      */
4202     replace(oldToken: string, newToken: string): void;
4203     /**
4204      * Returns true if token is in the associated attribute's supported tokens. Returns false otherwise.
4205      *
4206      * Throws a TypeError if the associated attribute has no supported tokens defined.
4207      */
4208     supports(token: string): boolean;
4209     /**
4210      * 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()).
4211      *
4212      * Returns true if token is now present, and false otherwise.
4213      *
4214      * Throws a "SyntaxError" DOMException if token is empty.
4215      *
4216      * Throws an "InvalidCharacterError" DOMException if token contains any spaces.
4217      */
4218     toggle(token: string, force?: boolean): boolean;
4219     forEach(callbackfn: (value: string, key: number, parent: DOMTokenList) => void, thisArg?: any): void;
4220     [index: number]: string;
4221 }
4222
4223 declare var DOMTokenList: {
4224     prototype: DOMTokenList;
4225     new(): DOMTokenList;
4226 };
4227
4228 interface DataCue extends TextTrackCue {
4229     data: ArrayBuffer;
4230     addEventListener<K extends keyof TextTrackCueEventMap>(type: K, listener: (this: DataCue, ev: TextTrackCueEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
4231     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
4232     removeEventListener<K extends keyof TextTrackCueEventMap>(type: K, listener: (this: DataCue, ev: TextTrackCueEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
4233     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
4234 }
4235
4236 declare var DataCue: {
4237     prototype: DataCue;
4238     new(): DataCue;
4239 };
4240
4241 /** 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. */
4242 interface DataTransfer {
4243     /**
4244      * 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.
4245      *
4246      * Can be set, to change the selected operation.
4247      *
4248      * The possible values are "none", "copy", "link", and "move".
4249      */
4250     dropEffect: "none" | "copy" | "link" | "move";
4251     /**
4252      * Returns the kinds of operations that are to be allowed.
4253      *
4254      * Can be set (during the dragstart event), to change the allowed operations.
4255      *
4256      * The possible values are "none", "copy", "copyLink", "copyMove", "link", "linkMove", "move", "all", and "uninitialized",
4257      */
4258     effectAllowed: "none" | "copy" | "copyLink" | "copyMove" | "link" | "linkMove" | "move" | "all" | "uninitialized";
4259     /**
4260      * Returns a FileList of the files being dragged, if any.
4261      */
4262     readonly files: FileList;
4263     /**
4264      * Returns a DataTransferItemList object, with the drag data.
4265      */
4266     readonly items: DataTransferItemList;
4267     /**
4268      * 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".
4269      */
4270     readonly types: ReadonlyArray<string>;
4271     /**
4272      * Removes the data of the specified formats. Removes all data if the argument is omitted.
4273      */
4274     clearData(format?: string): void;
4275     /**
4276      * Returns the specified data. If there is no such data, returns the empty string.
4277      */
4278     getData(format: string): string;
4279     /**
4280      * Adds the specified data.
4281      */
4282     setData(format: string, data: string): void;
4283     /**
4284      * Uses the given element to update the drag feedback, replacing any previously specified feedback.
4285      */
4286     setDragImage(image: Element, x: number, y: number): void;
4287 }
4288
4289 declare var DataTransfer: {
4290     prototype: DataTransfer;
4291     new(): DataTransfer;
4292 };
4293
4294 /** 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. */
4295 interface DataTransferItem {
4296     /**
4297      * Returns the drag data item kind, one of: "string", "file".
4298      */
4299     readonly kind: string;
4300     /**
4301      * Returns the drag data item type string.
4302      */
4303     readonly type: string;
4304     /**
4305      * Returns a File object, if the drag data item kind is File.
4306      */
4307     getAsFile(): File | null;
4308     /**
4309      * Invokes the callback with the string data as the argument, if the drag data item kind is text.
4310      */
4311     getAsString(callback: FunctionStringCallback | null): void;
4312     webkitGetAsEntry(): any;
4313 }
4314
4315 declare var DataTransferItem: {
4316     prototype: DataTransferItem;
4317     new(): DataTransferItem;
4318 };
4319
4320 /** 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. */
4321 interface DataTransferItemList {
4322     /**
4323      * Returns the number of items in the drag data store.
4324      */
4325     readonly length: number;
4326     /**
4327      * 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.
4328      */
4329     add(data: string, type: string): DataTransferItem | null;
4330     add(data: File): DataTransferItem | null;
4331     /**
4332      * Removes all the entries in the drag data store.
4333      */
4334     clear(): void;
4335     item(index: number): DataTransferItem;
4336     /**
4337      * Removes the indexth entry in the drag data store.
4338      */
4339     remove(index: number): void;
4340     [name: number]: DataTransferItem;
4341 }
4342
4343 declare var DataTransferItemList: {
4344     prototype: DataTransferItemList;
4345     new(): DataTransferItemList;
4346 };
4347
4348 interface DeferredPermissionRequest {
4349     readonly id: number;
4350     readonly type: MSWebViewPermissionType;
4351     readonly uri: string;
4352     allow(): void;
4353     deny(): void;
4354 }
4355
4356 declare var DeferredPermissionRequest: {
4357     prototype: DeferredPermissionRequest;
4358     new(): DeferredPermissionRequest;
4359 };
4360
4361 /** 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. */
4362 interface DelayNode extends AudioNode {
4363     readonly delayTime: AudioParam;
4364 }
4365
4366 declare var DelayNode: {
4367     prototype: DelayNode;
4368     new(context: BaseAudioContext, options?: DelayOptions): DelayNode;
4369 };
4370
4371 /** Provides information about the amount of acceleration the device is experiencing along all three axes. */
4372 interface DeviceAcceleration {
4373     readonly x: number | null;
4374     readonly y: number | null;
4375     readonly z: number | null;
4376 }
4377
4378 declare var DeviceAcceleration: {
4379     prototype: DeviceAcceleration;
4380     new(): DeviceAcceleration;
4381 };
4382
4383 /** 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. */
4384 interface DeviceLightEvent extends Event {
4385     readonly value: number;
4386 }
4387
4388 declare var DeviceLightEvent: {
4389     prototype: DeviceLightEvent;
4390     new(typeArg: string, eventInitDict?: DeviceLightEventInit): DeviceLightEvent;
4391 };
4392
4393 /** The DeviceMotionEvent provides web developers with information about the speed of changes for the device's position and orientation. */
4394 interface DeviceMotionEvent extends Event {
4395     readonly acceleration: DeviceMotionEventAcceleration | null;
4396     readonly accelerationIncludingGravity: DeviceMotionEventAcceleration | null;
4397     readonly interval: number;
4398     readonly rotationRate: DeviceMotionEventRotationRate | null;
4399 }
4400
4401 declare var DeviceMotionEvent: {
4402     prototype: DeviceMotionEvent;
4403     new(type: string, eventInitDict?: DeviceMotionEventInit): DeviceMotionEvent;
4404     requestPermission(): Promise<PermissionState>;
4405 };
4406
4407 interface DeviceMotionEventAcceleration {
4408     readonly x: number | null;
4409     readonly y: number | null;
4410     readonly z: number | null;
4411 }
4412
4413 interface DeviceMotionEventRotationRate {
4414     readonly alpha: number | null;
4415     readonly beta: number | null;
4416     readonly gamma: number | null;
4417 }
4418
4419 /** The DeviceOrientationEvent provides web developers with information from the physical orientation of the device running the web page. */
4420 interface DeviceOrientationEvent extends Event {
4421     readonly absolute: boolean;
4422     readonly alpha: number | null;
4423     readonly beta: number | null;
4424     readonly gamma: number | null;
4425 }
4426
4427 declare var DeviceOrientationEvent: {
4428     prototype: DeviceOrientationEvent;
4429     new(type: string, eventInitDict?: DeviceOrientationEventInit): DeviceOrientationEvent;
4430     requestPermission(): Promise<PermissionState>;
4431 };
4432
4433 /** Provides information about the rate at which the device is rotating around all three axes. */
4434 interface DeviceRotationRate {
4435     readonly alpha: number | null;
4436     readonly beta: number | null;
4437     readonly gamma: number | null;
4438 }
4439
4440 declare var DeviceRotationRate: {
4441     prototype: DeviceRotationRate;
4442     new(): DeviceRotationRate;
4443 };
4444
4445 interface DhImportKeyParams extends Algorithm {
4446     generator: Uint8Array;
4447     prime: Uint8Array;
4448 }
4449
4450 interface DhKeyAlgorithm extends KeyAlgorithm {
4451     generator: Uint8Array;
4452     prime: Uint8Array;
4453 }
4454
4455 interface DhKeyDeriveParams extends Algorithm {
4456     public: CryptoKey;
4457 }
4458
4459 interface DhKeyGenParams extends Algorithm {
4460     generator: Uint8Array;
4461     prime: Uint8Array;
4462 }
4463
4464 interface DocumentEventMap extends GlobalEventHandlersEventMap, DocumentAndElementEventHandlersEventMap {
4465     "fullscreenchange": Event;
4466     "fullscreenerror": Event;
4467     "pointerlockchange": Event;
4468     "pointerlockerror": Event;
4469     "readystatechange": Event;
4470     "visibilitychange": Event;
4471 }
4472
4473 /** Any web page loaded in the browser and serves as an entry point into the web page's content, which is the DOM tree. */
4474 interface Document extends Node, DocumentAndElementEventHandlers, DocumentOrShadowRoot, GlobalEventHandlers, NonElementParentNode, ParentNode, XPathEvaluatorBase {
4475     /**
4476      * Sets or gets the URL for the current document.
4477      */
4478     readonly URL: string;
4479     /**
4480      * Sets or gets the color of all active links in the document.
4481      */
4482     /** @deprecated */
4483     alinkColor: string;
4484     /**
4485      * Returns a reference to the collection of elements contained by the object.
4486      */
4487     /** @deprecated */
4488     readonly all: HTMLAllCollection;
4489     /**
4490      * Retrieves a collection of all a objects that have a name and/or id property. Objects in this collection are in HTML source order.
4491      */
4492     /** @deprecated */
4493     readonly anchors: HTMLCollectionOf<HTMLAnchorElement>;
4494     /**
4495      * Retrieves a collection of all applet objects in the document.
4496      */
4497     /** @deprecated */
4498     readonly applets: HTMLCollectionOf<HTMLAppletElement>;
4499     /**
4500      * Deprecated. Sets or retrieves a value that indicates the background color behind the object.
4501      */
4502     /** @deprecated */
4503     bgColor: string;
4504     /**
4505      * Specifies the beginning and end of the document body.
4506      */
4507     body: HTMLElement;
4508     /**
4509      * Returns document's encoding.
4510      */
4511     readonly characterSet: string;
4512     /**
4513      * Gets or sets the character set used to encode the object.
4514      */
4515     readonly charset: string;
4516     /**
4517      * Gets a value that indicates whether standards-compliant mode is switched on for the object.
4518      */
4519     readonly compatMode: string;
4520     /**
4521      * Returns document's content type.
4522      */
4523     readonly contentType: string;
4524     /**
4525      * 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.
4526      *
4527      * Can be set, to add a new cookie to the element's set of HTTP cookies.
4528      *
4529      * 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.
4530      */
4531     cookie: string;
4532     /**
4533      * 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.
4534      *
4535      * 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.
4536      */
4537     readonly currentScript: HTMLOrSVGScriptElement | null;
4538     readonly defaultView: (WindowProxy & typeof globalThis) | null;
4539     /**
4540      * Sets or gets a value that indicates whether the document can be edited.
4541      */
4542     designMode: string;
4543     /**
4544      * Sets or retrieves a value that indicates the reading order of the object.
4545      */
4546     dir: string;
4547     /**
4548      * Gets an object representing the document type declaration associated with the current document.
4549      */
4550     readonly doctype: DocumentType | null;
4551     /**
4552      * Gets a reference to the root node of the document.
4553      */
4554     readonly documentElement: HTMLElement;
4555     /**
4556      * Returns document's URL.
4557      */
4558     readonly documentURI: string;
4559     /**
4560      * Sets or gets the security domain of the document.
4561      */
4562     domain: string;
4563     /**
4564      * Retrieves a collection of all embed objects in the document.
4565      */
4566     readonly embeds: HTMLCollectionOf<HTMLEmbedElement>;
4567     /**
4568      * Sets or gets the foreground (text) color of the document.
4569      */
4570     /** @deprecated */
4571     fgColor: string;
4572     /**
4573      * Retrieves a collection, in source order, of all form objects in the document.
4574      */
4575     readonly forms: HTMLCollectionOf<HTMLFormElement>;
4576     /** @deprecated */
4577     readonly fullscreen: boolean;
4578     /**
4579      * Returns true if document has the ability to display elements fullscreen and fullscreen is supported, or false otherwise.
4580      */
4581     readonly fullscreenEnabled: boolean;
4582     /**
4583      * Returns the head element.
4584      */
4585     readonly head: HTMLHeadElement;
4586     readonly hidden: boolean;
4587     /**
4588      * Retrieves a collection, in source order, of img objects in the document.
4589      */
4590     readonly images: HTMLCollectionOf<HTMLImageElement>;
4591     /**
4592      * Gets the implementation object of the current document.
4593      */
4594     readonly implementation: DOMImplementation;
4595     /**
4596      * Returns the character encoding used to create the webpage that is loaded into the document object.
4597      */
4598     readonly inputEncoding: string;
4599     /**
4600      * Gets the date that the page was last modified, if the page supplies one.
4601      */
4602     readonly lastModified: string;
4603     /**
4604      * Sets or gets the color of the document links.
4605      */
4606     /** @deprecated */
4607     linkColor: string;
4608     /**
4609      * Retrieves a collection of all a objects that specify the href property and all area objects in the document.
4610      */
4611     readonly links: HTMLCollectionOf<HTMLAnchorElement | HTMLAreaElement>;
4612     /**
4613      * Contains information about the current URL.
4614      */
4615     location: Location;
4616     onfullscreenchange: ((this: Document, ev: Event) => any) | null;
4617     onfullscreenerror: ((this: Document, ev: Event) => any) | null;
4618     onpointerlockchange: ((this: Document, ev: Event) => any) | null;
4619     onpointerlockerror: ((this: Document, ev: Event) => any) | null;
4620     /**
4621      * Fires when the state of the object has changed.
4622      * @param ev The event
4623      */
4624     onreadystatechange: ((this: Document, ev: Event) => any) | null;
4625     onvisibilitychange: ((this: Document, ev: Event) => any) | null;
4626     readonly ownerDocument: null;
4627     /**
4628      * Return an HTMLCollection of the embed elements in the Document.
4629      */
4630     readonly plugins: HTMLCollectionOf<HTMLEmbedElement>;
4631     /**
4632      * Retrieves a value that indicates the current state of the object.
4633      */
4634     readonly readyState: DocumentReadyState;
4635     /**
4636      * Gets the URL of the location that referred the user to the current page.
4637      */
4638     readonly referrer: string;
4639     /**
4640      * Retrieves a collection of all script objects in the document.
4641      */
4642     readonly scripts: HTMLCollectionOf<HTMLScriptElement>;
4643     readonly scrollingElement: Element | null;
4644     readonly timeline: DocumentTimeline;
4645     /**
4646      * Contains the title of the document.
4647      */
4648     title: string;
4649     readonly visibilityState: VisibilityState;
4650     /**
4651      * Sets or gets the color of the links that the user has visited.
4652      */
4653     /** @deprecated */
4654     vlinkColor: string;
4655     /**
4656      * Moves node from another document and returns it.
4657      *
4658      * If node is a document, throws a "NotSupportedError" DOMException or, if node is a shadow root, throws a "HierarchyRequestError" DOMException.
4659      */
4660     adoptNode<T extends Node>(source: T): T;
4661     /** @deprecated */
4662     captureEvents(): void;
4663     caretPositionFromPoint(x: number, y: number): CaretPosition | null;
4664     /** @deprecated */
4665     caretRangeFromPoint(x: number, y: number): Range;
4666     /** @deprecated */
4667     clear(): void;
4668     /**
4669      * Closes an output stream and forces the sent data to display.
4670      */
4671     close(): void;
4672     /**
4673      * Creates an attribute object with a specified name.
4674      * @param name String that sets the attribute object's name.
4675      */
4676     createAttribute(localName: string): Attr;
4677     createAttributeNS(namespace: string | null, qualifiedName: string): Attr;
4678     /**
4679      * Returns a CDATASection node whose data is data.
4680      */
4681     createCDATASection(data: string): CDATASection;
4682     /**
4683      * Creates a comment object with the specified data.
4684      * @param data Sets the comment object's data.
4685      */
4686     createComment(data: string): Comment;
4687     /**
4688      * Creates a new document.
4689      */
4690     createDocumentFragment(): DocumentFragment;
4691     /**
4692      * Creates an instance of the element for the specified tag.
4693      * @param tagName The name of an element.
4694      */
4695     createElement<K extends keyof HTMLElementTagNameMap>(tagName: K, options?: ElementCreationOptions): HTMLElementTagNameMap[K];
4696     /** @deprecated */
4697     createElement<K extends keyof HTMLElementDeprecatedTagNameMap>(tagName: K, options?: ElementCreationOptions): HTMLElementDeprecatedTagNameMap[K];
4698     createElement(tagName: string, options?: ElementCreationOptions): HTMLElement;
4699     /**
4700      * 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.
4701      *
4702      * If localName does not match the Name production an "InvalidCharacterError" DOMException will be thrown.
4703      *
4704      * If one of the following conditions is true a "NamespaceError" DOMException will be thrown:
4705      *
4706      * localName does not match the QName production.
4707      * Namespace prefix is not null and namespace is the empty string.
4708      * Namespace prefix is "xml" and namespace is not the XML namespace.
4709      * qualifiedName or namespace prefix is "xmlns" and namespace is not the XMLNS namespace.
4710      * namespace is the XMLNS namespace and neither qualifiedName nor namespace prefix is "xmlns".
4711      *
4712      * When supplied, options's is can be used to create a customized built-in element.
4713      */
4714     createElementNS(namespaceURI: "http://www.w3.org/1999/xhtml", qualifiedName: string): HTMLElement;
4715     createElementNS<K extends keyof SVGElementTagNameMap>(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: K): SVGElementTagNameMap[K];
4716     createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: string): SVGElement;
4717     createElementNS(namespaceURI: string | null, qualifiedName: string, options?: ElementCreationOptions): Element;
4718     createElementNS(namespace: string | null, qualifiedName: string, options?: string | ElementCreationOptions): Element;
4719     createEvent(eventInterface: "AnimationEvent"): AnimationEvent;
4720     createEvent(eventInterface: "AnimationPlaybackEvent"): AnimationPlaybackEvent;
4721     createEvent(eventInterface: "AudioProcessingEvent"): AudioProcessingEvent;
4722     createEvent(eventInterface: "BeforeUnloadEvent"): BeforeUnloadEvent;
4723     createEvent(eventInterface: "ClipboardEvent"): ClipboardEvent;
4724     createEvent(eventInterface: "CloseEvent"): CloseEvent;
4725     createEvent(eventInterface: "CompositionEvent"): CompositionEvent;
4726     createEvent(eventInterface: "CustomEvent"): CustomEvent;
4727     createEvent(eventInterface: "DeviceLightEvent"): DeviceLightEvent;
4728     createEvent(eventInterface: "DeviceMotionEvent"): DeviceMotionEvent;
4729     createEvent(eventInterface: "DeviceOrientationEvent"): DeviceOrientationEvent;
4730     createEvent(eventInterface: "DragEvent"): DragEvent;
4731     createEvent(eventInterface: "ErrorEvent"): ErrorEvent;
4732     createEvent(eventInterface: "Event"): Event;
4733     createEvent(eventInterface: "Events"): Event;
4734     createEvent(eventInterface: "FocusEvent"): FocusEvent;
4735     createEvent(eventInterface: "FocusNavigationEvent"): FocusNavigationEvent;
4736     createEvent(eventInterface: "GamepadEvent"): GamepadEvent;
4737     createEvent(eventInterface: "HashChangeEvent"): HashChangeEvent;
4738     createEvent(eventInterface: "IDBVersionChangeEvent"): IDBVersionChangeEvent;
4739     createEvent(eventInterface: "InputEvent"): InputEvent;
4740     createEvent(eventInterface: "KeyboardEvent"): KeyboardEvent;
4741     createEvent(eventInterface: "ListeningStateChangedEvent"): ListeningStateChangedEvent;
4742     createEvent(eventInterface: "MSGestureEvent"): MSGestureEvent;
4743     createEvent(eventInterface: "MSMediaKeyMessageEvent"): MSMediaKeyMessageEvent;
4744     createEvent(eventInterface: "MSMediaKeyNeededEvent"): MSMediaKeyNeededEvent;
4745     createEvent(eventInterface: "MSPointerEvent"): MSPointerEvent;
4746     createEvent(eventInterface: "MediaEncryptedEvent"): MediaEncryptedEvent;
4747     createEvent(eventInterface: "MediaKeyMessageEvent"): MediaKeyMessageEvent;
4748     createEvent(eventInterface: "MediaQueryListEvent"): MediaQueryListEvent;
4749     createEvent(eventInterface: "MediaStreamErrorEvent"): MediaStreamErrorEvent;
4750     createEvent(eventInterface: "MediaStreamEvent"): MediaStreamEvent;
4751     createEvent(eventInterface: "MediaStreamTrackEvent"): MediaStreamTrackEvent;
4752     createEvent(eventInterface: "MessageEvent"): MessageEvent;
4753     createEvent(eventInterface: "MouseEvent"): MouseEvent;
4754     createEvent(eventInterface: "MouseEvents"): MouseEvent;
4755     createEvent(eventInterface: "MutationEvent"): MutationEvent;
4756     createEvent(eventInterface: "MutationEvents"): MutationEvent;
4757     createEvent(eventInterface: "OfflineAudioCompletionEvent"): OfflineAudioCompletionEvent;
4758     createEvent(eventInterface: "OverflowEvent"): OverflowEvent;
4759     createEvent(eventInterface: "PageTransitionEvent"): PageTransitionEvent;
4760     createEvent(eventInterface: "PaymentRequestUpdateEvent"): PaymentRequestUpdateEvent;
4761     createEvent(eventInterface: "PermissionRequestedEvent"): PermissionRequestedEvent;
4762     createEvent(eventInterface: "PointerEvent"): PointerEvent;
4763     createEvent(eventInterface: "PopStateEvent"): PopStateEvent;
4764     createEvent(eventInterface: "ProgressEvent"): ProgressEvent;
4765     createEvent(eventInterface: "PromiseRejectionEvent"): PromiseRejectionEvent;
4766     createEvent(eventInterface: "RTCDTMFToneChangeEvent"): RTCDTMFToneChangeEvent;
4767     createEvent(eventInterface: "RTCDataChannelEvent"): RTCDataChannelEvent;
4768     createEvent(eventInterface: "RTCDtlsTransportStateChangedEvent"): RTCDtlsTransportStateChangedEvent;
4769     createEvent(eventInterface: "RTCErrorEvent"): RTCErrorEvent;
4770     createEvent(eventInterface: "RTCIceCandidatePairChangedEvent"): RTCIceCandidatePairChangedEvent;
4771     createEvent(eventInterface: "RTCIceGathererEvent"): RTCIceGathererEvent;
4772     createEvent(eventInterface: "RTCIceTransportStateChangedEvent"): RTCIceTransportStateChangedEvent;
4773     createEvent(eventInterface: "RTCPeerConnectionIceErrorEvent"): RTCPeerConnectionIceErrorEvent;
4774     createEvent(eventInterface: "RTCPeerConnectionIceEvent"): RTCPeerConnectionIceEvent;
4775     createEvent(eventInterface: "RTCSsrcConflictEvent"): RTCSsrcConflictEvent;
4776     createEvent(eventInterface: "RTCStatsEvent"): RTCStatsEvent;
4777     createEvent(eventInterface: "RTCTrackEvent"): RTCTrackEvent;
4778     createEvent(eventInterface: "SVGZoomEvent"): SVGZoomEvent;
4779     createEvent(eventInterface: "SVGZoomEvents"): SVGZoomEvent;
4780     createEvent(eventInterface: "SecurityPolicyViolationEvent"): SecurityPolicyViolationEvent;
4781     createEvent(eventInterface: "ServiceWorkerMessageEvent"): ServiceWorkerMessageEvent;
4782     createEvent(eventInterface: "SpeechRecognitionErrorEvent"): SpeechRecognitionErrorEvent;
4783     createEvent(eventInterface: "SpeechRecognitionEvent"): SpeechRecognitionEvent;
4784     createEvent(eventInterface: "SpeechSynthesisErrorEvent"): SpeechSynthesisErrorEvent;
4785     createEvent(eventInterface: "SpeechSynthesisEvent"): SpeechSynthesisEvent;
4786     createEvent(eventInterface: "StorageEvent"): StorageEvent;
4787     createEvent(eventInterface: "TextEvent"): TextEvent;
4788     createEvent(eventInterface: "TouchEvent"): TouchEvent;
4789     createEvent(eventInterface: "TrackEvent"): TrackEvent;
4790     createEvent(eventInterface: "TransitionEvent"): TransitionEvent;
4791     createEvent(eventInterface: "UIEvent"): UIEvent;
4792     createEvent(eventInterface: "UIEvents"): UIEvent;
4793     createEvent(eventInterface: "VRDisplayEvent"): VRDisplayEvent;
4794     createEvent(eventInterface: "VRDisplayEvent "): VRDisplayEvent ;
4795     createEvent(eventInterface: "WebGLContextEvent"): WebGLContextEvent;
4796     createEvent(eventInterface: "WheelEvent"): WheelEvent;
4797     createEvent(eventInterface: string): Event;
4798     /**
4799      * Creates a NodeIterator object that you can use to traverse filtered lists of nodes or elements in a document.
4800      * @param root The root element or node to start traversing on.
4801      * @param whatToShow The type of nodes or elements to appear in the node list
4802      * @param filter A custom NodeFilter function to use. For more information, see filter. Use null for no filter.
4803      * @param entityReferenceExpansion A flag that specifies whether entity reference nodes are expanded.
4804      */
4805     createNodeIterator(root: Node, whatToShow?: number, filter?: NodeFilter | null): NodeIterator;
4806     /**
4807      * 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.
4808      */
4809     createProcessingInstruction(target: string, data: string): ProcessingInstruction;
4810     /**
4811      *  Returns an empty range object that has both of its boundary points positioned at the beginning of the document.
4812      */
4813     createRange(): Range;
4814     /**
4815      * Creates a text string from the specified value.
4816      * @param data String that specifies the nodeValue property of the text node.
4817      */
4818     createTextNode(data: string): Text;
4819     /**
4820      * Creates a TreeWalker object that you can use to traverse filtered lists of nodes or elements in a document.
4821      * @param root The root element or node to start traversing on.
4822      * @param whatToShow The type of nodes or elements to appear in the node list. For more information, see whatToShow.
4823      * @param filter A custom NodeFilter function to use.
4824      * @param entityReferenceExpansion A flag that specifies whether entity reference nodes are expanded.
4825      */
4826     createTreeWalker(root: Node, whatToShow?: number, filter?: NodeFilter | null): TreeWalker;
4827     /** @deprecated */
4828     createTreeWalker(root: Node, whatToShow: number, filter: NodeFilter | null, entityReferenceExpansion?: boolean): TreeWalker;
4829     /**
4830      * Returns the element for the specified x coordinate and the specified y coordinate.
4831      * @param x The x-offset
4832      * @param y The y-offset
4833      */
4834     elementFromPoint(x: number, y: number): Element | null;
4835     elementsFromPoint(x: number, y: number): Element[];
4836     /**
4837      * Executes a command on the current document, current selection, or the given range.
4838      * @param commandId String that specifies the command to execute. This command can be any of the command identifiers that can be executed in script.
4839      * @param showUI Display the user interface, defaults to false.
4840      * @param value Value to assign.
4841      */
4842     execCommand(commandId: string, showUI?: boolean, value?: string): boolean;
4843     /**
4844      * Stops document's fullscreen element from being displayed fullscreen and resolves promise when done.
4845      */
4846     exitFullscreen(): Promise<void>;
4847     exitPointerLock(): void;
4848     getAnimations(): Animation[];
4849     /**
4850      * Returns a reference to the first object with the specified value of the ID attribute.
4851      * @param elementId String that specifies the ID value.
4852      */
4853     getElementById(elementId: string): HTMLElement | null;
4854     /**
4855      * 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.
4856      */
4857     getElementsByClassName(classNames: string): HTMLCollectionOf<Element>;
4858     /**
4859      * Gets a collection of objects based on the value of the NAME or ID attribute.
4860      * @param elementName Gets a collection of objects based on the value of the NAME or ID attribute.
4861      */
4862     getElementsByName(elementName: string): NodeListOf<HTMLElement>;
4863     /**
4864      * Retrieves a collection of objects based on the specified element name.
4865      * @param name Specifies the name of an element.
4866      */
4867     getElementsByTagName<K extends keyof HTMLElementTagNameMap>(qualifiedName: K): HTMLCollectionOf<HTMLElementTagNameMap[K]>;
4868     getElementsByTagName<K extends keyof SVGElementTagNameMap>(qualifiedName: K): HTMLCollectionOf<SVGElementTagNameMap[K]>;
4869     getElementsByTagName(qualifiedName: string): HTMLCollectionOf<Element>;
4870     /**
4871      * If namespace and localName are "*" returns a HTMLCollection of all descendant elements.
4872      *
4873      * If only namespace is "*" returns a HTMLCollection of all descendant elements whose local name is localName.
4874      *
4875      * If only localName is "*" returns a HTMLCollection of all descendant elements whose namespace is namespace.
4876      *
4877      * Otherwise, returns a HTMLCollection of all descendant elements whose namespace is namespace and local name is localName.
4878      */
4879     getElementsByTagNameNS(namespaceURI: "http://www.w3.org/1999/xhtml", localName: string): HTMLCollectionOf<HTMLElement>;
4880     getElementsByTagNameNS(namespaceURI: "http://www.w3.org/2000/svg", localName: string): HTMLCollectionOf<SVGElement>;
4881     getElementsByTagNameNS(namespaceURI: string, localName: string): HTMLCollectionOf<Element>;
4882     /**
4883      * Returns an object representing the current selection of the document that is loaded into the object displaying a webpage.
4884      */
4885     getSelection(): Selection | null;
4886     /**
4887      * Gets a value indicating whether the object currently has focus.
4888      */
4889     hasFocus(): boolean;
4890     /**
4891      * Returns a copy of node. If deep is true, the copy also includes the node's descendants.
4892      *
4893      * If node is a document or a shadow root, throws a "NotSupportedError" DOMException.
4894      */
4895     importNode<T extends Node>(importedNode: T, deep: boolean): T;
4896     /**
4897      * 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.
4898      * @param url Specifies a MIME type for the document.
4899      * @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.
4900      * @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.
4901      * @param replace Specifies whether the existing entry for the document is replaced in the history list.
4902      */
4903     open(url?: string, name?: string, features?: string, replace?: boolean): Document;
4904     /**
4905      * Returns a Boolean value that indicates whether a specified command can be successfully executed using execCommand, given the current state of the document.
4906      * @param commandId Specifies a command identifier.
4907      */
4908     queryCommandEnabled(commandId: string): boolean;
4909     /**
4910      * Returns a Boolean value that indicates whether the specified command is in the indeterminate state.
4911      * @param commandId String that specifies a command identifier.
4912      */
4913     queryCommandIndeterm(commandId: string): boolean;
4914     /**
4915      * Returns a Boolean value that indicates the current state of the command.
4916      * @param commandId String that specifies a command identifier.
4917      */
4918     queryCommandState(commandId: string): boolean;
4919     /**
4920      * Returns a Boolean value that indicates whether the current command is supported on the current range.
4921      * @param commandId Specifies a command identifier.
4922      */
4923     queryCommandSupported(commandId: string): boolean;
4924     /**
4925      * Returns the current value of the document, range, or current selection for the given command.
4926      * @param commandId String that specifies a command identifier.
4927      */
4928     queryCommandValue(commandId: string): string;
4929     /** @deprecated */
4930     releaseEvents(): void;
4931     /**
4932      * Writes one or more HTML expressions to a document in the specified window.
4933      * @param content Specifies the text and HTML tags to write.
4934      */
4935     write(...text: string[]): void;
4936     /**
4937      * Writes one or more HTML expressions, followed by a carriage return, to a document in the specified window.
4938      * @param content The text and HTML tags to write.
4939      */
4940     writeln(...text: string[]): void;
4941     addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
4942     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
4943     removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
4944     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
4945 }
4946
4947 declare var Document: {
4948     prototype: Document;
4949     new(): Document;
4950 };
4951
4952 interface DocumentAndElementEventHandlersEventMap {
4953     "copy": ClipboardEvent;
4954     "cut": ClipboardEvent;
4955     "paste": ClipboardEvent;
4956 }
4957
4958 interface DocumentAndElementEventHandlers {
4959     oncopy: ((this: DocumentAndElementEventHandlers, ev: ClipboardEvent) => any) | null;
4960     oncut: ((this: DocumentAndElementEventHandlers, ev: ClipboardEvent) => any) | null;
4961     onpaste: ((this: DocumentAndElementEventHandlers, ev: ClipboardEvent) => any) | null;
4962     addEventListener<K extends keyof DocumentAndElementEventHandlersEventMap>(type: K, listener: (this: DocumentAndElementEventHandlers, ev: DocumentAndElementEventHandlersEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
4963     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
4964     removeEventListener<K extends keyof DocumentAndElementEventHandlersEventMap>(type: K, listener: (this: DocumentAndElementEventHandlers, ev: DocumentAndElementEventHandlersEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
4965     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
4966 }
4967
4968 interface DocumentEvent {
4969     createEvent(eventInterface: "AnimationEvent"): AnimationEvent;
4970     createEvent(eventInterface: "AnimationPlaybackEvent"): AnimationPlaybackEvent;
4971     createEvent(eventInterface: "AudioProcessingEvent"): AudioProcessingEvent;
4972     createEvent(eventInterface: "BeforeUnloadEvent"): BeforeUnloadEvent;
4973     createEvent(eventInterface: "ClipboardEvent"): ClipboardEvent;
4974     createEvent(eventInterface: "CloseEvent"): CloseEvent;
4975     createEvent(eventInterface: "CompositionEvent"): CompositionEvent;
4976     createEvent(eventInterface: "CustomEvent"): CustomEvent;
4977     createEvent(eventInterface: "DeviceLightEvent"): DeviceLightEvent;
4978     createEvent(eventInterface: "DeviceMotionEvent"): DeviceMotionEvent;
4979     createEvent(eventInterface: "DeviceOrientationEvent"): DeviceOrientationEvent;
4980     createEvent(eventInterface: "DragEvent"): DragEvent;
4981     createEvent(eventInterface: "ErrorEvent"): ErrorEvent;
4982     createEvent(eventInterface: "Event"): Event;
4983     createEvent(eventInterface: "Events"): Event;
4984     createEvent(eventInterface: "FocusEvent"): FocusEvent;
4985     createEvent(eventInterface: "FocusNavigationEvent"): FocusNavigationEvent;
4986     createEvent(eventInterface: "GamepadEvent"): GamepadEvent;
4987     createEvent(eventInterface: "HashChangeEvent"): HashChangeEvent;
4988     createEvent(eventInterface: "IDBVersionChangeEvent"): IDBVersionChangeEvent;
4989     createEvent(eventInterface: "InputEvent"): InputEvent;
4990     createEvent(eventInterface: "KeyboardEvent"): KeyboardEvent;
4991     createEvent(eventInterface: "ListeningStateChangedEvent"): ListeningStateChangedEvent;
4992     createEvent(eventInterface: "MSGestureEvent"): MSGestureEvent;
4993     createEvent(eventInterface: "MSMediaKeyMessageEvent"): MSMediaKeyMessageEvent;
4994     createEvent(eventInterface: "MSMediaKeyNeededEvent"): MSMediaKeyNeededEvent;
4995     createEvent(eventInterface: "MSPointerEvent"): MSPointerEvent;
4996     createEvent(eventInterface: "MediaEncryptedEvent"): MediaEncryptedEvent;
4997     createEvent(eventInterface: "MediaKeyMessageEvent"): MediaKeyMessageEvent;
4998     createEvent(eventInterface: "MediaQueryListEvent"): MediaQueryListEvent;
4999     createEvent(eventInterface: "MediaStreamErrorEvent"): MediaStreamErrorEvent;
5000     createEvent(eventInterface: "MediaStreamEvent"): MediaStreamEvent;
5001     createEvent(eventInterface: "MediaStreamTrackEvent"): MediaStreamTrackEvent;
5002     createEvent(eventInterface: "MessageEvent"): MessageEvent;
5003     createEvent(eventInterface: "MouseEvent"): MouseEvent;
5004     createEvent(eventInterface: "MouseEvents"): MouseEvent;
5005     createEvent(eventInterface: "MutationEvent"): MutationEvent;
5006     createEvent(eventInterface: "MutationEvents"): MutationEvent;
5007     createEvent(eventInterface: "OfflineAudioCompletionEvent"): OfflineAudioCompletionEvent;
5008     createEvent(eventInterface: "OverflowEvent"): OverflowEvent;
5009     createEvent(eventInterface: "PageTransitionEvent"): PageTransitionEvent;
5010     createEvent(eventInterface: "PaymentRequestUpdateEvent"): PaymentRequestUpdateEvent;
5011     createEvent(eventInterface: "PermissionRequestedEvent"): PermissionRequestedEvent;
5012     createEvent(eventInterface: "PointerEvent"): PointerEvent;
5013     createEvent(eventInterface: "PopStateEvent"): PopStateEvent;
5014     createEvent(eventInterface: "ProgressEvent"): ProgressEvent;
5015     createEvent(eventInterface: "PromiseRejectionEvent"): PromiseRejectionEvent;
5016     createEvent(eventInterface: "RTCDTMFToneChangeEvent"): RTCDTMFToneChangeEvent;
5017     createEvent(eventInterface: "RTCDataChannelEvent"): RTCDataChannelEvent;
5018     createEvent(eventInterface: "RTCDtlsTransportStateChangedEvent"): RTCDtlsTransportStateChangedEvent;
5019     createEvent(eventInterface: "RTCErrorEvent"): RTCErrorEvent;
5020     createEvent(eventInterface: "RTCIceCandidatePairChangedEvent"): RTCIceCandidatePairChangedEvent;
5021     createEvent(eventInterface: "RTCIceGathererEvent"): RTCIceGathererEvent;
5022     createEvent(eventInterface: "RTCIceTransportStateChangedEvent"): RTCIceTransportStateChangedEvent;
5023     createEvent(eventInterface: "RTCPeerConnectionIceErrorEvent"): RTCPeerConnectionIceErrorEvent;
5024     createEvent(eventInterface: "RTCPeerConnectionIceEvent"): RTCPeerConnectionIceEvent;
5025     createEvent(eventInterface: "RTCSsrcConflictEvent"): RTCSsrcConflictEvent;
5026     createEvent(eventInterface: "RTCStatsEvent"): RTCStatsEvent;
5027     createEvent(eventInterface: "RTCTrackEvent"): RTCTrackEvent;
5028     createEvent(eventInterface: "SVGZoomEvent"): SVGZoomEvent;
5029     createEvent(eventInterface: "SVGZoomEvents"): SVGZoomEvent;
5030     createEvent(eventInterface: "SecurityPolicyViolationEvent"): SecurityPolicyViolationEvent;
5031     createEvent(eventInterface: "ServiceWorkerMessageEvent"): ServiceWorkerMessageEvent;
5032     createEvent(eventInterface: "SpeechRecognitionErrorEvent"): SpeechRecognitionErrorEvent;
5033     createEvent(eventInterface: "SpeechRecognitionEvent"): SpeechRecognitionEvent;
5034     createEvent(eventInterface: "SpeechSynthesisErrorEvent"): SpeechSynthesisErrorEvent;
5035     createEvent(eventInterface: "SpeechSynthesisEvent"): SpeechSynthesisEvent;
5036     createEvent(eventInterface: "StorageEvent"): StorageEvent;
5037     createEvent(eventInterface: "TextEvent"): TextEvent;
5038     createEvent(eventInterface: "TouchEvent"): TouchEvent;
5039     createEvent(eventInterface: "TrackEvent"): TrackEvent;
5040     createEvent(eventInterface: "TransitionEvent"): TransitionEvent;
5041     createEvent(eventInterface: "UIEvent"): UIEvent;
5042     createEvent(eventInterface: "UIEvents"): UIEvent;
5043     createEvent(eventInterface: "VRDisplayEvent"): VRDisplayEvent;
5044     createEvent(eventInterface: "VRDisplayEvent "): VRDisplayEvent ;
5045     createEvent(eventInterface: "WebGLContextEvent"): WebGLContextEvent;
5046     createEvent(eventInterface: "WheelEvent"): WheelEvent;
5047     createEvent(eventInterface: string): Event;
5048 }
5049
5050 /** 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. */
5051 interface DocumentFragment extends Node, NonElementParentNode, ParentNode {
5052     readonly ownerDocument: Document;
5053     getElementById(elementId: string): HTMLElement | null;
5054 }
5055
5056 declare var DocumentFragment: {
5057     prototype: DocumentFragment;
5058     new(): DocumentFragment;
5059 };
5060
5061 interface DocumentOrShadowRoot {
5062     readonly activeElement: Element | null;
5063     /**
5064      * Returns document's fullscreen element.
5065      */
5066     readonly fullscreenElement: Element | null;
5067     readonly pointerLockElement: Element | null;
5068     /**
5069      * Retrieves a collection of styleSheet objects representing the style sheets that correspond to each instance of a link or style object in the document.
5070      */
5071     readonly styleSheets: StyleSheetList;
5072     caretPositionFromPoint(x: number, y: number): CaretPosition | null;
5073     /** @deprecated */
5074     caretRangeFromPoint(x: number, y: number): Range;
5075     elementFromPoint(x: number, y: number): Element | null;
5076     elementsFromPoint(x: number, y: number): Element[];
5077     getSelection(): Selection | null;
5078 }
5079
5080 interface DocumentTimeline extends AnimationTimeline {
5081 }
5082
5083 declare var DocumentTimeline: {
5084     prototype: DocumentTimeline;
5085     new(options?: DocumentTimelineOptions): DocumentTimeline;
5086 };
5087
5088 /** A Node containing a doctype. */
5089 interface DocumentType extends Node, ChildNode {
5090     readonly name: string;
5091     readonly ownerDocument: Document;
5092     readonly publicId: string;
5093     readonly systemId: string;
5094 }
5095
5096 declare var DocumentType: {
5097     prototype: DocumentType;
5098     new(): DocumentType;
5099 };
5100
5101 /** 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. */
5102 interface DragEvent extends MouseEvent {
5103     /**
5104      * Returns the DataTransfer object for the event.
5105      */
5106     readonly dataTransfer: DataTransfer | null;
5107 }
5108
5109 declare var DragEvent: {
5110     prototype: DragEvent;
5111     new(type: string, eventInitDict?: DragEventInit): DragEvent;
5112 };
5113
5114 /** Inherits properties from its parent, AudioNode. */
5115 interface DynamicsCompressorNode extends AudioNode {
5116     readonly attack: AudioParam;
5117     readonly knee: AudioParam;
5118     readonly ratio: AudioParam;
5119     readonly reduction: number;
5120     readonly release: AudioParam;
5121     readonly threshold: AudioParam;
5122 }
5123
5124 declare var DynamicsCompressorNode: {
5125     prototype: DynamicsCompressorNode;
5126     new(context: BaseAudioContext, options?: DynamicsCompressorOptions): DynamicsCompressorNode;
5127 };
5128
5129 interface EXT_blend_minmax {
5130     readonly MAX_EXT: GLenum;
5131     readonly MIN_EXT: GLenum;
5132 }
5133
5134 /** 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. */
5135 interface EXT_frag_depth {
5136 }
5137
5138 interface EXT_sRGB {
5139     readonly FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT: GLenum;
5140     readonly SRGB8_ALPHA8_EXT: GLenum;
5141     readonly SRGB_ALPHA_EXT: GLenum;
5142     readonly SRGB_EXT: GLenum;
5143 }
5144
5145 interface EXT_shader_texture_lod {
5146 }
5147
5148 /** The EXT_texture_filter_anisotropic extension is part of the WebGL API and exposes two constants for anisotropic filtering (AF). */
5149 interface EXT_texture_filter_anisotropic {
5150     readonly MAX_TEXTURE_MAX_ANISOTROPY_EXT: GLenum;
5151     readonly TEXTURE_MAX_ANISOTROPY_EXT: GLenum;
5152 }
5153
5154 interface ElementEventMap {
5155     "fullscreenchange": Event;
5156     "fullscreenerror": Event;
5157 }
5158
5159 /** 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. */
5160 interface Element extends Node, Animatable, ChildNode, InnerHTML, NonDocumentTypeChildNode, ParentNode, Slottable {
5161     readonly attributes: NamedNodeMap;
5162     /**
5163      * Allows for manipulation of element's class content attribute as a set of whitespace-separated tokens through a DOMTokenList object.
5164      */
5165     readonly classList: DOMTokenList;
5166     /**
5167      * Returns the value of element's class content attribute. Can be set to change it.
5168      */
5169     className: string;
5170     readonly clientHeight: number;
5171     readonly clientLeft: number;
5172     readonly clientTop: number;
5173     readonly clientWidth: number;
5174     /**
5175      * Returns the value of element's id content attribute. Can be set to change it.
5176      */
5177     id: string;
5178     /**
5179      * Returns the local name.
5180      */
5181     readonly localName: string;
5182     /**
5183      * Returns the namespace.
5184      */
5185     readonly namespaceURI: string | null;
5186     onfullscreenchange: ((this: Element, ev: Event) => any) | null;
5187     onfullscreenerror: ((this: Element, ev: Event) => any) | null;
5188     outerHTML: string;
5189     readonly ownerDocument: Document;
5190     /**
5191      * Returns the namespace prefix.
5192      */
5193     readonly prefix: string | null;
5194     readonly scrollHeight: number;
5195     scrollLeft: number;
5196     scrollTop: number;
5197     readonly scrollWidth: number;
5198     /**
5199      * Returns element's shadow root, if any, and if shadow root's mode is "open", and null otherwise.
5200      */
5201     readonly shadowRoot: ShadowRoot | null;
5202     /**
5203      * Returns the value of element's slot content attribute. Can be set to change it.
5204      */
5205     slot: string;
5206     /**
5207      * Returns the HTML-uppercased qualified name.
5208      */
5209     readonly tagName: string;
5210     /**
5211      * Creates a shadow root for element and returns it.
5212      */
5213     attachShadow(init: ShadowRootInit): ShadowRoot;
5214     /**
5215      * Returns the first (starting at element) inclusive ancestor that matches selectors, and null otherwise.
5216      */
5217     closest<K extends keyof HTMLElementTagNameMap>(selector: K): HTMLElementTagNameMap[K] | null;
5218     closest<K extends keyof SVGElementTagNameMap>(selector: K): SVGElementTagNameMap[K] | null;
5219     closest<E extends Element = Element>(selector: string): E | null;
5220     /**
5221      * Returns element's first attribute whose qualified name is qualifiedName, and null if there is no such attribute otherwise.
5222      */
5223     getAttribute(qualifiedName: string): string | null;
5224     /**
5225      * Returns element's attribute whose namespace is namespace and local name is localName, and null if there is no such attribute otherwise.
5226      */
5227     getAttributeNS(namespace: string | null, localName: string): string | null;
5228     /**
5229      * Returns the qualified names of all element's attributes. Can contain duplicates.
5230      */
5231     getAttributeNames(): string[];
5232     getAttributeNode(qualifiedName: string): Attr | null;
5233     getAttributeNodeNS(namespace: string | null, localName: string): Attr | null;
5234     getBoundingClientRect(): DOMRect;
5235     getClientRects(): DOMRectList;
5236     /**
5237      * 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.
5238      */
5239     getElementsByClassName(classNames: string): HTMLCollectionOf<Element>;
5240     getElementsByTagName<K extends keyof HTMLElementTagNameMap>(qualifiedName: K): HTMLCollectionOf<HTMLElementTagNameMap[K]>;
5241     getElementsByTagName<K extends keyof SVGElementTagNameMap>(qualifiedName: K): HTMLCollectionOf<SVGElementTagNameMap[K]>;
5242     getElementsByTagName(qualifiedName: string): HTMLCollectionOf<Element>;
5243     getElementsByTagNameNS(namespaceURI: "http://www.w3.org/1999/xhtml", localName: string): HTMLCollectionOf<HTMLElement>;
5244     getElementsByTagNameNS(namespaceURI: "http://www.w3.org/2000/svg", localName: string): HTMLCollectionOf<SVGElement>;
5245     getElementsByTagNameNS(namespaceURI: string, localName: string): HTMLCollectionOf<Element>;
5246     /**
5247      * Returns true if element has an attribute whose qualified name is qualifiedName, and false otherwise.
5248      */
5249     hasAttribute(qualifiedName: string): boolean;
5250     /**
5251      * Returns true if element has an attribute whose namespace is namespace and local name is localName.
5252      */
5253     hasAttributeNS(namespace: string | null, localName: string): boolean;
5254     /**
5255      * Returns true if element has attributes, and false otherwise.
5256      */
5257     hasAttributes(): boolean;
5258     hasPointerCapture(pointerId: number): boolean;
5259     insertAdjacentElement(position: InsertPosition, insertedElement: Element): Element | null;
5260     insertAdjacentHTML(where: InsertPosition, html: string): void;
5261     insertAdjacentText(where: InsertPosition, text: string): void;
5262     /**
5263      * Returns true if matching selectors against element's root yields element, and false otherwise.
5264      */
5265     matches(selectors: string): boolean;
5266     msGetRegionContent(): any;
5267     releasePointerCapture(pointerId: number): void;
5268     /**
5269      * Removes element's first attribute whose qualified name is qualifiedName.
5270      */
5271     removeAttribute(qualifiedName: string): void;
5272     /**
5273      * Removes element's attribute whose namespace is namespace and local name is localName.
5274      */
5275     removeAttributeNS(namespace: string | null, localName: string): void;
5276     removeAttributeNode(attr: Attr): Attr;
5277     /**
5278      * Displays element fullscreen and resolves promise when done.
5279      *
5280      * 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.
5281      */
5282     requestFullscreen(options?: FullscreenOptions): Promise<void>;
5283     requestPointerLock(): void;
5284     scroll(options?: ScrollToOptions): void;
5285     scroll(x: number, y: number): void;
5286     scrollBy(options?: ScrollToOptions): void;
5287     scrollBy(x: number, y: number): void;
5288     scrollIntoView(arg?: boolean | ScrollIntoViewOptions): void;
5289     scrollTo(options?: ScrollToOptions): void;
5290     scrollTo(x: number, y: number): void;
5291     /**
5292      * Sets the value of element's first attribute whose qualified name is qualifiedName to value.
5293      */
5294     setAttribute(qualifiedName: string, value: string): void;
5295     /**
5296      * Sets the value of element's attribute whose namespace is namespace and local name is localName to value.
5297      */
5298     setAttributeNS(namespace: string | null, qualifiedName: string, value: string): void;
5299     setAttributeNode(attr: Attr): Attr | null;
5300     setAttributeNodeNS(attr: Attr): Attr | null;
5301     setPointerCapture(pointerId: number): void;
5302     /**
5303      * 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.
5304      *
5305      * Returns true if qualifiedName is now present, and false otherwise.
5306      */
5307     toggleAttribute(qualifiedName: string, force?: boolean): boolean;
5308     webkitMatchesSelector(selectors: string): boolean;
5309     addEventListener<K extends keyof ElementEventMap>(type: K, listener: (this: Element, ev: ElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
5310     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
5311     removeEventListener<K extends keyof ElementEventMap>(type: K, listener: (this: Element, ev: ElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
5312     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
5313 }
5314
5315 declare var Element: {
5316     prototype: Element;
5317     new(): Element;
5318 };
5319
5320 interface ElementCSSInlineStyle {
5321     readonly style: CSSStyleDeclaration;
5322 }
5323
5324 interface ElementContentEditable {
5325     contentEditable: string;
5326     enterKeyHint: string;
5327     inputMode: string;
5328     readonly isContentEditable: boolean;
5329 }
5330
5331 /** Events providing information related to errors in scripts or in files. */
5332 interface ErrorEvent extends Event {
5333     readonly colno: number;
5334     readonly error: any;
5335     readonly filename: string;
5336     readonly lineno: number;
5337     readonly message: string;
5338 }
5339
5340 declare var ErrorEvent: {
5341     prototype: ErrorEvent;
5342     new(type: string, eventInitDict?: ErrorEventInit): ErrorEvent;
5343 };
5344
5345 /** An event which takes place in the DOM. */
5346 interface Event {
5347     /**
5348      * 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.
5349      */
5350     readonly bubbles: boolean;
5351     cancelBubble: boolean;
5352     /**
5353      * 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.
5354      */
5355     readonly cancelable: boolean;
5356     /**
5357      * 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.
5358      */
5359     readonly composed: boolean;
5360     /**
5361      * Returns the object whose event listener's callback is currently being invoked.
5362      */
5363     readonly currentTarget: EventTarget | null;
5364     /**
5365      * Returns true if preventDefault() was invoked successfully to indicate cancelation, and false otherwise.
5366      */
5367     readonly defaultPrevented: boolean;
5368     /**
5369      * Returns the event's phase, which is one of NONE, CAPTURING_PHASE, AT_TARGET, and BUBBLING_PHASE.
5370      */
5371     readonly eventPhase: number;
5372     /**
5373      * Returns true if event was dispatched by the user agent, and false otherwise.
5374      */
5375     readonly isTrusted: boolean;
5376     returnValue: boolean;
5377     /** @deprecated */
5378     readonly srcElement: EventTarget | null;
5379     /**
5380      * Returns the object to which event is dispatched (its target).
5381      */
5382     readonly target: EventTarget | null;
5383     /**
5384      * Returns the event's timestamp as the number of milliseconds measured relative to the time origin.
5385      */
5386     readonly timeStamp: number;
5387     /**
5388      * Returns the type of event, e.g. "click", "hashchange", or "submit".
5389      */
5390     readonly type: string;
5391     /**
5392      * 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.
5393      */
5394     composedPath(): EventTarget[];
5395     initEvent(type: string, bubbles?: boolean, cancelable?: boolean): void;
5396     /**
5397      * 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.
5398      */
5399     preventDefault(): void;
5400     /**
5401      * 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.
5402      */
5403     stopImmediatePropagation(): void;
5404     /**
5405      * When dispatched in a tree, invoking this method prevents event from reaching any objects other than the current object.
5406      */
5407     stopPropagation(): void;
5408     readonly AT_TARGET: number;
5409     readonly BUBBLING_PHASE: number;
5410     readonly CAPTURING_PHASE: number;
5411     readonly NONE: number;
5412 }
5413
5414 declare var Event: {
5415     prototype: Event;
5416     new(type: string, eventInitDict?: EventInit): Event;
5417     readonly AT_TARGET: number;
5418     readonly BUBBLING_PHASE: number;
5419     readonly CAPTURING_PHASE: number;
5420     readonly NONE: number;
5421 };
5422
5423 interface EventListenerObject {
5424     handleEvent(evt: Event): void;
5425 }
5426
5427 interface EventSourceEventMap {
5428     "error": Event;
5429     "message": MessageEvent;
5430     "open": Event;
5431 }
5432
5433 interface EventSource extends EventTarget {
5434     onerror: ((this: EventSource, ev: Event) => any) | null;
5435     onmessage: ((this: EventSource, ev: MessageEvent) => any) | null;
5436     onopen: ((this: EventSource, ev: Event) => any) | null;
5437     /**
5438      * Returns the state of this EventSource object's connection. It can have the values described below.
5439      */
5440     readonly readyState: number;
5441     /**
5442      * Returns the URL providing the event stream.
5443      */
5444     readonly url: string;
5445     /**
5446      * Returns true if the credentials mode for connection requests to the URL providing the event stream is set to "include", and false otherwise.
5447      */
5448     readonly withCredentials: boolean;
5449     /**
5450      * Aborts any instances of the fetch algorithm started for this EventSource object, and sets the readyState attribute to CLOSED.
5451      */
5452     close(): void;
5453     readonly CLOSED: number;
5454     readonly CONNECTING: number;
5455     readonly OPEN: number;
5456     addEventListener<K extends keyof EventSourceEventMap>(type: K, listener: (this: EventSource, ev: EventSourceEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
5457     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
5458     removeEventListener<K extends keyof EventSourceEventMap>(type: K, listener: (this: EventSource, ev: EventSourceEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
5459     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
5460 }
5461
5462 declare var EventSource: {
5463     prototype: EventSource;
5464     new(url: string, eventSourceInitDict?: EventSourceInit): EventSource;
5465     readonly CLOSED: number;
5466     readonly CONNECTING: number;
5467     readonly OPEN: number;
5468 };
5469
5470 /** EventTarget is a DOM interface implemented by objects that can receive events and may have listeners for them. */
5471 interface EventTarget {
5472     /**
5473      * 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.
5474      *
5475      * 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.
5476      *
5477      * 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.
5478      *
5479      * 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.
5480      *
5481      * When set to true, options's once indicates that the callback will only be invoked once after which the event listener will be removed.
5482      *
5483      * The event listener is appended to target's event listener list and is not appended if it has the same type, callback, and capture.
5484      */
5485     addEventListener(type: string, listener: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions): void;
5486     /**
5487      * 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.
5488      */
5489     dispatchEvent(event: Event): boolean;
5490     /**
5491      * Removes the event listener in target's event listener list with the same type, callback, and options.
5492      */
5493     removeEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
5494 }
5495
5496 declare var EventTarget: {
5497     prototype: EventTarget;
5498     new(): EventTarget;
5499 };
5500
5501 interface ExtensionScriptApis {
5502     extensionIdToShortId(extensionId: string): number;
5503     fireExtensionApiTelemetry(functionName: string, isSucceeded: boolean, isSupported: boolean, errorString: string): void;
5504     genericFunction(routerAddress: any, parameters?: string, callbackId?: number): void;
5505     genericSynchronousFunction(functionId: number, parameters?: string): string;
5506     genericWebRuntimeCallout(to: any, from: any, payload: string): void;
5507     getExtensionId(): string;
5508     registerGenericFunctionCallbackHandler(callbackHandler: Function): void;
5509     registerGenericPersistentCallbackHandler(callbackHandler: Function): void;
5510     registerWebRuntimeCallbackHandler(handler: Function): any;
5511 }
5512
5513 declare var ExtensionScriptApis: {
5514     prototype: ExtensionScriptApis;
5515     new(): ExtensionScriptApis;
5516 };
5517
5518 interface External {
5519     /** @deprecated */
5520     AddSearchProvider(): void;
5521     /** @deprecated */
5522     IsSearchProviderInstalled(): void;
5523 }
5524
5525 declare var External: {
5526     prototype: External;
5527     new(): External;
5528 };
5529
5530 /** Provides information about files and allows JavaScript in a web page to access their content. */
5531 interface File extends Blob {
5532     readonly lastModified: number;
5533     readonly name: string;
5534 }
5535
5536 declare var File: {
5537     prototype: File;
5538     new(fileBits: BlobPart[], fileName: string, options?: FilePropertyBag): File;
5539 };
5540
5541 /** 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. */
5542 interface FileList {
5543     readonly length: number;
5544     item(index: number): File | null;
5545     [index: number]: File;
5546 }
5547
5548 declare var FileList: {
5549     prototype: FileList;
5550     new(): FileList;
5551 };
5552
5553 interface FileReaderEventMap {
5554     "abort": ProgressEvent<FileReader>;
5555     "error": ProgressEvent<FileReader>;
5556     "load": ProgressEvent<FileReader>;
5557     "loadend": ProgressEvent<FileReader>;
5558     "loadstart": ProgressEvent<FileReader>;
5559     "progress": ProgressEvent<FileReader>;
5560 }
5561
5562 /** 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. */
5563 interface FileReader extends EventTarget {
5564     readonly error: DOMException | null;
5565     onabort: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
5566     onerror: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
5567     onload: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
5568     onloadend: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
5569     onloadstart: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
5570     onprogress: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
5571     readonly readyState: number;
5572     readonly result: string | ArrayBuffer | null;
5573     abort(): void;
5574     readAsArrayBuffer(blob: Blob): void;
5575     readAsBinaryString(blob: Blob): void;
5576     readAsDataURL(blob: Blob): void;
5577     readAsText(blob: Blob, encoding?: string): void;
5578     readonly DONE: number;
5579     readonly EMPTY: number;
5580     readonly LOADING: number;
5581     addEventListener<K extends keyof FileReaderEventMap>(type: K, listener: (this: FileReader, ev: FileReaderEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
5582     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
5583     removeEventListener<K extends keyof FileReaderEventMap>(type: K, listener: (this: FileReader, ev: FileReaderEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
5584     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
5585 }
5586
5587 declare var FileReader: {
5588     prototype: FileReader;
5589     new(): FileReader;
5590     readonly DONE: number;
5591     readonly EMPTY: number;
5592     readonly LOADING: number;
5593 };
5594
5595 /** Focus-related events like focus, blur, focusin, or focusout. */
5596 interface FocusEvent extends UIEvent {
5597     readonly relatedTarget: EventTarget | null;
5598 }
5599
5600 declare var FocusEvent: {
5601     prototype: FocusEvent;
5602     new(type: string, eventInitDict?: FocusEventInit): FocusEvent;
5603 };
5604
5605 interface FocusNavigationEvent extends Event {
5606     readonly navigationReason: NavigationReason;
5607     readonly originHeight: number;
5608     readonly originLeft: number;
5609     readonly originTop: number;
5610     readonly originWidth: number;
5611     requestFocus(): void;
5612 }
5613
5614 declare var FocusNavigationEvent: {
5615     prototype: FocusNavigationEvent;
5616     new(type: string, eventInitDict?: FocusNavigationEventInit): FocusNavigationEvent;
5617 };
5618
5619 /** 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". */
5620 interface FormData {
5621     append(name: string, value: string | Blob, fileName?: string): void;
5622     delete(name: string): void;
5623     get(name: string): FormDataEntryValue | null;
5624     getAll(name: string): FormDataEntryValue[];
5625     has(name: string): boolean;
5626     set(name: string, value: string | Blob, fileName?: string): void;
5627     forEach(callbackfn: (value: FormDataEntryValue, key: string, parent: FormData) => void, thisArg?: any): void;
5628 }
5629
5630 declare var FormData: {
5631     prototype: FormData;
5632     new(form?: HTMLFormElement): FormData;
5633 };
5634
5635 /** 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. */
5636 interface GainNode extends AudioNode {
5637     readonly gain: AudioParam;
5638 }
5639
5640 declare var GainNode: {
5641     prototype: GainNode;
5642     new(context: BaseAudioContext, options?: GainOptions): GainNode;
5643 };
5644
5645 /** This Gamepad API interface defines an individual gamepad or other controller, allowing access to information such as button presses, axis positions, and id. */
5646 interface Gamepad {
5647     readonly axes: ReadonlyArray<number>;
5648     readonly buttons: ReadonlyArray<GamepadButton>;
5649     readonly connected: boolean;
5650     readonly hand: GamepadHand;
5651     readonly hapticActuators: ReadonlyArray<GamepadHapticActuator>;
5652     readonly id: string;
5653     readonly index: number;
5654     readonly mapping: GamepadMappingType;
5655     readonly pose: GamepadPose | null;
5656     readonly timestamp: number;
5657 }
5658
5659 declare var Gamepad: {
5660     prototype: Gamepad;
5661     new(): Gamepad;
5662 };
5663
5664 /** 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. */
5665 interface GamepadButton {
5666     readonly pressed: boolean;
5667     readonly touched: boolean;
5668     readonly value: number;
5669 }
5670
5671 declare var GamepadButton: {
5672     prototype: GamepadButton;
5673     new(): GamepadButton;
5674 };
5675
5676 /** 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. */
5677 interface GamepadEvent extends Event {
5678     readonly gamepad: Gamepad;
5679 }
5680
5681 declare var GamepadEvent: {
5682     prototype: GamepadEvent;
5683     new(type: string, eventInitDict: GamepadEventInit): GamepadEvent;
5684 };
5685
5686 /** This Gamepad API interface represents hardware in the controller designed to provide haptic feedback to the user (if available), most commonly vibration hardware. */
5687 interface GamepadHapticActuator {
5688     readonly type: GamepadHapticActuatorType;
5689     pulse(value: number, duration: number): Promise<boolean>;
5690 }
5691
5692 declare var GamepadHapticActuator: {
5693     prototype: GamepadHapticActuator;
5694     new(): GamepadHapticActuator;
5695 };
5696
5697 /** This Gamepad API interface represents the pose of a WebVR controller at a given timestamp (which includes orientation, position, velocity, and acceleration information.) */
5698 interface GamepadPose {
5699     readonly angularAcceleration: Float32Array | null;
5700     readonly angularVelocity: Float32Array | null;
5701     readonly hasOrientation: boolean;
5702     readonly hasPosition: boolean;
5703     readonly linearAcceleration: Float32Array | null;
5704     readonly linearVelocity: Float32Array | null;
5705     readonly orientation: Float32Array | null;
5706     readonly position: Float32Array | null;
5707 }
5708
5709 declare var GamepadPose: {
5710     prototype: GamepadPose;
5711     new(): GamepadPose;
5712 };
5713
5714 interface GenericTransformStream {
5715     readonly readable: ReadableStream;
5716     readonly writable: WritableStream;
5717 }
5718
5719 /** 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. */
5720 interface Geolocation {
5721     clearWatch(watchId: number): void;
5722     getCurrentPosition(successCallback: PositionCallback, errorCallback?: PositionErrorCallback, options?: PositionOptions): void;
5723     watchPosition(successCallback: PositionCallback, errorCallback?: PositionErrorCallback, options?: PositionOptions): number;
5724 }
5725
5726 declare var Geolocation: {
5727     prototype: Geolocation;
5728     new(): Geolocation;
5729 };
5730
5731 interface GeolocationCoordinates {
5732     readonly accuracy: number;
5733     readonly altitude: number | null;
5734     readonly altitudeAccuracy: number | null;
5735     readonly heading: number | null;
5736     readonly latitude: number;
5737     readonly longitude: number;
5738     readonly speed: number | null;
5739 }
5740
5741 declare var GeolocationCoordinates: {
5742     prototype: GeolocationCoordinates;
5743     new(): GeolocationCoordinates;
5744 };
5745
5746 interface GeolocationPosition {
5747     readonly coords: GeolocationCoordinates;
5748     readonly timestamp: number;
5749 }
5750
5751 declare var GeolocationPosition: {
5752     prototype: GeolocationPosition;
5753     new(): GeolocationPosition;
5754 };
5755
5756 interface GeolocationPositionError {
5757     readonly code: number;
5758     readonly message: string;
5759     readonly PERMISSION_DENIED: number;
5760     readonly POSITION_UNAVAILABLE: number;
5761     readonly TIMEOUT: number;
5762 }
5763
5764 declare var GeolocationPositionError: {
5765     prototype: GeolocationPositionError;
5766     new(): GeolocationPositionError;
5767     readonly PERMISSION_DENIED: number;
5768     readonly POSITION_UNAVAILABLE: number;
5769     readonly TIMEOUT: number;
5770 };
5771
5772 interface GlobalEventHandlersEventMap {
5773     "abort": UIEvent;
5774     "animationcancel": AnimationEvent;
5775     "animationend": AnimationEvent;
5776     "animationiteration": AnimationEvent;
5777     "animationstart": AnimationEvent;
5778     "auxclick": MouseEvent;
5779     "beforeinput": InputEvent;
5780     "blur": FocusEvent;
5781     "cancel": Event;
5782     "canplay": Event;
5783     "canplaythrough": Event;
5784     "change": Event;
5785     "click": MouseEvent;
5786     "close": Event;
5787     "compositionend": CompositionEvent;
5788     "compositionstart": CompositionEvent;
5789     "compositionupdate": CompositionEvent;
5790     "contextmenu": MouseEvent;
5791     "cuechange": Event;
5792     "dblclick": MouseEvent;
5793     "drag": DragEvent;
5794     "dragend": DragEvent;
5795     "dragenter": DragEvent;
5796     "dragexit": Event;
5797     "dragleave": DragEvent;
5798     "dragover": DragEvent;
5799     "dragstart": DragEvent;
5800     "drop": DragEvent;
5801     "durationchange": Event;
5802     "emptied": Event;
5803     "ended": Event;
5804     "error": ErrorEvent;
5805     "focus": FocusEvent;
5806     "focusin": FocusEvent;
5807     "focusout": FocusEvent;
5808     "gotpointercapture": PointerEvent;
5809     "input": Event;
5810     "invalid": Event;
5811     "keydown": KeyboardEvent;
5812     "keypress": KeyboardEvent;
5813     "keyup": KeyboardEvent;
5814     "load": Event;
5815     "loadeddata": Event;
5816     "loadedmetadata": Event;
5817     "loadstart": Event;
5818     "lostpointercapture": PointerEvent;
5819     "mousedown": MouseEvent;
5820     "mouseenter": MouseEvent;
5821     "mouseleave": MouseEvent;
5822     "mousemove": MouseEvent;
5823     "mouseout": MouseEvent;
5824     "mouseover": MouseEvent;
5825     "mouseup": MouseEvent;
5826     "pause": Event;
5827     "play": Event;
5828     "playing": Event;
5829     "pointercancel": PointerEvent;
5830     "pointerdown": PointerEvent;
5831     "pointerenter": PointerEvent;
5832     "pointerleave": PointerEvent;
5833     "pointermove": PointerEvent;
5834     "pointerout": PointerEvent;
5835     "pointerover": PointerEvent;
5836     "pointerup": PointerEvent;
5837     "progress": ProgressEvent;
5838     "ratechange": Event;
5839     "reset": Event;
5840     "resize": UIEvent;
5841     "scroll": Event;
5842     "securitypolicyviolation": SecurityPolicyViolationEvent;
5843     "seeked": Event;
5844     "seeking": Event;
5845     "select": Event;
5846     "selectionchange": Event;
5847     "selectstart": Event;
5848     "stalled": Event;
5849     "submit": Event;
5850     "suspend": Event;
5851     "timeupdate": Event;
5852     "toggle": Event;
5853     "touchcancel": TouchEvent;
5854     "touchend": TouchEvent;
5855     "touchmove": TouchEvent;
5856     "touchstart": TouchEvent;
5857     "transitioncancel": TransitionEvent;
5858     "transitionend": TransitionEvent;
5859     "transitionrun": TransitionEvent;
5860     "transitionstart": TransitionEvent;
5861     "volumechange": Event;
5862     "waiting": Event;
5863     "wheel": WheelEvent;
5864 }
5865
5866 interface GlobalEventHandlers {
5867     /**
5868      * Fires when the user aborts the download.
5869      * @param ev The event.
5870      */
5871     onabort: ((this: GlobalEventHandlers, ev: UIEvent) => any) | null;
5872     onanimationcancel: ((this: GlobalEventHandlers, ev: AnimationEvent) => any) | null;
5873     onanimationend: ((this: GlobalEventHandlers, ev: AnimationEvent) => any) | null;
5874     onanimationiteration: ((this: GlobalEventHandlers, ev: AnimationEvent) => any) | null;
5875     onanimationstart: ((this: GlobalEventHandlers, ev: AnimationEvent) => any) | null;
5876     onauxclick: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
5877     /**
5878      * Fires when the object loses the input focus.
5879      * @param ev The focus event.
5880      */
5881     onblur: ((this: GlobalEventHandlers, ev: FocusEvent) => any) | null;
5882     oncancel: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5883     /**
5884      * Occurs when playback is possible, but would require further buffering.
5885      * @param ev The event.
5886      */
5887     oncanplay: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5888     oncanplaythrough: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5889     /**
5890      * Fires when the contents of the object or selection have changed.
5891      * @param ev The event.
5892      */
5893     onchange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5894     /**
5895      * Fires when the user clicks the left mouse button on the object
5896      * @param ev The mouse event.
5897      */
5898     onclick: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
5899     onclose: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5900     /**
5901      * Fires when the user clicks the right mouse button in the client area, opening the context menu.
5902      * @param ev The mouse event.
5903      */
5904     oncontextmenu: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
5905     oncuechange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5906     /**
5907      * Fires when the user double-clicks the object.
5908      * @param ev The mouse event.
5909      */
5910     ondblclick: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
5911     /**
5912      * Fires on the source object continuously during a drag operation.
5913      * @param ev The event.
5914      */
5915     ondrag: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
5916     /**
5917      * Fires on the source object when the user releases the mouse at the close of a drag operation.
5918      * @param ev The event.
5919      */
5920     ondragend: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
5921     /**
5922      * Fires on the target element when the user drags the object to a valid drop target.
5923      * @param ev The drag event.
5924      */
5925     ondragenter: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
5926     ondragexit: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5927     /**
5928      * Fires on the target object when the user moves the mouse out of a valid drop target during a drag operation.
5929      * @param ev The drag event.
5930      */
5931     ondragleave: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
5932     /**
5933      * Fires on the target element continuously while the user drags the object over a valid drop target.
5934      * @param ev The event.
5935      */
5936     ondragover: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
5937     /**
5938      * Fires on the source object when the user starts to drag a text selection or selected object.
5939      * @param ev The event.
5940      */
5941     ondragstart: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
5942     ondrop: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
5943     /**
5944      * Occurs when the duration attribute is updated.
5945      * @param ev The event.
5946      */
5947     ondurationchange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5948     /**
5949      * Occurs when the media element is reset to its initial state.
5950      * @param ev The event.
5951      */
5952     onemptied: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5953     /**
5954      * Occurs when the end of playback is reached.
5955      * @param ev The event
5956      */
5957     onended: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5958     /**
5959      * Fires when an error occurs during object loading.
5960      * @param ev The event.
5961      */
5962     onerror: OnErrorEventHandler;
5963     /**
5964      * Fires when the object receives focus.
5965      * @param ev The event.
5966      */
5967     onfocus: ((this: GlobalEventHandlers, ev: FocusEvent) => any) | null;
5968     ongotpointercapture: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
5969     oninput: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5970     oninvalid: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5971     /**
5972      * Fires when the user presses a key.
5973      * @param ev The keyboard event
5974      */
5975     onkeydown: ((this: GlobalEventHandlers, ev: KeyboardEvent) => any) | null;
5976     /**
5977      * Fires when the user presses an alphanumeric key.
5978      * @param ev The event.
5979      */
5980     onkeypress: ((this: GlobalEventHandlers, ev: KeyboardEvent) => any) | null;
5981     /**
5982      * Fires when the user releases a key.
5983      * @param ev The keyboard event
5984      */
5985     onkeyup: ((this: GlobalEventHandlers, ev: KeyboardEvent) => any) | null;
5986     /**
5987      * Fires immediately after the browser loads the object.
5988      * @param ev The event.
5989      */
5990     onload: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5991     /**
5992      * Occurs when media data is loaded at the current playback position.
5993      * @param ev The event.
5994      */
5995     onloadeddata: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5996     /**
5997      * Occurs when the duration and dimensions of the media have been determined.
5998      * @param ev The event.
5999      */
6000     onloadedmetadata: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6001     /**
6002      * Occurs when Internet Explorer begins looking for media data.
6003      * @param ev The event.
6004      */
6005     onloadstart: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6006     onlostpointercapture: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
6007     /**
6008      * Fires when the user clicks the object with either mouse button.
6009      * @param ev The mouse event.
6010      */
6011     onmousedown: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
6012     onmouseenter: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
6013     onmouseleave: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
6014     /**
6015      * Fires when the user moves the mouse over the object.
6016      * @param ev The mouse event.
6017      */
6018     onmousemove: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
6019     /**
6020      * Fires when the user moves the mouse pointer outside the boundaries of the object.
6021      * @param ev The mouse event.
6022      */
6023     onmouseout: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
6024     /**
6025      * Fires when the user moves the mouse pointer into the object.
6026      * @param ev The mouse event.
6027      */
6028     onmouseover: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
6029     /**
6030      * Fires when the user releases a mouse button while the mouse is over the object.
6031      * @param ev The mouse event.
6032      */
6033     onmouseup: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
6034     /**
6035      * Occurs when playback is paused.
6036      * @param ev The event.
6037      */
6038     onpause: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6039     /**
6040      * Occurs when the play method is requested.
6041      * @param ev The event.
6042      */
6043     onplay: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6044     /**
6045      * Occurs when the audio or video has started playing.
6046      * @param ev The event.
6047      */
6048     onplaying: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6049     onpointercancel: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
6050     onpointerdown: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
6051     onpointerenter: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
6052     onpointerleave: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
6053     onpointermove: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
6054     onpointerout: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
6055     onpointerover: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
6056     onpointerup: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
6057     /**
6058      * Occurs to indicate progress while downloading media data.
6059      * @param ev The event.
6060      */
6061     onprogress: ((this: GlobalEventHandlers, ev: ProgressEvent) => any) | null;
6062     /**
6063      * Occurs when the playback rate is increased or decreased.
6064      * @param ev The event.
6065      */
6066     onratechange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6067     /**
6068      * Fires when the user resets a form.
6069      * @param ev The event.
6070      */
6071     onreset: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6072     onresize: ((this: GlobalEventHandlers, ev: UIEvent) => any) | null;
6073     /**
6074      * Fires when the user repositions the scroll box in the scroll bar on the object.
6075      * @param ev The event.
6076      */
6077     onscroll: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6078     onsecuritypolicyviolation: ((this: GlobalEventHandlers, ev: SecurityPolicyViolationEvent) => any) | null;
6079     /**
6080      * Occurs when the seek operation ends.
6081      * @param ev The event.
6082      */
6083     onseeked: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6084     /**
6085      * Occurs when the current playback position is moved.
6086      * @param ev The event.
6087      */
6088     onseeking: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6089     /**
6090      * Fires when the current selection changes.
6091      * @param ev The event.
6092      */
6093     onselect: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6094     onselectionchange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6095     onselectstart: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6096     /**
6097      * Occurs when the download has stopped.
6098      * @param ev The event.
6099      */
6100     onstalled: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6101     onsubmit: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6102     /**
6103      * Occurs if the load operation has been intentionally halted.
6104      * @param ev The event.
6105      */
6106     onsuspend: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6107     /**
6108      * Occurs to indicate the current playback position.
6109      * @param ev The event.
6110      */
6111     ontimeupdate: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6112     ontoggle: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6113     ontouchcancel?: ((this: GlobalEventHandlers, ev: TouchEvent) => any) | null;
6114     ontouchend?: ((this: GlobalEventHandlers, ev: TouchEvent) => any) | null;
6115     ontouchmove?: ((this: GlobalEventHandlers, ev: TouchEvent) => any) | null;
6116     ontouchstart?: ((this: GlobalEventHandlers, ev: TouchEvent) => any) | null;
6117     ontransitioncancel: ((this: GlobalEventHandlers, ev: TransitionEvent) => any) | null;
6118     ontransitionend: ((this: GlobalEventHandlers, ev: TransitionEvent) => any) | null;
6119     ontransitionrun: ((this: GlobalEventHandlers, ev: TransitionEvent) => any) | null;
6120     ontransitionstart: ((this: GlobalEventHandlers, ev: TransitionEvent) => any) | null;
6121     /**
6122      * Occurs when the volume is changed, or playback is muted or unmuted.
6123      * @param ev The event.
6124      */
6125     onvolumechange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6126     /**
6127      * Occurs when playback stops because the next frame of a video resource is not available.
6128      * @param ev The event.
6129      */
6130     onwaiting: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6131     onwheel: ((this: GlobalEventHandlers, ev: WheelEvent) => any) | null;
6132     addEventListener<K extends keyof GlobalEventHandlersEventMap>(type: K, listener: (this: GlobalEventHandlers, ev: GlobalEventHandlersEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6133     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6134     removeEventListener<K extends keyof GlobalEventHandlersEventMap>(type: K, listener: (this: GlobalEventHandlers, ev: GlobalEventHandlersEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6135     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6136 }
6137
6138 interface HTMLAllCollection {
6139     /**
6140      * Returns the number of elements in the collection.
6141      */
6142     readonly length: number;
6143     /**
6144      * Returns the item with index index from the collection (determined by tree order).
6145      */
6146     item(nameOrIndex?: string): HTMLCollection | Element | null;
6147     /**
6148      * Returns the item with ID or name name from the collection.
6149      *
6150      * If there are multiple matching items, then an HTMLCollection object containing all those elements is returned.
6151      *
6152      * 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.
6153      */
6154     namedItem(name: string): HTMLCollection | Element | null;
6155     [index: number]: Element;
6156 }
6157
6158 declare var HTMLAllCollection: {
6159     prototype: HTMLAllCollection;
6160     new(): HTMLAllCollection;
6161 };
6162
6163 /** 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. */
6164 interface HTMLAnchorElement extends HTMLElement, HTMLHyperlinkElementUtils {
6165     /**
6166      * Sets or retrieves the character set used to encode the object.
6167      */
6168     /** @deprecated */
6169     charset: string;
6170     /**
6171      * Sets or retrieves the coordinates of the object.
6172      */
6173     /** @deprecated */
6174     coords: string;
6175     download: string;
6176     /**
6177      * Sets or retrieves the language code of the object.
6178      */
6179     hreflang: string;
6180     /**
6181      * Sets or retrieves the shape of the object.
6182      */
6183     /** @deprecated */
6184     name: string;
6185     ping: string;
6186     referrerPolicy: string;
6187     /**
6188      * Sets or retrieves the relationship between the object and the destination of the link.
6189      */
6190     rel: string;
6191     readonly relList: DOMTokenList;
6192     /**
6193      * Sets or retrieves the relationship between the object and the destination of the link.
6194      */
6195     /** @deprecated */
6196     rev: string;
6197     /**
6198      * Sets or retrieves the shape of the object.
6199      */
6200     /** @deprecated */
6201     shape: string;
6202     /**
6203      * Sets or retrieves the window or frame at which to target content.
6204      */
6205     target: string;
6206     /**
6207      * Retrieves or sets the text of the object as a string.
6208      */
6209     text: string;
6210     type: string;
6211     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLAnchorElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6212     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6213     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLAnchorElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6214     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6215 }
6216
6217 declare var HTMLAnchorElement: {
6218     prototype: HTMLAnchorElement;
6219     new(): HTMLAnchorElement;
6220 };
6221
6222 interface HTMLAppletElement extends HTMLElement {
6223     /** @deprecated */
6224     align: string;
6225     /**
6226      * Sets or retrieves a text alternative to the graphic.
6227      */
6228     /** @deprecated */
6229     alt: string;
6230     /**
6231      * Sets or retrieves a character string that can be used to implement your own archive functionality for the object.
6232      */
6233     /** @deprecated */
6234     archive: string;
6235     /** @deprecated */
6236     code: string;
6237     /**
6238      * Sets or retrieves the URL of the component.
6239      */
6240     /** @deprecated */
6241     codeBase: string;
6242     readonly form: HTMLFormElement | null;
6243     /**
6244      * Sets or retrieves the height of the object.
6245      */
6246     /** @deprecated */
6247     height: string;
6248     /** @deprecated */
6249     hspace: number;
6250     /**
6251      * Sets or retrieves the shape of the object.
6252      */
6253     /** @deprecated */
6254     name: string;
6255     /** @deprecated */
6256     object: string;
6257     /** @deprecated */
6258     vspace: number;
6259     /** @deprecated */
6260     width: string;
6261     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLAppletElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6262     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6263     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLAppletElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6264     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6265 }
6266
6267 declare var HTMLAppletElement: {
6268     prototype: HTMLAppletElement;
6269     new(): HTMLAppletElement;
6270 };
6271
6272 /** 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. */
6273 interface HTMLAreaElement extends HTMLElement, HTMLHyperlinkElementUtils {
6274     /**
6275      * Sets or retrieves a text alternative to the graphic.
6276      */
6277     alt: string;
6278     /**
6279      * Sets or retrieves the coordinates of the object.
6280      */
6281     coords: string;
6282     download: string;
6283     /**
6284      * Sets or gets whether clicks in this region cause action.
6285      */
6286     /** @deprecated */
6287     noHref: boolean;
6288     ping: string;
6289     referrerPolicy: string;
6290     rel: string;
6291     readonly relList: DOMTokenList;
6292     /**
6293      * Sets or retrieves the shape of the object.
6294      */
6295     shape: string;
6296     /**
6297      * Sets or retrieves the window or frame at which to target content.
6298      */
6299     target: string;
6300     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLAreaElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6301     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6302     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLAreaElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6303     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6304 }
6305
6306 declare var HTMLAreaElement: {
6307     prototype: HTMLAreaElement;
6308     new(): HTMLAreaElement;
6309 };
6310
6311 /** Provides access to the properties of <audio> elements, as well as methods to manipulate them. It derives from the HTMLMediaElement interface. */
6312 interface HTMLAudioElement extends HTMLMediaElement {
6313     addEventListener<K extends keyof HTMLMediaElementEventMap>(type: K, listener: (this: HTMLAudioElement, ev: HTMLMediaElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6314     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6315     removeEventListener<K extends keyof HTMLMediaElementEventMap>(type: K, listener: (this: HTMLAudioElement, ev: HTMLMediaElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6316     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6317 }
6318
6319 declare var HTMLAudioElement: {
6320     prototype: HTMLAudioElement;
6321     new(): HTMLAudioElement;
6322 };
6323
6324 /** A HTML line break element (<br>). It inherits from HTMLElement. */
6325 interface HTMLBRElement extends HTMLElement {
6326     /**
6327      * Sets or retrieves the side on which floating objects are not to be positioned when any IHTMLBlockElement is inserted into the document.
6328      */
6329     /** @deprecated */
6330     clear: string;
6331     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLBRElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6332     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6333     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLBRElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6334     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6335 }
6336
6337 declare var HTMLBRElement: {
6338     prototype: HTMLBRElement;
6339     new(): HTMLBRElement;
6340 };
6341
6342 /** Contains the base URI for a document. This object inherits all of the properties and methods as described in the HTMLElement interface. */
6343 interface HTMLBaseElement extends HTMLElement {
6344     /**
6345      * Gets or sets the baseline URL on which relative links are based.
6346      */
6347     href: string;
6348     /**
6349      * Sets or retrieves the window or frame at which to target content.
6350      */
6351     target: string;
6352     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLBaseElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6353     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6354     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLBaseElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6355     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6356 }
6357
6358 declare var HTMLBaseElement: {
6359     prototype: HTMLBaseElement;
6360     new(): HTMLBaseElement;
6361 };
6362
6363 /** Provides special properties (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating <basefont> elements. */
6364 interface HTMLBaseFontElement extends HTMLElement, DOML2DeprecatedColorProperty {
6365     /**
6366      * Sets or retrieves the current typeface family.
6367      */
6368     /** @deprecated */
6369     face: string;
6370     /**
6371      * Sets or retrieves the font size of the object.
6372      */
6373     /** @deprecated */
6374     size: number;
6375     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLBaseFontElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6376     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6377     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLBaseFontElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6378     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6379 }
6380
6381 declare var HTMLBaseFontElement: {
6382     prototype: HTMLBaseFontElement;
6383     new(): HTMLBaseFontElement;
6384 };
6385
6386 interface HTMLBodyElementEventMap extends HTMLElementEventMap, WindowEventHandlersEventMap {
6387     "orientationchange": Event;
6388 }
6389
6390 /** Provides special properties (beyond those inherited from the regular HTMLElement interface) for manipulating <body> elements. */
6391 interface HTMLBodyElement extends HTMLElement, WindowEventHandlers {
6392     /** @deprecated */
6393     aLink: string;
6394     /** @deprecated */
6395     background: string;
6396     /** @deprecated */
6397     bgColor: string;
6398     /** @deprecated */
6399     link: string;
6400     /** @deprecated */
6401     onorientationchange: ((this: HTMLBodyElement, ev: Event) => any) | null;
6402     /** @deprecated */
6403     text: string;
6404     /** @deprecated */
6405     vLink: string;
6406     addEventListener<K extends keyof HTMLBodyElementEventMap>(type: K, listener: (this: HTMLBodyElement, ev: HTMLBodyElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6407     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6408     removeEventListener<K extends keyof HTMLBodyElementEventMap>(type: K, listener: (this: HTMLBodyElement, ev: HTMLBodyElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6409     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6410 }
6411
6412 declare var HTMLBodyElement: {
6413     prototype: HTMLBodyElement;
6414     new(): HTMLBodyElement;
6415 };
6416
6417 /** Provides properties and methods (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating <button> elements. */
6418 interface HTMLButtonElement extends HTMLElement {
6419     disabled: boolean;
6420     /**
6421      * Retrieves a reference to the form that the object is embedded in.
6422      */
6423     readonly form: HTMLFormElement | null;
6424     /**
6425      * Overrides the action attribute (where the data on a form is sent) on the parent form element.
6426      */
6427     formAction: string;
6428     /**
6429      * Used to override the encoding (formEnctype attribute) specified on the form element.
6430      */
6431     formEnctype: string;
6432     /**
6433      * Overrides the submit method attribute previously specified on a form element.
6434      */
6435     formMethod: string;
6436     /**
6437      * 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.
6438      */
6439     formNoValidate: boolean;
6440     /**
6441      * Overrides the target attribute on a form element.
6442      */
6443     formTarget: string;
6444     readonly labels: NodeListOf<HTMLLabelElement>;
6445     /**
6446      * Sets or retrieves the name of the object.
6447      */
6448     name: string;
6449     /**
6450      * Gets the classification and default behavior of the button.
6451      */
6452     type: string;
6453     /**
6454      * 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.
6455      */
6456     readonly validationMessage: string;
6457     /**
6458      * Returns a  ValidityState object that represents the validity states of an element.
6459      */
6460     readonly validity: ValidityState;
6461     /**
6462      * Sets or retrieves the default or selected value of the control.
6463      */
6464     value: string;
6465     /**
6466      * Returns whether an element will successfully validate based on forms validation rules and constraints.
6467      */
6468     readonly willValidate: boolean;
6469     /**
6470      * Returns whether a form will validate when it is submitted, without having to submit it.
6471      */
6472     checkValidity(): boolean;
6473     reportValidity(): boolean;
6474     /**
6475      * Sets a custom error message that is displayed when a form is submitted.
6476      * @param error Sets a custom error message that is displayed when a form is submitted.
6477      */
6478     setCustomValidity(error: string): void;
6479     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLButtonElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6480     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6481     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLButtonElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6482     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6483 }
6484
6485 declare var HTMLButtonElement: {
6486     prototype: HTMLButtonElement;
6487     new(): HTMLButtonElement;
6488 };
6489
6490 /** 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. */
6491 interface HTMLCanvasElement extends HTMLElement {
6492     /**
6493      * Gets or sets the height of a canvas element on a document.
6494      */
6495     height: number;
6496     /**
6497      * Gets or sets the width of a canvas element on a document.
6498      */
6499     width: number;
6500     /**
6501      * 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.
6502      * @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");
6503      */
6504     getContext(contextId: "2d", options?: CanvasRenderingContext2DSettings): CanvasRenderingContext2D | null;
6505     getContext(contextId: "bitmaprenderer", options?: ImageBitmapRenderingContextSettings): ImageBitmapRenderingContext | null;
6506     getContext(contextId: "webgl", options?: WebGLContextAttributes): WebGLRenderingContext | null;
6507     getContext(contextId: "webgl2", options?: WebGLContextAttributes): WebGL2RenderingContext | null;
6508     getContext(contextId: string, options?: any): RenderingContext | null;
6509     toBlob(callback: BlobCallback, type?: string, quality?: any): void;
6510     /**
6511      * Returns the content of the current canvas as an image that you can use as a source for another canvas or an HTML element.
6512      * @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.
6513      */
6514     toDataURL(type?: string, quality?: any): string;
6515     transferControlToOffscreen(): OffscreenCanvas;
6516     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLCanvasElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6517     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6518     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLCanvasElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6519     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6520 }
6521
6522 declare var HTMLCanvasElement: {
6523     prototype: HTMLCanvasElement;
6524     new(): HTMLCanvasElement;
6525 };
6526
6527 /** A generic collection (array-like object similar to arguments) of elements (in document order) and offers methods and properties for selecting from the list. */
6528 interface HTMLCollectionBase {
6529     /**
6530      * Sets or retrieves the number of objects in a collection.
6531      */
6532     readonly length: number;
6533     /**
6534      * Retrieves an object from various collections.
6535      */
6536     item(index: number): Element | null;
6537     [index: number]: Element;
6538 }
6539
6540 interface HTMLCollection extends HTMLCollectionBase {
6541     /**
6542      * Retrieves a select object or an object from an options collection.
6543      */
6544     namedItem(name: string): Element | null;
6545 }
6546
6547 declare var HTMLCollection: {
6548     prototype: HTMLCollection;
6549     new(): HTMLCollection;
6550 };
6551
6552 interface HTMLCollectionOf<T extends Element> extends HTMLCollectionBase {
6553     item(index: number): T | null;
6554     namedItem(name: string): T | null;
6555     [index: number]: T;
6556 }
6557
6558 /** Provides special properties (beyond those of the regular HTMLElement interface it also has available to it by inheritance) for manipulating definition list (<dl>) elements. */
6559 interface HTMLDListElement extends HTMLElement {
6560     /** @deprecated */
6561     compact: boolean;
6562     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDListElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6563     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6564     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDListElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6565     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6566 }
6567
6568 declare var HTMLDListElement: {
6569     prototype: HTMLDListElement;
6570     new(): HTMLDListElement;
6571 };
6572
6573 /** Provides special properties (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating <data> elements. */
6574 interface HTMLDataElement extends HTMLElement {
6575     value: string;
6576     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDataElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6577     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6578     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDataElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6579     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6580 }
6581
6582 declare var HTMLDataElement: {
6583     prototype: HTMLDataElement;
6584     new(): HTMLDataElement;
6585 };
6586
6587 /** Provides special properties (beyond the HTMLElement object interface it also has available to it by inheritance) to manipulate <datalist> elements and their content. */
6588 interface HTMLDataListElement extends HTMLElement {
6589     readonly options: HTMLCollectionOf<HTMLOptionElement>;
6590     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDataListElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6591     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6592     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDataListElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6593     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6594 }
6595
6596 declare var HTMLDataListElement: {
6597     prototype: HTMLDataListElement;
6598     new(): HTMLDataListElement;
6599 };
6600
6601 interface HTMLDetailsElement extends HTMLElement {
6602     open: boolean;
6603     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDetailsElement, 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: HTMLDetailsElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6606     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6607 }
6608
6609 declare var HTMLDetailsElement: {
6610     prototype: HTMLDetailsElement;
6611     new(): HTMLDetailsElement;
6612 };
6613
6614 interface HTMLDialogElement extends HTMLElement {
6615     open: boolean;
6616     returnValue: string;
6617     close(returnValue?: string): void;
6618     show(): void;
6619     showModal(): void;
6620     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDialogElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6621     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6622     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDialogElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6623     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6624 }
6625
6626 declare var HTMLDialogElement: {
6627     prototype: HTMLDialogElement;
6628     new(): HTMLDialogElement;
6629 };
6630
6631 interface HTMLDirectoryElement extends HTMLElement {
6632     /** @deprecated */
6633     compact: boolean;
6634     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDirectoryElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6635     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6636     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDirectoryElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6637     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6638 }
6639
6640 declare var HTMLDirectoryElement: {
6641     prototype: HTMLDirectoryElement;
6642     new(): HTMLDirectoryElement;
6643 };
6644
6645 /** Provides special properties (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating <div> elements. */
6646 interface HTMLDivElement extends HTMLElement {
6647     /**
6648      * Sets or retrieves how the object is aligned with adjacent text.
6649      */
6650     /** @deprecated */
6651     align: string;
6652     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDivElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6653     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6654     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDivElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6655     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6656 }
6657
6658 declare var HTMLDivElement: {
6659     prototype: HTMLDivElement;
6660     new(): HTMLDivElement;
6661 };
6662
6663 /** The HTMLDocument property of Window objects is an alias that browsers expose for the Document interface object. */
6664 interface HTMLDocument extends Document {
6665     addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: HTMLDocument, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6666     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6667     removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: HTMLDocument, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6668     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6669 }
6670
6671 declare var HTMLDocument: {
6672     prototype: HTMLDocument;
6673     new(): HTMLDocument;
6674 };
6675
6676 interface HTMLElementEventMap extends ElementEventMap, GlobalEventHandlersEventMap, DocumentAndElementEventHandlersEventMap {
6677 }
6678
6679 /** Any HTML element. Some elements directly implement this interface, while others implement it via an interface that inherits it. */
6680 interface HTMLElement extends Element, DocumentAndElementEventHandlers, ElementCSSInlineStyle, ElementCSSInlineStyle, ElementContentEditable, GlobalEventHandlers, HTMLOrSVGElement {
6681     accessKey: string;
6682     readonly accessKeyLabel: string;
6683     autocapitalize: string;
6684     dir: string;
6685     draggable: boolean;
6686     hidden: boolean;
6687     innerText: string;
6688     lang: string;
6689     readonly offsetHeight: number;
6690     readonly offsetLeft: number;
6691     readonly offsetParent: Element | null;
6692     readonly offsetTop: number;
6693     readonly offsetWidth: number;
6694     spellcheck: boolean;
6695     title: string;
6696     translate: boolean;
6697     click(): void;
6698     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6699     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6700     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6701     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6702 }
6703
6704 declare var HTMLElement: {
6705     prototype: HTMLElement;
6706     new(): HTMLElement;
6707 };
6708
6709 /** Provides special properties (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating <embed> elements. */
6710 interface HTMLEmbedElement extends HTMLElement {
6711     /** @deprecated */
6712     align: string;
6713     /**
6714      * Sets or retrieves the height of the object.
6715      */
6716     height: string;
6717     /**
6718      * Sets or retrieves the name of the object.
6719      */
6720     /** @deprecated */
6721     name: string;
6722     /**
6723      * Sets or retrieves a URL to be loaded by the object.
6724      */
6725     src: string;
6726     type: string;
6727     /**
6728      * Sets or retrieves the width of the object.
6729      */
6730     width: string;
6731     getSVGDocument(): Document | null;
6732     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLEmbedElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6733     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6734     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLEmbedElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6735     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6736 }
6737
6738 declare var HTMLEmbedElement: {
6739     prototype: HTMLEmbedElement;
6740     new(): HTMLEmbedElement;
6741 };
6742
6743 /** 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. */
6744 interface HTMLFieldSetElement extends HTMLElement {
6745     disabled: boolean;
6746     readonly elements: HTMLCollection;
6747     /**
6748      * Retrieves a reference to the form that the object is embedded in.
6749      */
6750     readonly form: HTMLFormElement | null;
6751     name: string;
6752     readonly type: string;
6753     /**
6754      * 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.
6755      */
6756     readonly validationMessage: string;
6757     /**
6758      * Returns a  ValidityState object that represents the validity states of an element.
6759      */
6760     readonly validity: ValidityState;
6761     /**
6762      * Returns whether an element will successfully validate based on forms validation rules and constraints.
6763      */
6764     readonly willValidate: boolean;
6765     /**
6766      * Returns whether a form will validate when it is submitted, without having to submit it.
6767      */
6768     checkValidity(): boolean;
6769     reportValidity(): boolean;
6770     /**
6771      * Sets a custom error message that is displayed when a form is submitted.
6772      * @param error Sets a custom error message that is displayed when a form is submitted.
6773      */
6774     setCustomValidity(error: string): void;
6775     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLFieldSetElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6776     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6777     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLFieldSetElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6778     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6779 }
6780
6781 declare var HTMLFieldSetElement: {
6782     prototype: HTMLFieldSetElement;
6783     new(): HTMLFieldSetElement;
6784 };
6785
6786 /** 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. */
6787 interface HTMLFontElement extends HTMLElement {
6788     /** @deprecated */
6789     color: string;
6790     /**
6791      * Sets or retrieves the current typeface family.
6792      */
6793     /** @deprecated */
6794     face: string;
6795     /** @deprecated */
6796     size: string;
6797     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLFontElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6798     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6799     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLFontElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6800     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6801 }
6802
6803 declare var HTMLFontElement: {
6804     prototype: HTMLFontElement;
6805     new(): HTMLFontElement;
6806 };
6807
6808 /** A collection of HTML form control elements.  */
6809 interface HTMLFormControlsCollection extends HTMLCollectionBase {
6810     /**
6811      * Returns the item with ID or name name from the collection.
6812      *
6813      * If there are multiple matching items, then a RadioNodeList object containing all those elements is returned.
6814      */
6815     namedItem(name: string): RadioNodeList | Element | null;
6816 }
6817
6818 declare var HTMLFormControlsCollection: {
6819     prototype: HTMLFormControlsCollection;
6820     new(): HTMLFormControlsCollection;
6821 };
6822
6823 /** 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. */
6824 interface HTMLFormElement extends HTMLElement {
6825     /**
6826      * Sets or retrieves a list of character encodings for input data that must be accepted by the server processing the form.
6827      */
6828     acceptCharset: string;
6829     /**
6830      * Sets or retrieves the URL to which the form content is sent for processing.
6831      */
6832     action: string;
6833     /**
6834      * Specifies whether autocomplete is applied to an editable text field.
6835      */
6836     autocomplete: string;
6837     /**
6838      * Retrieves a collection, in source order, of all controls in a given form.
6839      */
6840     readonly elements: HTMLFormControlsCollection;
6841     /**
6842      * Sets or retrieves the MIME encoding for the form.
6843      */
6844     encoding: string;
6845     /**
6846      * Sets or retrieves the encoding type for the form.
6847      */
6848     enctype: string;
6849     /**
6850      * Sets or retrieves the number of objects in a collection.
6851      */
6852     readonly length: number;
6853     /**
6854      * Sets or retrieves how to send the form data to the server.
6855      */
6856     method: string;
6857     /**
6858      * Sets or retrieves the name of the object.
6859      */
6860     name: string;
6861     /**
6862      * Designates a form that is not validated when submitted.
6863      */
6864     noValidate: boolean;
6865     /**
6866      * Sets or retrieves the window or frame at which to target content.
6867      */
6868     target: string;
6869     /**
6870      * Returns whether a form will validate when it is submitted, without having to submit it.
6871      */
6872     checkValidity(): boolean;
6873     reportValidity(): boolean;
6874     /**
6875      * Fires when the user resets a form.
6876      */
6877     reset(): void;
6878     /**
6879      * Fires when a FORM is about to be submitted.
6880      */
6881     submit(): void;
6882     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLFormElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6883     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6884     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLFormElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6885     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6886     [index: number]: Element;
6887     [name: string]: any;
6888 }
6889
6890 declare var HTMLFormElement: {
6891     prototype: HTMLFormElement;
6892     new(): HTMLFormElement;
6893 };
6894
6895 interface HTMLFrameElement extends HTMLElement {
6896     /**
6897      * Retrieves the document object of the page or frame.
6898      */
6899     /** @deprecated */
6900     readonly contentDocument: Document | null;
6901     /**
6902      * Retrieves the object of the specified.
6903      */
6904     /** @deprecated */
6905     readonly contentWindow: WindowProxy | null;
6906     /**
6907      * Sets or retrieves whether to display a border for the frame.
6908      */
6909     /** @deprecated */
6910     frameBorder: string;
6911     /**
6912      * Sets or retrieves a URI to a long description of the object.
6913      */
6914     /** @deprecated */
6915     longDesc: string;
6916     /**
6917      * Sets or retrieves the top and bottom margin heights before displaying the text in a frame.
6918      */
6919     /** @deprecated */
6920     marginHeight: string;
6921     /**
6922      * Sets or retrieves the left and right margin widths before displaying the text in a frame.
6923      */
6924     /** @deprecated */
6925     marginWidth: string;
6926     /**
6927      * Sets or retrieves the frame name.
6928      */
6929     /** @deprecated */
6930     name: string;
6931     /**
6932      * Sets or retrieves whether the user can resize the frame.
6933      */
6934     /** @deprecated */
6935     noResize: boolean;
6936     /**
6937      * Sets or retrieves whether the frame can be scrolled.
6938      */
6939     /** @deprecated */
6940     scrolling: string;
6941     /**
6942      * Sets or retrieves a URL to be loaded by the object.
6943      */
6944     /** @deprecated */
6945     src: string;
6946     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLFrameElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6947     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6948     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLFrameElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6949     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6950 }
6951
6952 declare var HTMLFrameElement: {
6953     prototype: HTMLFrameElement;
6954     new(): HTMLFrameElement;
6955 };
6956
6957 interface HTMLFrameSetElementEventMap extends HTMLElementEventMap, WindowEventHandlersEventMap {
6958 }
6959
6960 /** Provides special properties (beyond those of the regular HTMLElement interface they also inherit) for manipulating <frameset> elements. */
6961 interface HTMLFrameSetElement extends HTMLElement, WindowEventHandlers {
6962     /**
6963      * Sets or retrieves the frame widths of the object.
6964      */
6965     /** @deprecated */
6966     cols: string;
6967     /**
6968      * Sets or retrieves the frame heights of the object.
6969      */
6970     /** @deprecated */
6971     rows: string;
6972     addEventListener<K extends keyof HTMLFrameSetElementEventMap>(type: K, listener: (this: HTMLFrameSetElement, ev: HTMLFrameSetElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6973     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6974     removeEventListener<K extends keyof HTMLFrameSetElementEventMap>(type: K, listener: (this: HTMLFrameSetElement, ev: HTMLFrameSetElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6975     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6976 }
6977
6978 declare var HTMLFrameSetElement: {
6979     prototype: HTMLFrameSetElement;
6980     new(): HTMLFrameSetElement;
6981 };
6982
6983 /** Provides special properties (beyond those of the HTMLElement interface it also has available to it by inheritance) for manipulating <hr> elements. */
6984 interface HTMLHRElement extends HTMLElement {
6985     /**
6986      * Sets or retrieves how the object is aligned with adjacent text.
6987      */
6988     /** @deprecated */
6989     align: string;
6990     /** @deprecated */
6991     color: string;
6992     /**
6993      * Sets or retrieves whether the horizontal rule is drawn with 3-D shading.
6994      */
6995     /** @deprecated */
6996     noShade: boolean;
6997     /** @deprecated */
6998     size: string;
6999     /**
7000      * Sets or retrieves the width of the object.
7001      */
7002     /** @deprecated */
7003     width: string;
7004     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLHRElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7005     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7006     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLHRElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7007     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7008 }
7009
7010 declare var HTMLHRElement: {
7011     prototype: HTMLHRElement;
7012     new(): HTMLHRElement;
7013 };
7014
7015 /** Contains the descriptive information, or metadata, for a document. This object inherits all of the properties and methods described in the HTMLElement interface. */
7016 interface HTMLHeadElement extends HTMLElement {
7017     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLHeadElement, 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: HTMLHeadElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7020     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7021 }
7022
7023 declare var HTMLHeadElement: {
7024     prototype: HTMLHeadElement;
7025     new(): HTMLHeadElement;
7026 };
7027
7028 /** The different heading elements. It inherits methods and properties from the HTMLElement interface. */
7029 interface HTMLHeadingElement extends HTMLElement {
7030     /**
7031      * Sets or retrieves a value that indicates the table alignment.
7032      */
7033     /** @deprecated */
7034     align: string;
7035     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLHeadingElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7036     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7037     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLHeadingElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7038     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7039 }
7040
7041 declare var HTMLHeadingElement: {
7042     prototype: HTMLHeadingElement;
7043     new(): HTMLHeadingElement;
7044 };
7045
7046 /** Serves as the root node for a given HTML document. This object inherits the properties and methods described in the HTMLElement interface. */
7047 interface HTMLHtmlElement extends HTMLElement {
7048     /**
7049      * Sets or retrieves the DTD version that governs the current document.
7050      */
7051     /** @deprecated */
7052     version: string;
7053     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLHtmlElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7054     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7055     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLHtmlElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7056     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7057 }
7058
7059 declare var HTMLHtmlElement: {
7060     prototype: HTMLHtmlElement;
7061     new(): HTMLHtmlElement;
7062 };
7063
7064 interface HTMLHyperlinkElementUtils {
7065     hash: string;
7066     host: string;
7067     hostname: string;
7068     href: string;
7069     toString(): string;
7070     readonly origin: string;
7071     password: string;
7072     pathname: string;
7073     port: string;
7074     protocol: string;
7075     search: string;
7076     username: string;
7077 }
7078
7079 /** 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. */
7080 interface HTMLIFrameElement extends HTMLElement {
7081     /**
7082      * Sets or retrieves how the object is aligned with adjacent text.
7083      */
7084     /** @deprecated */
7085     align: string;
7086     allow: string;
7087     allowFullscreen: boolean;
7088     allowPaymentRequest: boolean;
7089     /**
7090      * Retrieves the document object of the page or frame.
7091      */
7092     readonly contentDocument: Document | null;
7093     /**
7094      * Retrieves the object of the specified.
7095      */
7096     readonly contentWindow: WindowProxy | null;
7097     /**
7098      * Sets or retrieves whether to display a border for the frame.
7099      */
7100     /** @deprecated */
7101     frameBorder: string;
7102     /**
7103      * Sets or retrieves the height of the object.
7104      */
7105     height: string;
7106     /**
7107      * Sets or retrieves a URI to a long description of the object.
7108      */
7109     /** @deprecated */
7110     longDesc: string;
7111     /**
7112      * Sets or retrieves the top and bottom margin heights before displaying the text in a frame.
7113      */
7114     /** @deprecated */
7115     marginHeight: string;
7116     /**
7117      * Sets or retrieves the left and right margin widths before displaying the text in a frame.
7118      */
7119     /** @deprecated */
7120     marginWidth: string;
7121     /**
7122      * Sets or retrieves the frame name.
7123      */
7124     name: string;
7125     referrerPolicy: ReferrerPolicy;
7126     readonly sandbox: DOMTokenList;
7127     /**
7128      * Sets or retrieves whether the frame can be scrolled.
7129      */
7130     /** @deprecated */
7131     scrolling: string;
7132     /**
7133      * Sets or retrieves a URL to be loaded by the object.
7134      */
7135     src: string;
7136     /**
7137      * Sets or retrives the content of the page that is to contain.
7138      */
7139     srcdoc: string;
7140     /**
7141      * Sets or retrieves the width of the object.
7142      */
7143     width: string;
7144     getSVGDocument(): Document | null;
7145     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLIFrameElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7146     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7147     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLIFrameElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7148     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7149 }
7150
7151 declare var HTMLIFrameElement: {
7152     prototype: HTMLIFrameElement;
7153     new(): HTMLIFrameElement;
7154 };
7155
7156 /** Provides special properties and methods for manipulating <img> elements. */
7157 interface HTMLImageElement extends HTMLElement {
7158     /**
7159      * Sets or retrieves how the object is aligned with adjacent text.
7160      */
7161     /** @deprecated */
7162     align: string;
7163     /**
7164      * Sets or retrieves a text alternative to the graphic.
7165      */
7166     alt: string;
7167     /**
7168      * Specifies the properties of a border drawn around an object.
7169      */
7170     /** @deprecated */
7171     border: string;
7172     /**
7173      * Retrieves whether the object is fully loaded.
7174      */
7175     readonly complete: boolean;
7176     crossOrigin: string | null;
7177     readonly currentSrc: string;
7178     decoding: "async" | "sync" | "auto";
7179     /**
7180      * Sets or retrieves the height of the object.
7181      */
7182     height: number;
7183     /**
7184      * Sets or retrieves the width of the border to draw around the object.
7185      */
7186     /** @deprecated */
7187     hspace: number;
7188     /**
7189      * Sets or retrieves whether the image is a server-side image map.
7190      */
7191     isMap: boolean;
7192     loading: string;
7193     /**
7194      * Sets or retrieves a Uniform Resource Identifier (URI) to a long description of the object.
7195      */
7196     /** @deprecated */
7197     longDesc: string;
7198     /** @deprecated */
7199     lowsrc: string;
7200     /**
7201      * Sets or retrieves the name of the object.
7202      */
7203     /** @deprecated */
7204     name: string;
7205     /**
7206      * The original height of the image resource before sizing.
7207      */
7208     readonly naturalHeight: number;
7209     /**
7210      * The original width of the image resource before sizing.
7211      */
7212     readonly naturalWidth: number;
7213     referrerPolicy: string;
7214     sizes: string;
7215     /**
7216      * The address or URL of the a media resource that is to be considered.
7217      */
7218     src: string;
7219     srcset: string;
7220     /**
7221      * Sets or retrieves the URL, often with a bookmark extension (#name), to use as a client-side image map.
7222      */
7223     useMap: string;
7224     /**
7225      * Sets or retrieves the vertical margin for the object.
7226      */
7227     /** @deprecated */
7228     vspace: number;
7229     /**
7230      * Sets or retrieves the width of the object.
7231      */
7232     width: number;
7233     readonly x: number;
7234     readonly y: number;
7235     decode(): Promise<void>;
7236     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLImageElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7237     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7238     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLImageElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7239     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7240 }
7241
7242 declare var HTMLImageElement: {
7243     prototype: HTMLImageElement;
7244     new(): HTMLImageElement;
7245 };
7246
7247 /** Provides special properties and methods for manipulating the options, layout, and presentation of <input> elements. */
7248 interface HTMLInputElement extends HTMLElement {
7249     /**
7250      * Sets or retrieves a comma-separated list of content types.
7251      */
7252     accept: string;
7253     /**
7254      * Sets or retrieves how the object is aligned with adjacent text.
7255      */
7256     /** @deprecated */
7257     align: string;
7258     /**
7259      * Sets or retrieves a text alternative to the graphic.
7260      */
7261     alt: string;
7262     /**
7263      * Specifies whether autocomplete is applied to an editable text field.
7264      */
7265     autocomplete: string;
7266     /**
7267      * Sets or retrieves the state of the check box or radio button.
7268      */
7269     checked: boolean;
7270     /**
7271      * Sets or retrieves the state of the check box or radio button.
7272      */
7273     defaultChecked: boolean;
7274     /**
7275      * Sets or retrieves the initial contents of the object.
7276      */
7277     defaultValue: string;
7278     dirName: string;
7279     disabled: boolean;
7280     /**
7281      * Returns a FileList object on a file type input object.
7282      */
7283     files: FileList | null;
7284     /**
7285      * Retrieves a reference to the form that the object is embedded in.
7286      */
7287     readonly form: HTMLFormElement | null;
7288     /**
7289      * Overrides the action attribute (where the data on a form is sent) on the parent form element.
7290      */
7291     formAction: string;
7292     /**
7293      * Used to override the encoding (formEnctype attribute) specified on the form element.
7294      */
7295     formEnctype: string;
7296     /**
7297      * Overrides the submit method attribute previously specified on a form element.
7298      */
7299     formMethod: string;
7300     /**
7301      * 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.
7302      */
7303     formNoValidate: boolean;
7304     /**
7305      * Overrides the target attribute on a form element.
7306      */
7307     formTarget: string;
7308     /**
7309      * Sets or retrieves the height of the object.
7310      */
7311     height: number;
7312     indeterminate: boolean;
7313     readonly labels: NodeListOf<HTMLLabelElement> | null;
7314     /**
7315      * Specifies the ID of a pre-defined datalist of options for an input element.
7316      */
7317     readonly list: HTMLElement | null;
7318     /**
7319      * 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.
7320      */
7321     max: string;
7322     /**
7323      * Sets or retrieves the maximum number of characters that the user can enter in a text control.
7324      */
7325     maxLength: number;
7326     /**
7327      * 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.
7328      */
7329     min: string;
7330     minLength: number;
7331     /**
7332      * Sets or retrieves the Boolean value indicating whether multiple items can be selected from a list.
7333      */
7334     multiple: boolean;
7335     /**
7336      * Sets or retrieves the name of the object.
7337      */
7338     name: string;
7339     /**
7340      * Gets or sets a string containing a regular expression that the user's input must match.
7341      */
7342     pattern: string;
7343     /**
7344      * 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.
7345      */
7346     placeholder: string;
7347     readOnly: boolean;
7348     /**
7349      * When present, marks an element that can't be submitted without a value.
7350      */
7351     required: boolean;
7352     selectionDirection: "forward" | "backward" | "none" | null;
7353     /**
7354      * Gets or sets the end position or offset of a text selection.
7355      */
7356     selectionEnd: number | null;
7357     /**
7358      * Gets or sets the starting position or offset of a text selection.
7359      */
7360     selectionStart: number | null;
7361     size: number;
7362     /**
7363      * The address or URL of the a media resource that is to be considered.
7364      */
7365     src: string;
7366     /**
7367      * 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.
7368      */
7369     step: string;
7370     /**
7371      * Returns the content type of the object.
7372      */
7373     type: string;
7374     /**
7375      * Sets or retrieves the URL, often with a bookmark extension (#name), to use as a client-side image map.
7376      */
7377     /** @deprecated */
7378     useMap: string;
7379     /**
7380      * 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.
7381      */
7382     readonly validationMessage: string;
7383     /**
7384      * Returns a  ValidityState object that represents the validity states of an element.
7385      */
7386     readonly validity: ValidityState;
7387     /**
7388      * Returns the value of the data at the cursor's current position.
7389      */
7390     value: string;
7391     /**
7392      * 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.
7393      */
7394     valueAsDate: Date | null;
7395     /**
7396      * Returns the input field value as a number.
7397      */
7398     valueAsNumber: number;
7399     /**
7400      * Sets or retrieves the width of the object.
7401      */
7402     width: number;
7403     /**
7404      * Returns whether an element will successfully validate based on forms validation rules and constraints.
7405      */
7406     readonly willValidate: boolean;
7407     /**
7408      * Returns whether a form will validate when it is submitted, without having to submit it.
7409      */
7410     checkValidity(): boolean;
7411     reportValidity(): boolean;
7412     /**
7413      * Makes the selection equal to the current object.
7414      */
7415     select(): void;
7416     /**
7417      * Sets a custom error message that is displayed when a form is submitted.
7418      * @param error Sets a custom error message that is displayed when a form is submitted.
7419      */
7420     setCustomValidity(error: string): void;
7421     setRangeText(replacement: string): void;
7422     setRangeText(replacement: string, start: number, end: number, selectionMode?: SelectionMode): void;
7423     /**
7424      * Sets the start and end positions of a selection in a text field.
7425      * @param start The offset into the text field for the start of the selection.
7426      * @param end The offset into the text field for the end of the selection.
7427      * @param direction The direction in which the selection is performed.
7428      */
7429     setSelectionRange(start: number | null, end: number | null, direction?: "forward" | "backward" | "none"): void;
7430     /**
7431      * 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.
7432      * @param n Value to decrement the value by.
7433      */
7434     stepDown(n?: number): void;
7435     /**
7436      * 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.
7437      * @param n Value to increment the value by.
7438      */
7439     stepUp(n?: number): void;
7440     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLInputElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7441     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7442     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLInputElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7443     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7444 }
7445
7446 declare var HTMLInputElement: {
7447     prototype: HTMLInputElement;
7448     new(): HTMLInputElement;
7449 };
7450
7451 /** Exposes specific properties and methods (beyond those defined by regular HTMLElement interface it also has available to it by inheritance) for manipulating list elements. */
7452 interface HTMLLIElement extends HTMLElement {
7453     /** @deprecated */
7454     type: string;
7455     /**
7456      * Sets or retrieves the value of a list item.
7457      */
7458     value: number;
7459     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLLIElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7460     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7461     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLLIElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7462     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7463 }
7464
7465 declare var HTMLLIElement: {
7466     prototype: HTMLLIElement;
7467     new(): HTMLLIElement;
7468 };
7469
7470 /** Gives access to properties specific to <label> elements. It inherits methods and properties from the base HTMLElement interface. */
7471 interface HTMLLabelElement extends HTMLElement {
7472     readonly control: HTMLElement | null;
7473     /**
7474      * Retrieves a reference to the form that the object is embedded in.
7475      */
7476     readonly form: HTMLFormElement | null;
7477     /**
7478      * Sets or retrieves the object to which the given label object is assigned.
7479      */
7480     htmlFor: string;
7481     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLLabelElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7482     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7483     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLLabelElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7484     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7485 }
7486
7487 declare var HTMLLabelElement: {
7488     prototype: HTMLLabelElement;
7489     new(): HTMLLabelElement;
7490 };
7491
7492 /** The HTMLLegendElement is an interface allowing to access properties of the <legend> elements. It inherits properties and methods from the HTMLElement interface. */
7493 interface HTMLLegendElement extends HTMLElement {
7494     /** @deprecated */
7495     align: string;
7496     /**
7497      * Retrieves a reference to the form that the object is embedded in.
7498      */
7499     readonly form: HTMLFormElement | null;
7500     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLLegendElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7501     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7502     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLLegendElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7503     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7504 }
7505
7506 declare var HTMLLegendElement: {
7507     prototype: HTMLLegendElement;
7508     new(): HTMLLegendElement;
7509 };
7510
7511 /** 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. */
7512 interface HTMLLinkElement extends HTMLElement, LinkStyle {
7513     as: string;
7514     /**
7515      * Sets or retrieves the character set used to encode the object.
7516      */
7517     /** @deprecated */
7518     charset: string;
7519     crossOrigin: string | null;
7520     disabled: boolean;
7521     /**
7522      * Sets or retrieves a destination URL or an anchor point.
7523      */
7524     href: string;
7525     /**
7526      * Sets or retrieves the language code of the object.
7527      */
7528     hreflang: string;
7529     imageSizes: string;
7530     imageSrcset: string;
7531     integrity: string;
7532     /**
7533      * Sets or retrieves the media type.
7534      */
7535     media: string;
7536     referrerPolicy: string;
7537     /**
7538      * Sets or retrieves the relationship between the object and the destination of the link.
7539      */
7540     rel: string;
7541     readonly relList: DOMTokenList;
7542     /**
7543      * Sets or retrieves the relationship between the object and the destination of the link.
7544      */
7545     /** @deprecated */
7546     rev: string;
7547     readonly sizes: DOMTokenList;
7548     /**
7549      * Sets or retrieves the window or frame at which to target content.
7550      */
7551     /** @deprecated */
7552     target: string;
7553     /**
7554      * Sets or retrieves the MIME type of the object.
7555      */
7556     type: string;
7557     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLLinkElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7558     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7559     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLLinkElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7560     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7561 }
7562
7563 declare var HTMLLinkElement: {
7564     prototype: HTMLLinkElement;
7565     new(): HTMLLinkElement;
7566 };
7567
7568 /** 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. */
7569 interface HTMLMapElement extends HTMLElement {
7570     /**
7571      * Retrieves a collection of the area objects defined for the given map object.
7572      */
7573     readonly areas: HTMLCollection;
7574     /**
7575      * Sets or retrieves the name of the object.
7576      */
7577     name: string;
7578     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLMapElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7579     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7580     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLMapElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7581     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7582 }
7583
7584 declare var HTMLMapElement: {
7585     prototype: HTMLMapElement;
7586     new(): HTMLMapElement;
7587 };
7588
7589 interface HTMLMarqueeElementEventMap extends HTMLElementEventMap {
7590     "bounce": Event;
7591     "finish": Event;
7592     "start": Event;
7593 }
7594
7595 /** Provides methods to manipulate <marquee> elements. */
7596 interface HTMLMarqueeElement extends HTMLElement {
7597     /** @deprecated */
7598     behavior: string;
7599     /** @deprecated */
7600     bgColor: string;
7601     /** @deprecated */
7602     direction: string;
7603     /** @deprecated */
7604     height: string;
7605     /** @deprecated */
7606     hspace: number;
7607     /** @deprecated */
7608     loop: number;
7609     /** @deprecated */
7610     onbounce: ((this: HTMLMarqueeElement, ev: Event) => any) | null;
7611     /** @deprecated */
7612     onfinish: ((this: HTMLMarqueeElement, ev: Event) => any) | null;
7613     /** @deprecated */
7614     onstart: ((this: HTMLMarqueeElement, ev: Event) => any) | null;
7615     /** @deprecated */
7616     scrollAmount: number;
7617     /** @deprecated */
7618     scrollDelay: number;
7619     /** @deprecated */
7620     trueSpeed: boolean;
7621     /** @deprecated */
7622     vspace: number;
7623     /** @deprecated */
7624     width: string;
7625     /** @deprecated */
7626     start(): void;
7627     /** @deprecated */
7628     stop(): void;
7629     addEventListener<K extends keyof HTMLMarqueeElementEventMap>(type: K, listener: (this: HTMLMarqueeElement, ev: HTMLMarqueeElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7630     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7631     removeEventListener<K extends keyof HTMLMarqueeElementEventMap>(type: K, listener: (this: HTMLMarqueeElement, ev: HTMLMarqueeElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7632     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7633 }
7634
7635 declare var HTMLMarqueeElement: {
7636     prototype: HTMLMarqueeElement;
7637     new(): HTMLMarqueeElement;
7638 };
7639
7640 interface HTMLMediaElementEventMap extends HTMLElementEventMap {
7641     "encrypted": MediaEncryptedEvent;
7642     "waitingforkey": Event;
7643 }
7644
7645 /** Adds to HTMLElement the properties and methods needed to support basic media-related capabilities that are common to audio and video. */
7646 interface HTMLMediaElement extends HTMLElement {
7647     /**
7648      * Gets or sets a value that indicates whether to start playing the media automatically.
7649      */
7650     autoplay: boolean;
7651     /**
7652      * Gets a collection of buffered time ranges.
7653      */
7654     readonly buffered: TimeRanges;
7655     /**
7656      * 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).
7657      */
7658     controls: boolean;
7659     crossOrigin: string | null;
7660     /**
7661      * Gets the address or URL of the current media resource that is selected by IHTMLMediaElement.
7662      */
7663     readonly currentSrc: string;
7664     /**
7665      * Gets or sets the current playback position, in seconds.
7666      */
7667     currentTime: number;
7668     defaultMuted: boolean;
7669     /**
7670      * Gets or sets the default playback rate when the user is not using fast forward or reverse for a video or audio resource.
7671      */
7672     defaultPlaybackRate: number;
7673     /**
7674      * 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.
7675      */
7676     readonly duration: number;
7677     /**
7678      * Gets information about whether the playback has ended or not.
7679      */
7680     readonly ended: boolean;
7681     /**
7682      * Returns an object representing the current error state of the audio or video element.
7683      */
7684     readonly error: MediaError | null;
7685     /**
7686      * Gets or sets a flag to specify whether playback should restart after it completes.
7687      */
7688     loop: boolean;
7689     readonly mediaKeys: MediaKeys | null;
7690     /**
7691      * Gets or sets a flag that indicates whether the audio (either audio or the audio track on video media) is muted.
7692      */
7693     muted: boolean;
7694     /**
7695      * Gets the current network activity for the element.
7696      */
7697     readonly networkState: number;
7698     onencrypted: ((this: HTMLMediaElement, ev: MediaEncryptedEvent) => any) | null;
7699     onwaitingforkey: ((this: HTMLMediaElement, ev: Event) => any) | null;
7700     /**
7701      * Gets a flag that specifies whether playback is paused.
7702      */
7703     readonly paused: boolean;
7704     /**
7705      * 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.
7706      */
7707     playbackRate: number;
7708     /**
7709      * Gets TimeRanges for the current media resource that has been played.
7710      */
7711     readonly played: TimeRanges;
7712     /**
7713      * Gets or sets the current playback position, in seconds.
7714      */
7715     preload: string;
7716     readonly readyState: number;
7717     /**
7718      * Returns a TimeRanges object that represents the ranges of the current media resource that can be seeked.
7719      */
7720     readonly seekable: TimeRanges;
7721     /**
7722      * Gets a flag that indicates whether the client is currently moving to a new playback position in the media resource.
7723      */
7724     readonly seeking: boolean;
7725     /**
7726      * The address or URL of the a media resource that is to be considered.
7727      */
7728     src: string;
7729     srcObject: MediaProvider | null;
7730     readonly textTracks: TextTrackList;
7731     /**
7732      * Gets or sets the volume level for audio portions of the media element.
7733      */
7734     volume: number;
7735     addTextTrack(kind: TextTrackKind, label?: string, language?: string): TextTrack;
7736     /**
7737      * Returns a string that specifies whether the client can play a given media resource type.
7738      */
7739     canPlayType(type: string): CanPlayTypeResult;
7740     fastSeek(time: number): void;
7741     /**
7742      * Resets the audio or video object and loads a new media resource.
7743      */
7744     load(): void;
7745     /**
7746      * 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.
7747      */
7748     pause(): void;
7749     /**
7750      * Loads and starts playback of a media resource.
7751      */
7752     play(): Promise<void>;
7753     setMediaKeys(mediaKeys: MediaKeys | null): Promise<void>;
7754     readonly HAVE_CURRENT_DATA: number;
7755     readonly HAVE_ENOUGH_DATA: number;
7756     readonly HAVE_FUTURE_DATA: number;
7757     readonly HAVE_METADATA: number;
7758     readonly HAVE_NOTHING: number;
7759     readonly NETWORK_EMPTY: number;
7760     readonly NETWORK_IDLE: number;
7761     readonly NETWORK_LOADING: number;
7762     readonly NETWORK_NO_SOURCE: number;
7763     addEventListener<K extends keyof HTMLMediaElementEventMap>(type: K, listener: (this: HTMLMediaElement, ev: HTMLMediaElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7764     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7765     removeEventListener<K extends keyof HTMLMediaElementEventMap>(type: K, listener: (this: HTMLMediaElement, ev: HTMLMediaElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7766     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7767 }
7768
7769 declare var HTMLMediaElement: {
7770     prototype: HTMLMediaElement;
7771     new(): HTMLMediaElement;
7772     readonly HAVE_CURRENT_DATA: number;
7773     readonly HAVE_ENOUGH_DATA: number;
7774     readonly HAVE_FUTURE_DATA: number;
7775     readonly HAVE_METADATA: number;
7776     readonly HAVE_NOTHING: number;
7777     readonly NETWORK_EMPTY: number;
7778     readonly NETWORK_IDLE: number;
7779     readonly NETWORK_LOADING: number;
7780     readonly NETWORK_NO_SOURCE: number;
7781 };
7782
7783 interface HTMLMenuElement extends HTMLElement {
7784     /** @deprecated */
7785     compact: boolean;
7786     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLMenuElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7787     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7788     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLMenuElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7789     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7790 }
7791
7792 declare var HTMLMenuElement: {
7793     prototype: HTMLMenuElement;
7794     new(): HTMLMenuElement;
7795 };
7796
7797 /** Contains descriptive metadata about a document. It inherits all of the properties and methods described in the HTMLElement interface. */
7798 interface HTMLMetaElement extends HTMLElement {
7799     /**
7800      * Gets or sets meta-information to associate with httpEquiv or name.
7801      */
7802     content: string;
7803     /**
7804      * Gets or sets information used to bind the value of a content attribute of a meta element to an HTTP response header.
7805      */
7806     httpEquiv: string;
7807     /**
7808      * Sets or retrieves the value specified in the content attribute of the meta object.
7809      */
7810     name: string;
7811     /**
7812      * Sets or retrieves a scheme to be used in interpreting the value of a property specified for the object.
7813      */
7814     /** @deprecated */
7815     scheme: string;
7816     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLMetaElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7817     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7818     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLMetaElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7819     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7820 }
7821
7822 declare var HTMLMetaElement: {
7823     prototype: HTMLMetaElement;
7824     new(): HTMLMetaElement;
7825 };
7826
7827 /** 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. */
7828 interface HTMLMeterElement extends HTMLElement {
7829     high: number;
7830     readonly labels: NodeListOf<HTMLLabelElement>;
7831     low: number;
7832     max: number;
7833     min: number;
7834     optimum: number;
7835     value: number;
7836     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLMeterElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7837     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7838     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLMeterElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7839     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7840 }
7841
7842 declare var HTMLMeterElement: {
7843     prototype: HTMLMeterElement;
7844     new(): HTMLMeterElement;
7845 };
7846
7847 /** 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>. */
7848 interface HTMLModElement extends HTMLElement {
7849     /**
7850      * Sets or retrieves reference information about the object.
7851      */
7852     cite: string;
7853     /**
7854      * Sets or retrieves the date and time of a modification to the object.
7855      */
7856     dateTime: string;
7857     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLModElement, 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: HTMLModElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7860     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7861 }
7862
7863 declare var HTMLModElement: {
7864     prototype: HTMLModElement;
7865     new(): HTMLModElement;
7866 };
7867
7868 /** Provides special properties (beyond those defined on the regular HTMLElement interface it also has available to it by inheritance) for manipulating ordered list elements. */
7869 interface HTMLOListElement extends HTMLElement {
7870     /** @deprecated */
7871     compact: boolean;
7872     reversed: boolean;
7873     /**
7874      * The starting number.
7875      */
7876     start: number;
7877     type: string;
7878     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLOListElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7879     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7880     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLOListElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7881     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7882 }
7883
7884 declare var HTMLOListElement: {
7885     prototype: HTMLOListElement;
7886     new(): HTMLOListElement;
7887 };
7888
7889 /** 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. */
7890 interface HTMLObjectElement extends HTMLElement {
7891     /** @deprecated */
7892     align: string;
7893     /**
7894      * Sets or retrieves a character string that can be used to implement your own archive functionality for the object.
7895      */
7896     /** @deprecated */
7897     archive: string;
7898     /** @deprecated */
7899     border: string;
7900     /**
7901      * Sets or retrieves the URL of the file containing the compiled Java class.
7902      */
7903     /** @deprecated */
7904     code: string;
7905     /**
7906      * Sets or retrieves the URL of the component.
7907      */
7908     /** @deprecated */
7909     codeBase: string;
7910     /**
7911      * Sets or retrieves the Internet media type for the code associated with the object.
7912      */
7913     /** @deprecated */
7914     codeType: string;
7915     /**
7916      * Retrieves the document object of the page or frame.
7917      */
7918     readonly contentDocument: Document | null;
7919     readonly contentWindow: WindowProxy | null;
7920     /**
7921      * Sets or retrieves the URL that references the data of the object.
7922      */
7923     data: string;
7924     /** @deprecated */
7925     declare: boolean;
7926     /**
7927      * Retrieves a reference to the form that the object is embedded in.
7928      */
7929     readonly form: HTMLFormElement | null;
7930     /**
7931      * Sets or retrieves the height of the object.
7932      */
7933     height: string;
7934     /** @deprecated */
7935     hspace: number;
7936     /**
7937      * Sets or retrieves the name of the object.
7938      */
7939     name: string;
7940     /**
7941      * Sets or retrieves a message to be displayed while an object is loading.
7942      */
7943     /** @deprecated */
7944     standby: string;
7945     /**
7946      * Sets or retrieves the MIME type of the object.
7947      */
7948     type: string;
7949     /**
7950      * Sets or retrieves the URL, often with a bookmark extension (#name), to use as a client-side image map.
7951      */
7952     useMap: string;
7953     /**
7954      * 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.
7955      */
7956     readonly validationMessage: string;
7957     /**
7958      * Returns a  ValidityState object that represents the validity states of an element.
7959      */
7960     readonly validity: ValidityState;
7961     /** @deprecated */
7962     vspace: number;
7963     /**
7964      * Sets or retrieves the width of the object.
7965      */
7966     width: string;
7967     /**
7968      * Returns whether an element will successfully validate based on forms validation rules and constraints.
7969      */
7970     readonly willValidate: boolean;
7971     /**
7972      * Returns whether a form will validate when it is submitted, without having to submit it.
7973      */
7974     checkValidity(): boolean;
7975     getSVGDocument(): Document | null;
7976     reportValidity(): boolean;
7977     /**
7978      * Sets a custom error message that is displayed when a form is submitted.
7979      * @param error Sets a custom error message that is displayed when a form is submitted.
7980      */
7981     setCustomValidity(error: string): void;
7982     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLObjectElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7983     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7984     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLObjectElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7985     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7986 }
7987
7988 declare var HTMLObjectElement: {
7989     prototype: HTMLObjectElement;
7990     new(): HTMLObjectElement;
7991 };
7992
7993 /** 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. */
7994 interface HTMLOptGroupElement extends HTMLElement {
7995     disabled: boolean;
7996     /**
7997      * Retrieves a reference to the form that the object is embedded in.
7998      */
7999     readonly form: HTMLFormElement | null;
8000     /**
8001      * Sets or retrieves a value that you can use to implement your own label functionality for the object.
8002      */
8003     label: string;
8004     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLOptGroupElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8005     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8006     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLOptGroupElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8007     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8008 }
8009
8010 declare var HTMLOptGroupElement: {
8011     prototype: HTMLOptGroupElement;
8012     new(): HTMLOptGroupElement;
8013 };
8014
8015 /** <option> elements and inherits all classes and methods of the HTMLElement interface. */
8016 interface HTMLOptionElement extends HTMLElement {
8017     /**
8018      * Sets or retrieves the status of an option.
8019      */
8020     defaultSelected: boolean;
8021     disabled: boolean;
8022     /**
8023      * Retrieves a reference to the form that the object is embedded in.
8024      */
8025     readonly form: HTMLFormElement | null;
8026     /**
8027      * Sets or retrieves the ordinal position of an option in a list box.
8028      */
8029     readonly index: number;
8030     /**
8031      * Sets or retrieves a value that you can use to implement your own label functionality for the object.
8032      */
8033     label: string;
8034     /**
8035      * Sets or retrieves whether the option in the list box is the default item.
8036      */
8037     selected: boolean;
8038     /**
8039      * Sets or retrieves the text string specified by the option tag.
8040      */
8041     text: string;
8042     /**
8043      * Sets or retrieves the value which is returned to the server when the form control is submitted.
8044      */
8045     value: string;
8046     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLOptionElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8047     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8048     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLOptionElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8049     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8050 }
8051
8052 declare var HTMLOptionElement: {
8053     prototype: HTMLOptionElement;
8054     new(): HTMLOptionElement;
8055 };
8056
8057 /** 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. */
8058 interface HTMLOptionsCollection extends HTMLCollectionOf<HTMLOptionElement> {
8059     /**
8060      * Returns the number of elements in the collection.
8061      *
8062      * When set to a smaller number, truncates the number of option elements in the corresponding container.
8063      *
8064      * When set to a greater number, adds new blank option elements to that container.
8065      */
8066     length: number;
8067     /**
8068      * Returns the index of the first selected item, if any, or −1 if there is no selected item.
8069      *
8070      * Can be set, to change the selection.
8071      */
8072     selectedIndex: number;
8073     /**
8074      * Inserts element before the node given by before.
8075      *
8076      * 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.
8077      *
8078      * If before is omitted, null, or a number out of range, then element will be added at the end of the list.
8079      *
8080      * This method will throw a "HierarchyRequestError" DOMException if element is an ancestor of the element into which it is to be inserted.
8081      */
8082     add(element: HTMLOptionElement | HTMLOptGroupElement, before?: HTMLElement | number | null): void;
8083     /**
8084      * Removes the item with index index from the collection.
8085      */
8086     remove(index: number): void;
8087 }
8088
8089 declare var HTMLOptionsCollection: {
8090     prototype: HTMLOptionsCollection;
8091     new(): HTMLOptionsCollection;
8092 };
8093
8094 interface HTMLOrSVGElement {
8095     autofocus: boolean;
8096     readonly dataset: DOMStringMap;
8097     nonce?: string;
8098     tabIndex: number;
8099     blur(): void;
8100     focus(options?: FocusOptions): void;
8101 }
8102
8103 /** Provides properties and methods (beyond those inherited from HTMLElement) for manipulating the layout and presentation of <output> elements. */
8104 interface HTMLOutputElement extends HTMLElement {
8105     defaultValue: string;
8106     readonly form: HTMLFormElement | null;
8107     readonly htmlFor: DOMTokenList;
8108     readonly labels: NodeListOf<HTMLLabelElement>;
8109     name: string;
8110     readonly type: string;
8111     readonly validationMessage: string;
8112     readonly validity: ValidityState;
8113     value: string;
8114     readonly willValidate: boolean;
8115     checkValidity(): boolean;
8116     reportValidity(): boolean;
8117     setCustomValidity(error: string): void;
8118     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLOutputElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8119     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8120     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLOutputElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8121     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8122 }
8123
8124 declare var HTMLOutputElement: {
8125     prototype: HTMLOutputElement;
8126     new(): HTMLOutputElement;
8127 };
8128
8129 /** Provides special properties (beyond those of the regular HTMLElement object interface it inherits) for manipulating <p> elements. */
8130 interface HTMLParagraphElement extends HTMLElement {
8131     /**
8132      * Sets or retrieves how the object is aligned with adjacent text.
8133      */
8134     /** @deprecated */
8135     align: string;
8136     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLParagraphElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8137     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8138     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLParagraphElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8139     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8140 }
8141
8142 declare var HTMLParagraphElement: {
8143     prototype: HTMLParagraphElement;
8144     new(): HTMLParagraphElement;
8145 };
8146
8147 /** 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. */
8148 interface HTMLParamElement extends HTMLElement {
8149     /**
8150      * Sets or retrieves the name of an input parameter for an element.
8151      */
8152     name: string;
8153     /**
8154      * Sets or retrieves the content type of the resource designated by the value attribute.
8155      */
8156     /** @deprecated */
8157     type: string;
8158     /**
8159      * Sets or retrieves the value of an input parameter for an element.
8160      */
8161     value: string;
8162     /**
8163      * Sets or retrieves the data type of the value attribute.
8164      */
8165     /** @deprecated */
8166     valueType: string;
8167     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLParamElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8168     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8169     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLParamElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8170     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8171 }
8172
8173 declare var HTMLParamElement: {
8174     prototype: HTMLParamElement;
8175     new(): HTMLParamElement;
8176 };
8177
8178 /** A <picture> HTML element. It doesn't implement specific properties or methods. */
8179 interface HTMLPictureElement extends HTMLElement {
8180     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLPictureElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8181     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8182     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLPictureElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8183     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8184 }
8185
8186 declare var HTMLPictureElement: {
8187     prototype: HTMLPictureElement;
8188     new(): HTMLPictureElement;
8189 };
8190
8191 /** 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>). */
8192 interface HTMLPreElement extends HTMLElement {
8193     /**
8194      * Sets or gets a value that you can use to implement your own width functionality for the object.
8195      */
8196     /** @deprecated */
8197     width: number;
8198     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLPreElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8199     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8200     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLPreElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8201     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8202 }
8203
8204 declare var HTMLPreElement: {
8205     prototype: HTMLPreElement;
8206     new(): HTMLPreElement;
8207 };
8208
8209 /** 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. */
8210 interface HTMLProgressElement extends HTMLElement {
8211     readonly labels: NodeListOf<HTMLLabelElement>;
8212     /**
8213      * Defines the maximum, or "done" value for a progress element.
8214      */
8215     max: number;
8216     /**
8217      * 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).
8218      */
8219     readonly position: number;
8220     /**
8221      * Sets or gets the current value of a progress element. The value must be a non-negative number between 0 and the max value.
8222      */
8223     value: number;
8224     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLProgressElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8225     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8226     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLProgressElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8227     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8228 }
8229
8230 declare var HTMLProgressElement: {
8231     prototype: HTMLProgressElement;
8232     new(): HTMLProgressElement;
8233 };
8234
8235 /** 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. */
8236 interface HTMLQuoteElement extends HTMLElement {
8237     /**
8238      * Sets or retrieves reference information about the object.
8239      */
8240     cite: string;
8241     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLQuoteElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8242     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8243     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLQuoteElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8244     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8245 }
8246
8247 declare var HTMLQuoteElement: {
8248     prototype: HTMLQuoteElement;
8249     new(): HTMLQuoteElement;
8250 };
8251
8252 /** 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). */
8253 interface HTMLScriptElement extends HTMLElement {
8254     async: boolean;
8255     /**
8256      * Sets or retrieves the character set used to encode the object.
8257      */
8258     /** @deprecated */
8259     charset: string;
8260     crossOrigin: string | null;
8261     /**
8262      * Sets or retrieves the status of the script.
8263      */
8264     defer: boolean;
8265     /**
8266      * Sets or retrieves the event for which the script is written.
8267      */
8268     /** @deprecated */
8269     event: string;
8270     /**
8271      * Sets or retrieves the object that is bound to the event script.
8272      */
8273     /** @deprecated */
8274     htmlFor: string;
8275     integrity: string;
8276     noModule: boolean;
8277     referrerPolicy: string;
8278     /**
8279      * Retrieves the URL to an external file that contains the source code or data.
8280      */
8281     src: string;
8282     /**
8283      * Retrieves or sets the text of the object as a string.
8284      */
8285     text: string;
8286     /**
8287      * Sets or retrieves the MIME type for the associated scripting engine.
8288      */
8289     type: string;
8290     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLScriptElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8291     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8292     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLScriptElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8293     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8294 }
8295
8296 declare var HTMLScriptElement: {
8297     prototype: HTMLScriptElement;
8298     new(): HTMLScriptElement;
8299 };
8300
8301 /** A <select> HTML Element. These elements also share all of the properties and methods of other HTML elements via the HTMLElement interface. */
8302 interface HTMLSelectElement extends HTMLElement {
8303     autocomplete: string;
8304     disabled: boolean;
8305     /**
8306      * Retrieves a reference to the form that the object is embedded in.
8307      */
8308     readonly form: HTMLFormElement | null;
8309     readonly labels: NodeListOf<HTMLLabelElement>;
8310     /**
8311      * Sets or retrieves the number of objects in a collection.
8312      */
8313     length: number;
8314     /**
8315      * Sets or retrieves the Boolean value indicating whether multiple items can be selected from a list.
8316      */
8317     multiple: boolean;
8318     /**
8319      * Sets or retrieves the name of the object.
8320      */
8321     name: string;
8322     readonly options: HTMLOptionsCollection;
8323     /**
8324      * When present, marks an element that can't be submitted without a value.
8325      */
8326     required: boolean;
8327     /**
8328      * Sets or retrieves the index of the selected option in a select object.
8329      */
8330     selectedIndex: number;
8331     readonly selectedOptions: HTMLCollectionOf<HTMLOptionElement>;
8332     /**
8333      * Sets or retrieves the number of rows in the list box.
8334      */
8335     size: number;
8336     /**
8337      * Retrieves the type of select control based on the value of the MULTIPLE attribute.
8338      */
8339     readonly type: string;
8340     /**
8341      * 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.
8342      */
8343     readonly validationMessage: string;
8344     /**
8345      * Returns a  ValidityState object that represents the validity states of an element.
8346      */
8347     readonly validity: ValidityState;
8348     /**
8349      * Sets or retrieves the value which is returned to the server when the form control is submitted.
8350      */
8351     value: string;
8352     /**
8353      * Returns whether an element will successfully validate based on forms validation rules and constraints.
8354      */
8355     readonly willValidate: boolean;
8356     /**
8357      * Adds an element to the areas, controlRange, or options collection.
8358      * @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.
8359      * @param before Variant of type Object that specifies an element to insert before, or null to append the object to the collection.
8360      */
8361     add(element: HTMLOptionElement | HTMLOptGroupElement, before?: HTMLElement | number | null): void;
8362     /**
8363      * Returns whether a form will validate when it is submitted, without having to submit it.
8364      */
8365     checkValidity(): boolean;
8366     /**
8367      * Retrieves a select object or an object from an options collection.
8368      * @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.
8369      * @param index Variant of type Number that specifies the zero-based index of the object to retrieve when a collection is returned.
8370      */
8371     item(index: number): Element | null;
8372     /**
8373      * Retrieves a select object or an object from an options collection.
8374      * @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.
8375      */
8376     namedItem(name: string): HTMLOptionElement | null;
8377     /**
8378      * Removes an element from the collection.
8379      * @param index Number that specifies the zero-based index of the element to remove from the collection.
8380      */
8381     remove(): void;
8382     remove(index: number): void;
8383     reportValidity(): boolean;
8384     /**
8385      * Sets a custom error message that is displayed when a form is submitted.
8386      * @param error Sets a custom error message that is displayed when a form is submitted.
8387      */
8388     setCustomValidity(error: string): void;
8389     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLSelectElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8390     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8391     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLSelectElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8392     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8393     [name: number]: HTMLOptionElement | HTMLOptGroupElement;
8394 }
8395
8396 declare var HTMLSelectElement: {
8397     prototype: HTMLSelectElement;
8398     new(): HTMLSelectElement;
8399 };
8400
8401 interface HTMLSlotElement extends HTMLElement {
8402     name: string;
8403     assignedElements(options?: AssignedNodesOptions): Element[];
8404     assignedNodes(options?: AssignedNodesOptions): Node[];
8405     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLSlotElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8406     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8407     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLSlotElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8408     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8409 }
8410
8411 declare var HTMLSlotElement: {
8412     prototype: HTMLSlotElement;
8413     new(): HTMLSlotElement;
8414 };
8415
8416 /** Provides special properties (beyond the regular HTMLElement object interface it also has available to it by inheritance) for manipulating <source> elements. */
8417 interface HTMLSourceElement extends HTMLElement {
8418     /**
8419      * Gets or sets the intended media type of the media source.
8420      */
8421     media: string;
8422     sizes: string;
8423     /**
8424      * The address or URL of the a media resource that is to be considered.
8425      */
8426     src: string;
8427     srcset: string;
8428     /**
8429      * Gets or sets the MIME type of a media resource.
8430      */
8431     type: string;
8432     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLSourceElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8433     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8434     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLSourceElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8435     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8436 }
8437
8438 declare var HTMLSourceElement: {
8439     prototype: HTMLSourceElement;
8440     new(): HTMLSourceElement;
8441 };
8442
8443 /** A <span> element and derives from the HTMLElement interface, but without implementing any additional properties or methods. */
8444 interface HTMLSpanElement extends HTMLElement {
8445     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLSpanElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8446     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8447     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLSpanElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8448     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8449 }
8450
8451 declare var HTMLSpanElement: {
8452     prototype: HTMLSpanElement;
8453     new(): HTMLSpanElement;
8454 };
8455
8456 /** A <style> element. It inherits properties and methods from its parent, HTMLElement, and from LinkStyle. */
8457 interface HTMLStyleElement extends HTMLElement, LinkStyle {
8458     /**
8459      * Sets or retrieves the media type.
8460      */
8461     media: string;
8462     /**
8463      * Retrieves the CSS language in which the style sheet is written.
8464      */
8465     /** @deprecated */
8466     type: string;
8467     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLStyleElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8468     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8469     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLStyleElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8470     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8471 }
8472
8473 declare var HTMLStyleElement: {
8474     prototype: HTMLStyleElement;
8475     new(): HTMLStyleElement;
8476 };
8477
8478 /** Special properties (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating table caption elements. */
8479 interface HTMLTableCaptionElement extends HTMLElement {
8480     /**
8481      * Sets or retrieves the alignment of the caption or legend.
8482      */
8483     /** @deprecated */
8484     align: string;
8485     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableCaptionElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8486     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8487     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableCaptionElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8488     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8489 }
8490
8491 declare var HTMLTableCaptionElement: {
8492     prototype: HTMLTableCaptionElement;
8493     new(): HTMLTableCaptionElement;
8494 };
8495
8496 /** 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. */
8497 interface HTMLTableCellElement extends HTMLElement {
8498     /**
8499      * Sets or retrieves abbreviated text for the object.
8500      */
8501     abbr: string;
8502     /**
8503      * Sets or retrieves how the object is aligned with adjacent text.
8504      */
8505     /** @deprecated */
8506     align: string;
8507     /**
8508      * Sets or retrieves a comma-delimited list of conceptual categories associated with the object.
8509      */
8510     /** @deprecated */
8511     axis: string;
8512     /** @deprecated */
8513     bgColor: string;
8514     /**
8515      * Retrieves the position of the object in the cells collection of a row.
8516      */
8517     readonly cellIndex: number;
8518     /** @deprecated */
8519     ch: string;
8520     /** @deprecated */
8521     chOff: string;
8522     /**
8523      * Sets or retrieves the number columns in the table that the object should span.
8524      */
8525     colSpan: number;
8526     /**
8527      * Sets or retrieves a list of header cells that provide information for the object.
8528      */
8529     headers: string;
8530     /**
8531      * Sets or retrieves the height of the object.
8532      */
8533     /** @deprecated */
8534     height: string;
8535     /**
8536      * Sets or retrieves whether the browser automatically performs wordwrap.
8537      */
8538     /** @deprecated */
8539     noWrap: boolean;
8540     /**
8541      * Sets or retrieves how many rows in a table the cell should span.
8542      */
8543     rowSpan: number;
8544     /**
8545      * Sets or retrieves the group of cells in a table to which the object's information applies.
8546      */
8547     scope: string;
8548     /** @deprecated */
8549     vAlign: string;
8550     /**
8551      * Sets or retrieves the width of the object.
8552      */
8553     /** @deprecated */
8554     width: string;
8555     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableCellElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8556     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8557     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableCellElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8558     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8559 }
8560
8561 declare var HTMLTableCellElement: {
8562     prototype: HTMLTableCellElement;
8563     new(): HTMLTableCellElement;
8564 };
8565
8566 /** Provides special properties (beyond the HTMLElement interface it also has available to it inheritance) for manipulating single or grouped table column elements. */
8567 interface HTMLTableColElement extends HTMLElement {
8568     /**
8569      * Sets or retrieves the alignment of the object relative to the display or table.
8570      */
8571     /** @deprecated */
8572     align: string;
8573     /** @deprecated */
8574     ch: string;
8575     /** @deprecated */
8576     chOff: string;
8577     /**
8578      * Sets or retrieves the number of columns in the group.
8579      */
8580     span: number;
8581     /** @deprecated */
8582     vAlign: string;
8583     /**
8584      * Sets or retrieves the width of the object.
8585      */
8586     /** @deprecated */
8587     width: string;
8588     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableColElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8589     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8590     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableColElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8591     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8592 }
8593
8594 declare var HTMLTableColElement: {
8595     prototype: HTMLTableColElement;
8596     new(): HTMLTableColElement;
8597 };
8598
8599 interface HTMLTableDataCellElement extends HTMLTableCellElement {
8600     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableDataCellElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8601     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8602     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableDataCellElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8603     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8604 }
8605
8606 declare var HTMLTableDataCellElement: {
8607     prototype: HTMLTableDataCellElement;
8608     new(): HTMLTableDataCellElement;
8609 };
8610
8611 /** 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. */
8612 interface HTMLTableElement extends HTMLElement {
8613     /**
8614      * Sets or retrieves a value that indicates the table alignment.
8615      */
8616     /** @deprecated */
8617     align: string;
8618     /** @deprecated */
8619     bgColor: string;
8620     /**
8621      * Sets or retrieves the width of the border to draw around the object.
8622      */
8623     /** @deprecated */
8624     border: string;
8625     /**
8626      * Retrieves the caption object of a table.
8627      */
8628     caption: HTMLTableCaptionElement | null;
8629     /**
8630      * Sets or retrieves the amount of space between the border of the cell and the content of the cell.
8631      */
8632     /** @deprecated */
8633     cellPadding: string;
8634     /**
8635      * Sets or retrieves the amount of space between cells in a table.
8636      */
8637     /** @deprecated */
8638     cellSpacing: string;
8639     /**
8640      * Sets or retrieves the way the border frame around the table is displayed.
8641      */
8642     /** @deprecated */
8643     frame: string;
8644     /**
8645      * Sets or retrieves the number of horizontal rows contained in the object.
8646      */
8647     readonly rows: HTMLCollectionOf<HTMLTableRowElement>;
8648     /**
8649      * Sets or retrieves which dividing lines (inner borders) are displayed.
8650      */
8651     /** @deprecated */
8652     rules: string;
8653     /**
8654      * Sets or retrieves a description and/or structure of the object.
8655      */
8656     /** @deprecated */
8657     summary: string;
8658     /**
8659      * Retrieves a collection of all tBody objects in the table. Objects in this collection are in source order.
8660      */
8661     readonly tBodies: HTMLCollectionOf<HTMLTableSectionElement>;
8662     /**
8663      * Retrieves the tFoot object of the table.
8664      */
8665     tFoot: HTMLTableSectionElement | null;
8666     /**
8667      * Retrieves the tHead object of the table.
8668      */
8669     tHead: HTMLTableSectionElement | null;
8670     /**
8671      * Sets or retrieves the width of the object.
8672      */
8673     /** @deprecated */
8674     width: string;
8675     /**
8676      * Creates an empty caption element in the table.
8677      */
8678     createCaption(): HTMLTableCaptionElement;
8679     /**
8680      * Creates an empty tBody element in the table.
8681      */
8682     createTBody(): HTMLTableSectionElement;
8683     /**
8684      * Creates an empty tFoot element in the table.
8685      */
8686     createTFoot(): HTMLTableSectionElement;
8687     /**
8688      * Returns the tHead element object if successful, or null otherwise.
8689      */
8690     createTHead(): HTMLTableSectionElement;
8691     /**
8692      * Deletes the caption element and its contents from the table.
8693      */
8694     deleteCaption(): void;
8695     /**
8696      * Removes the specified row (tr) from the element and from the rows collection.
8697      * @param index Number that specifies the zero-based position in the rows collection of the row to remove.
8698      */
8699     deleteRow(index: number): void;
8700     /**
8701      * Deletes the tFoot element and its contents from the table.
8702      */
8703     deleteTFoot(): void;
8704     /**
8705      * Deletes the tHead element and its contents from the table.
8706      */
8707     deleteTHead(): void;
8708     /**
8709      * Creates a new row (tr) in the table, and adds the row to the rows collection.
8710      * @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.
8711      */
8712     insertRow(index?: number): HTMLTableRowElement;
8713     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8714     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8715     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8716     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8717 }
8718
8719 declare var HTMLTableElement: {
8720     prototype: HTMLTableElement;
8721     new(): HTMLTableElement;
8722 };
8723
8724 interface HTMLTableHeaderCellElement extends HTMLTableCellElement {
8725     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableHeaderCellElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8726     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8727     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableHeaderCellElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8728     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8729 }
8730
8731 declare var HTMLTableHeaderCellElement: {
8732     prototype: HTMLTableHeaderCellElement;
8733     new(): HTMLTableHeaderCellElement;
8734 };
8735
8736 /** 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. */
8737 interface HTMLTableRowElement extends HTMLElement {
8738     /**
8739      * Sets or retrieves how the object is aligned with adjacent text.
8740      */
8741     /** @deprecated */
8742     align: string;
8743     /** @deprecated */
8744     bgColor: string;
8745     /**
8746      * Retrieves a collection of all cells in the table row.
8747      */
8748     readonly cells: HTMLCollectionOf<HTMLTableDataCellElement | HTMLTableHeaderCellElement>;
8749     /** @deprecated */
8750     ch: string;
8751     /** @deprecated */
8752     chOff: string;
8753     /**
8754      * Retrieves the position of the object in the rows collection for the table.
8755      */
8756     readonly rowIndex: number;
8757     /**
8758      * Retrieves the position of the object in the collection.
8759      */
8760     readonly sectionRowIndex: number;
8761     /** @deprecated */
8762     vAlign: string;
8763     /**
8764      * Removes the specified cell from the table row, as well as from the cells collection.
8765      * @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.
8766      */
8767     deleteCell(index: number): void;
8768     /**
8769      * Creates a new cell in the table row, and adds the cell to the cells collection.
8770      * @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.
8771      */
8772     insertCell(index?: number): HTMLTableDataCellElement;
8773     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableRowElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8774     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8775     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableRowElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8776     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8777 }
8778
8779 declare var HTMLTableRowElement: {
8780     prototype: HTMLTableRowElement;
8781     new(): HTMLTableRowElement;
8782 };
8783
8784 /** 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. */
8785 interface HTMLTableSectionElement extends HTMLElement {
8786     /**
8787      * Sets or retrieves a value that indicates the table alignment.
8788      */
8789     /** @deprecated */
8790     align: string;
8791     /** @deprecated */
8792     ch: string;
8793     /** @deprecated */
8794     chOff: string;
8795     /**
8796      * Sets or retrieves the number of horizontal rows contained in the object.
8797      */
8798     readonly rows: HTMLCollectionOf<HTMLTableRowElement>;
8799     /** @deprecated */
8800     vAlign: string;
8801     /**
8802      * Removes the specified row (tr) from the element and from the rows collection.
8803      * @param index Number that specifies the zero-based position in the rows collection of the row to remove.
8804      */
8805     deleteRow(index: number): void;
8806     /**
8807      * Creates a new row (tr) in the table, and adds the row to the rows collection.
8808      * @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.
8809      */
8810     insertRow(index?: number): HTMLTableRowElement;
8811     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableSectionElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8812     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8813     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableSectionElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8814     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8815 }
8816
8817 declare var HTMLTableSectionElement: {
8818     prototype: HTMLTableSectionElement;
8819     new(): HTMLTableSectionElement;
8820 };
8821
8822 /** Enables access to the contents of an HTML <template> element. */
8823 interface HTMLTemplateElement extends HTMLElement {
8824     readonly content: DocumentFragment;
8825     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTemplateElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8826     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8827     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTemplateElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8828     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8829 }
8830
8831 declare var HTMLTemplateElement: {
8832     prototype: HTMLTemplateElement;
8833     new(): HTMLTemplateElement;
8834 };
8835
8836 /** Provides special properties and methods for manipulating the layout and presentation of <textarea> elements. */
8837 interface HTMLTextAreaElement extends HTMLElement {
8838     autocomplete: string;
8839     /**
8840      * Sets or retrieves the width of the object.
8841      */
8842     cols: number;
8843     /**
8844      * Sets or retrieves the initial contents of the object.
8845      */
8846     defaultValue: string;
8847     dirName: string;
8848     disabled: boolean;
8849     /**
8850      * Retrieves a reference to the form that the object is embedded in.
8851      */
8852     readonly form: HTMLFormElement | null;
8853     readonly labels: NodeListOf<HTMLLabelElement>;
8854     /**
8855      * Sets or retrieves the maximum number of characters that the user can enter in a text control.
8856      */
8857     maxLength: number;
8858     minLength: number;
8859     /**
8860      * Sets or retrieves the name of the object.
8861      */
8862     name: string;
8863     /**
8864      * 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.
8865      */
8866     placeholder: string;
8867     /**
8868      * Sets or retrieves the value indicated whether the content of the object is read-only.
8869      */
8870     readOnly: boolean;
8871     /**
8872      * When present, marks an element that can't be submitted without a value.
8873      */
8874     required: boolean;
8875     /**
8876      * Sets or retrieves the number of horizontal rows contained in the object.
8877      */
8878     rows: number;
8879     selectionDirection: "forward" | "backward" | "none";
8880     /**
8881      * Gets or sets the end position or offset of a text selection.
8882      */
8883     selectionEnd: number;
8884     /**
8885      * Gets or sets the starting position or offset of a text selection.
8886      */
8887     selectionStart: number;
8888     readonly textLength: number;
8889     /**
8890      * Retrieves the type of control.
8891      */
8892     readonly type: string;
8893     /**
8894      * 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.
8895      */
8896     readonly validationMessage: string;
8897     /**
8898      * Returns a  ValidityState object that represents the validity states of an element.
8899      */
8900     readonly validity: ValidityState;
8901     /**
8902      * Retrieves or sets the text in the entry field of the textArea element.
8903      */
8904     value: string;
8905     /**
8906      * Returns whether an element will successfully validate based on forms validation rules and constraints.
8907      */
8908     readonly willValidate: boolean;
8909     /**
8910      * Sets or retrieves how to handle wordwrapping in the object.
8911      */
8912     wrap: string;
8913     /**
8914      * Returns whether a form will validate when it is submitted, without having to submit it.
8915      */
8916     checkValidity(): boolean;
8917     reportValidity(): boolean;
8918     /**
8919      * Highlights the input area of a form element.
8920      */
8921     select(): void;
8922     /**
8923      * Sets a custom error message that is displayed when a form is submitted.
8924      * @param error Sets a custom error message that is displayed when a form is submitted.
8925      */
8926     setCustomValidity(error: string): void;
8927     setRangeText(replacement: string): void;
8928     setRangeText(replacement: string, start: number, end: number, selectionMode?: SelectionMode): void;
8929     /**
8930      * Sets the start and end positions of a selection in a text field.
8931      * @param start The offset into the text field for the start of the selection.
8932      * @param end The offset into the text field for the end of the selection.
8933      * @param direction The direction in which the selection is performed.
8934      */
8935     setSelectionRange(start: number | null, end: number | null, direction?: "forward" | "backward" | "none"): void;
8936     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTextAreaElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8937     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8938     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTextAreaElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8939     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8940 }
8941
8942 declare var HTMLTextAreaElement: {
8943     prototype: HTMLTextAreaElement;
8944     new(): HTMLTextAreaElement;
8945 };
8946
8947 /** Provides special properties (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating <time> elements. */
8948 interface HTMLTimeElement extends HTMLElement {
8949     dateTime: string;
8950     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTimeElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8951     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8952     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTimeElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8953     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8954 }
8955
8956 declare var HTMLTimeElement: {
8957     prototype: HTMLTimeElement;
8958     new(): HTMLTimeElement;
8959 };
8960
8961 /** Contains the title for a document. This element inherits all of the properties and methods of the HTMLElement interface. */
8962 interface HTMLTitleElement extends HTMLElement {
8963     /**
8964      * Retrieves or sets the text of the object as a string.
8965      */
8966     text: string;
8967     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTitleElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8968     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8969     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTitleElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8970     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8971 }
8972
8973 declare var HTMLTitleElement: {
8974     prototype: HTMLTitleElement;
8975     new(): HTMLTitleElement;
8976 };
8977
8978 /** The HTMLTrackElement */
8979 interface HTMLTrackElement extends HTMLElement {
8980     default: boolean;
8981     kind: string;
8982     label: string;
8983     readonly readyState: number;
8984     src: string;
8985     srclang: string;
8986     readonly track: TextTrack;
8987     readonly ERROR: number;
8988     readonly LOADED: number;
8989     readonly LOADING: number;
8990     readonly NONE: number;
8991     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTrackElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8992     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8993     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTrackElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8994     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8995 }
8996
8997 declare var HTMLTrackElement: {
8998     prototype: HTMLTrackElement;
8999     new(): HTMLTrackElement;
9000     readonly ERROR: number;
9001     readonly LOADED: number;
9002     readonly LOADING: number;
9003     readonly NONE: number;
9004 };
9005
9006 /** Provides special properties (beyond those defined on the regular HTMLElement interface it also has available to it by inheritance) for manipulating unordered list elements. */
9007 interface HTMLUListElement extends HTMLElement {
9008     /** @deprecated */
9009     compact: boolean;
9010     /** @deprecated */
9011     type: string;
9012     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLUListElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9013     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9014     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLUListElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9015     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9016 }
9017
9018 declare var HTMLUListElement: {
9019     prototype: HTMLUListElement;
9020     new(): HTMLUListElement;
9021 };
9022
9023 /** An invalid HTML element and derives from the HTMLElement interface, but without implementing any additional properties or methods. */
9024 interface HTMLUnknownElement extends HTMLElement {
9025     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLUnknownElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9026     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9027     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLUnknownElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9028     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9029 }
9030
9031 declare var HTMLUnknownElement: {
9032     prototype: HTMLUnknownElement;
9033     new(): HTMLUnknownElement;
9034 };
9035
9036 /** Provides special properties and methods for manipulating video objects. It also inherits properties and methods of HTMLMediaElement and HTMLElement. */
9037 interface HTMLVideoElement extends HTMLMediaElement {
9038     /**
9039      * Gets or sets the height of the video element.
9040      */
9041     height: number;
9042     /**
9043      * Gets or sets the playsinline of the video element. for example, On iPhone, video elements will now be allowed to play inline, and will not automatically enter fullscreen mode when playback begins.
9044      */
9045     playsInline: boolean;
9046     /**
9047      * 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.
9048      */
9049     poster: string;
9050     /**
9051      * Gets the intrinsic height of a video in CSS pixels, or zero if the dimensions are not known.
9052      */
9053     readonly videoHeight: number;
9054     /**
9055      * Gets the intrinsic width of a video in CSS pixels, or zero if the dimensions are not known.
9056      */
9057     readonly videoWidth: number;
9058     /**
9059      * Gets or sets the width of the video element.
9060      */
9061     width: number;
9062     getVideoPlaybackQuality(): VideoPlaybackQuality;
9063     addEventListener<K extends keyof HTMLMediaElementEventMap>(type: K, listener: (this: HTMLVideoElement, ev: HTMLMediaElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9064     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9065     removeEventListener<K extends keyof HTMLMediaElementEventMap>(type: K, listener: (this: HTMLVideoElement, ev: HTMLMediaElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9066     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9067 }
9068
9069 declare var HTMLVideoElement: {
9070     prototype: HTMLVideoElement;
9071     new(): HTMLVideoElement;
9072 };
9073
9074 /** Events that fire when the fragment identifier of the URL has changed. */
9075 interface HashChangeEvent extends Event {
9076     /**
9077      * Returns the URL of the session history entry that is now current.
9078      */
9079     readonly newURL: string;
9080     /**
9081      * Returns the URL of the session history entry that was previously current.
9082      */
9083     readonly oldURL: string;
9084 }
9085
9086 declare var HashChangeEvent: {
9087     prototype: HashChangeEvent;
9088     new(type: string, eventInitDict?: HashChangeEventInit): HashChangeEvent;
9089 };
9090
9091 /** 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. */
9092 interface Headers {
9093     append(name: string, value: string): void;
9094     delete(name: string): void;
9095     get(name: string): string | null;
9096     has(name: string): boolean;
9097     set(name: string, value: string): void;
9098     forEach(callbackfn: (value: string, key: string, parent: Headers) => void, thisArg?: any): void;
9099 }
9100
9101 declare var Headers: {
9102     prototype: Headers;
9103     new(init?: HeadersInit): Headers;
9104 };
9105
9106 /** Allows manipulation of the browser session history, that is the pages visited in the tab or frame that the current page is loaded in. */
9107 interface History {
9108     readonly length: number;
9109     scrollRestoration: ScrollRestoration;
9110     readonly state: any;
9111     back(): void;
9112     forward(): void;
9113     go(delta?: number): void;
9114     pushState(data: any, title: string, url?: string | null): void;
9115     replaceState(data: any, title: string, url?: string | null): void;
9116 }
9117
9118 declare var History: {
9119     prototype: History;
9120     new(): History;
9121 };
9122
9123 interface IDBArrayKey extends Array<IDBValidKey> {
9124 }
9125
9126 /** This IndexedDB API interface represents a cursor for traversing or iterating over multiple records in a database. */
9127 interface IDBCursor {
9128     /**
9129      * Returns the direction ("next", "nextunique", "prev" or "prevunique") of the cursor.
9130      */
9131     readonly direction: IDBCursorDirection;
9132     /**
9133      * Returns the key of the cursor. Throws a "InvalidStateError" DOMException if the cursor is advancing or is finished.
9134      */
9135     readonly key: IDBValidKey;
9136     /**
9137      * Returns the effective key of the cursor. Throws a "InvalidStateError" DOMException if the cursor is advancing or is finished.
9138      */
9139     readonly primaryKey: IDBValidKey;
9140     /**
9141      * Returns the IDBObjectStore or IDBIndex the cursor was opened from.
9142      */
9143     readonly source: IDBObjectStore | IDBIndex;
9144     /**
9145      * Advances the cursor through the next count records in range.
9146      */
9147     advance(count: number): void;
9148     /**
9149      * Advances the cursor to the next record in range.
9150      */
9151     continue(key?: IDBValidKey): void;
9152     /**
9153      * 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.
9154      */
9155     continuePrimaryKey(key: IDBValidKey, primaryKey: IDBValidKey): void;
9156     /**
9157      * Delete the record pointed at by the cursor with a new value.
9158      *
9159      * If successful, request's result will be undefined.
9160      */
9161     delete(): IDBRequest<undefined>;
9162     /**
9163      * Updated the record pointed at by the cursor with a new value.
9164      *
9165      * Throws a "DataError" DOMException if the effective object store uses in-line keys and the key would have changed.
9166      *
9167      * If successful, request's result will be the record's key.
9168      */
9169     update(value: any): IDBRequest<IDBValidKey>;
9170 }
9171
9172 declare var IDBCursor: {
9173     prototype: IDBCursor;
9174     new(): IDBCursor;
9175 };
9176
9177 /** 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. */
9178 interface IDBCursorWithValue extends IDBCursor {
9179     /**
9180      * Returns the cursor's current value.
9181      */
9182     readonly value: any;
9183 }
9184
9185 declare var IDBCursorWithValue: {
9186     prototype: IDBCursorWithValue;
9187     new(): IDBCursorWithValue;
9188 };
9189
9190 interface IDBDatabaseEventMap {
9191     "abort": Event;
9192     "close": Event;
9193     "error": Event;
9194     "versionchange": IDBVersionChangeEvent;
9195 }
9196
9197 /** 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. */
9198 interface IDBDatabase extends EventTarget {
9199     /**
9200      * Returns the name of the database.
9201      */
9202     readonly name: string;
9203     /**
9204      * Returns a list of the names of object stores in the database.
9205      */
9206     readonly objectStoreNames: DOMStringList;
9207     onabort: ((this: IDBDatabase, ev: Event) => any) | null;
9208     onclose: ((this: IDBDatabase, ev: Event) => any) | null;
9209     onerror: ((this: IDBDatabase, ev: Event) => any) | null;
9210     onversionchange: ((this: IDBDatabase, ev: IDBVersionChangeEvent) => any) | null;
9211     /**
9212      * Returns the version of the database.
9213      */
9214     readonly version: number;
9215     /**
9216      * Closes the connection once all running transactions have finished.
9217      */
9218     close(): void;
9219     /**
9220      * Creates a new object store with the given name and options and returns a new IDBObjectStore.
9221      *
9222      * Throws a "InvalidStateError" DOMException if not called within an upgrade transaction.
9223      */
9224     createObjectStore(name: string, options?: IDBObjectStoreParameters): IDBObjectStore;
9225     /**
9226      * Deletes the object store with the given name.
9227      *
9228      * Throws a "InvalidStateError" DOMException if not called within an upgrade transaction.
9229      */
9230     deleteObjectStore(name: string): void;
9231     /**
9232      * 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.
9233      */
9234     transaction(storeNames: string | string[], mode?: IDBTransactionMode): IDBTransaction;
9235     addEventListener<K extends keyof IDBDatabaseEventMap>(type: K, listener: (this: IDBDatabase, ev: IDBDatabaseEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9236     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9237     removeEventListener<K extends keyof IDBDatabaseEventMap>(type: K, listener: (this: IDBDatabase, ev: IDBDatabaseEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9238     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9239 }
9240
9241 declare var IDBDatabase: {
9242     prototype: IDBDatabase;
9243     new(): IDBDatabase;
9244 };
9245
9246 /** 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.) */
9247 interface IDBFactory {
9248     /**
9249      * Compares two values as keys. Returns -1 if key1 precedes key2, 1 if key2 precedes key1, and 0 if the keys are equal.
9250      *
9251      * Throws a "DataError" DOMException if either input is not a valid key.
9252      */
9253     cmp(first: any, second: any): number;
9254     /**
9255      * 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.
9256      */
9257     deleteDatabase(name: string): IDBOpenDBRequest;
9258     /**
9259      * 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.
9260      */
9261     open(name: string, version?: number): IDBOpenDBRequest;
9262 }
9263
9264 declare var IDBFactory: {
9265     prototype: IDBFactory;
9266     new(): IDBFactory;
9267 };
9268
9269 /** 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. */
9270 interface IDBIndex {
9271     readonly keyPath: string | string[];
9272     readonly multiEntry: boolean;
9273     /**
9274      * Returns the name of the index.
9275      */
9276     name: string;
9277     /**
9278      * Returns the IDBObjectStore the index belongs to.
9279      */
9280     readonly objectStore: IDBObjectStore;
9281     readonly unique: boolean;
9282     /**
9283      * Retrieves the number of records matching the given key or key range in query.
9284      *
9285      * If successful, request's result will be the count.
9286      */
9287     count(key?: IDBValidKey | IDBKeyRange): IDBRequest<number>;
9288     /**
9289      * Retrieves the value of the first record matching the given key or key range in query.
9290      *
9291      * If successful, request's result will be the value, or undefined if there was no matching record.
9292      */
9293     get(key: IDBValidKey | IDBKeyRange): IDBRequest<any | undefined>;
9294     /**
9295      * Retrieves the values of the records matching the given key or key range in query (up to count if given).
9296      *
9297      * If successful, request's result will be an Array of the values.
9298      */
9299     getAll(query?: IDBValidKey | IDBKeyRange | null, count?: number): IDBRequest<any[]>;
9300     /**
9301      * Retrieves the keys of records matching the given key or key range in query (up to count if given).
9302      *
9303      * If successful, request's result will be an Array of the keys.
9304      */
9305     getAllKeys(query?: IDBValidKey | IDBKeyRange | null, count?: number): IDBRequest<IDBValidKey[]>;
9306     /**
9307      * Retrieves the key of the first record matching the given key or key range in query.
9308      *
9309      * If successful, request's result will be the key, or undefined if there was no matching record.
9310      */
9311     getKey(key: IDBValidKey | IDBKeyRange): IDBRequest<IDBValidKey | undefined>;
9312     /**
9313      * Opens a cursor over the records matching query, ordered by direction. If query is null, all records in index are matched.
9314      *
9315      * If successful, request's result will be an IDBCursorWithValue, or null if there were no matching records.
9316      */
9317     openCursor(query?: IDBValidKey | IDBKeyRange | null, direction?: IDBCursorDirection): IDBRequest<IDBCursorWithValue | null>;
9318     /**
9319      * 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.
9320      *
9321      * If successful, request's result will be an IDBCursor, or null if there were no matching records.
9322      */
9323     openKeyCursor(query?: IDBValidKey | IDBKeyRange | null, direction?: IDBCursorDirection): IDBRequest<IDBCursor | null>;
9324 }
9325
9326 declare var IDBIndex: {
9327     prototype: IDBIndex;
9328     new(): IDBIndex;
9329 };
9330
9331 /** 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: */
9332 interface IDBKeyRange {
9333     /**
9334      * Returns lower bound, or undefined if none.
9335      */
9336     readonly lower: any;
9337     /**
9338      * Returns true if the lower open flag is set, and false otherwise.
9339      */
9340     readonly lowerOpen: boolean;
9341     /**
9342      * Returns upper bound, or undefined if none.
9343      */
9344     readonly upper: any;
9345     /**
9346      * Returns true if the upper open flag is set, and false otherwise.
9347      */
9348     readonly upperOpen: boolean;
9349     /**
9350      * Returns true if key is included in the range, and false otherwise.
9351      */
9352     includes(key: any): boolean;
9353 }
9354
9355 declare var IDBKeyRange: {
9356     prototype: IDBKeyRange;
9357     new(): IDBKeyRange;
9358     /**
9359      * 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.
9360      */
9361     bound(lower: any, upper: any, lowerOpen?: boolean, upperOpen?: boolean): IDBKeyRange;
9362     /**
9363      * Returns a new IDBKeyRange starting at key with no upper bound. If open is true, key is not included in the range.
9364      */
9365     lowerBound(lower: any, open?: boolean): IDBKeyRange;
9366     /**
9367      * Returns a new IDBKeyRange spanning only key.
9368      */
9369     only(value: any): IDBKeyRange;
9370     /**
9371      * Returns a new IDBKeyRange with no lower bound and ending at key. If open is true, key is not included in the range.
9372      */
9373     upperBound(upper: any, open?: boolean): IDBKeyRange;
9374 };
9375
9376 /** 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.) */
9377 interface IDBObjectStore {
9378     /**
9379      * Returns true if the store has a key generator, and false otherwise.
9380      */
9381     readonly autoIncrement: boolean;
9382     /**
9383      * Returns a list of the names of indexes in the store.
9384      */
9385     readonly indexNames: DOMStringList;
9386     /**
9387      * Returns the key path of the store, or null if none.
9388      */
9389     readonly keyPath: string | string[];
9390     /**
9391      * Returns the name of the store.
9392      */
9393     name: string;
9394     /**
9395      * Returns the associated transaction.
9396      */
9397     readonly transaction: IDBTransaction;
9398     /**
9399      * Adds or updates a record in store with the given value and key.
9400      *
9401      * If the store uses in-line keys and key is specified a "DataError" DOMException will be thrown.
9402      *
9403      * 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.
9404      *
9405      * If successful, request's result will be the record's key.
9406      */
9407     add(value: any, key?: IDBValidKey): IDBRequest<IDBValidKey>;
9408     /**
9409      * Deletes all records in store.
9410      *
9411      * If successful, request's result will be undefined.
9412      */
9413     clear(): IDBRequest<undefined>;
9414     /**
9415      * Retrieves the number of records matching the given key or key range in query.
9416      *
9417      * If successful, request's result will be the count.
9418      */
9419     count(key?: IDBValidKey | IDBKeyRange): IDBRequest<number>;
9420     /**
9421      * 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.
9422      *
9423      * Throws an "InvalidStateError" DOMException if not called within an upgrade transaction.
9424      */
9425     createIndex(name: string, keyPath: string | string[], options?: IDBIndexParameters): IDBIndex;
9426     /**
9427      * Deletes records in store with the given key or in the given key range in query.
9428      *
9429      * If successful, request's result will be undefined.
9430      */
9431     delete(key: IDBValidKey | IDBKeyRange): IDBRequest<undefined>;
9432     /**
9433      * Deletes the index in store with the given name.
9434      *
9435      * Throws an "InvalidStateError" DOMException if not called within an upgrade transaction.
9436      */
9437     deleteIndex(name: string): void;
9438     /**
9439      * Retrieves the value of the first record matching the given key or key range in query.
9440      *
9441      * If successful, request's result will be the value, or undefined if there was no matching record.
9442      */
9443     get(query: IDBValidKey | IDBKeyRange): IDBRequest<any | undefined>;
9444     /**
9445      * Retrieves the values of the records matching the given key or key range in query (up to count if given).
9446      *
9447      * If successful, request's result will be an Array of the values.
9448      */
9449     getAll(query?: IDBValidKey | IDBKeyRange | null, count?: number): IDBRequest<any[]>;
9450     /**
9451      * Retrieves the keys of records matching the given key or key range in query (up to count if given).
9452      *
9453      * If successful, request's result will be an Array of the keys.
9454      */
9455     getAllKeys(query?: IDBValidKey | IDBKeyRange | null, count?: number): IDBRequest<IDBValidKey[]>;
9456     /**
9457      * Retrieves the key of the first record matching the given key or key range in query.
9458      *
9459      * If successful, request's result will be the key, or undefined if there was no matching record.
9460      */
9461     getKey(query: IDBValidKey | IDBKeyRange): IDBRequest<IDBValidKey | undefined>;
9462     index(name: string): IDBIndex;
9463     /**
9464      * Opens a cursor over the records matching query, ordered by direction. If query is null, all records in store are matched.
9465      *
9466      * If successful, request's result will be an IDBCursorWithValue pointing at the first matching record, or null if there were no matching records.
9467      */
9468     openCursor(query?: IDBValidKey | IDBKeyRange | null, direction?: IDBCursorDirection): IDBRequest<IDBCursorWithValue | null>;
9469     /**
9470      * 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.
9471      *
9472      * If successful, request's result will be an IDBCursor pointing at the first matching record, or null if there were no matching records.
9473      */
9474     openKeyCursor(query?: IDBValidKey | IDBKeyRange | null, direction?: IDBCursorDirection): IDBRequest<IDBCursor | null>;
9475     /**
9476      * Adds or updates a record in store with the given value and key.
9477      *
9478      * If the store uses in-line keys and key is specified a "DataError" DOMException will be thrown.
9479      *
9480      * 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.
9481      *
9482      * If successful, request's result will be the record's key.
9483      */
9484     put(value: any, key?: IDBValidKey): IDBRequest<IDBValidKey>;
9485 }
9486
9487 declare var IDBObjectStore: {
9488     prototype: IDBObjectStore;
9489     new(): IDBObjectStore;
9490 };
9491
9492 interface IDBOpenDBRequestEventMap extends IDBRequestEventMap {
9493     "blocked": Event;
9494     "upgradeneeded": IDBVersionChangeEvent;
9495 }
9496
9497 /** Also inherits methods from its parents IDBRequest and EventTarget. */
9498 interface IDBOpenDBRequest extends IDBRequest<IDBDatabase> {
9499     onblocked: ((this: IDBOpenDBRequest, ev: Event) => any) | null;
9500     onupgradeneeded: ((this: IDBOpenDBRequest, ev: IDBVersionChangeEvent) => any) | null;
9501     addEventListener<K extends keyof IDBOpenDBRequestEventMap>(type: K, listener: (this: IDBOpenDBRequest, ev: IDBOpenDBRequestEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9502     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9503     removeEventListener<K extends keyof IDBOpenDBRequestEventMap>(type: K, listener: (this: IDBOpenDBRequest, ev: IDBOpenDBRequestEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9504     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9505 }
9506
9507 declare var IDBOpenDBRequest: {
9508     prototype: IDBOpenDBRequest;
9509     new(): IDBOpenDBRequest;
9510 };
9511
9512 interface IDBRequestEventMap {
9513     "error": Event;
9514     "success": Event;
9515 }
9516
9517 /** 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. */
9518 interface IDBRequest<T = any> extends EventTarget {
9519     /**
9520      * 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.
9521      */
9522     readonly error: DOMException | null;
9523     onerror: ((this: IDBRequest<T>, ev: Event) => any) | null;
9524     onsuccess: ((this: IDBRequest<T>, ev: Event) => any) | null;
9525     /**
9526      * Returns "pending" until a request is complete, then returns "done".
9527      */
9528     readonly readyState: IDBRequestReadyState;
9529     /**
9530      * When a request is completed, returns the result, or undefined if the request failed. Throws a "InvalidStateError" DOMException if the request is still pending.
9531      */
9532     readonly result: T;
9533     /**
9534      * Returns the IDBObjectStore, IDBIndex, or IDBCursor the request was made against, or null if is was an open request.
9535      */
9536     readonly source: IDBObjectStore | IDBIndex | IDBCursor;
9537     /**
9538      * 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.
9539      */
9540     readonly transaction: IDBTransaction | null;
9541     addEventListener<K extends keyof IDBRequestEventMap>(type: K, listener: (this: IDBRequest<T>, ev: IDBRequestEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9542     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9543     removeEventListener<K extends keyof IDBRequestEventMap>(type: K, listener: (this: IDBRequest<T>, ev: IDBRequestEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9544     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9545 }
9546
9547 declare var IDBRequest: {
9548     prototype: IDBRequest;
9549     new(): IDBRequest;
9550 };
9551
9552 interface IDBTransactionEventMap {
9553     "abort": Event;
9554     "complete": Event;
9555     "error": Event;
9556 }
9557
9558 interface IDBTransaction extends EventTarget {
9559     /**
9560      * Returns the transaction's connection.
9561      */
9562     readonly db: IDBDatabase;
9563     /**
9564      * If the transaction was aborted, returns the error (a DOMException) providing the reason.
9565      */
9566     readonly error: DOMException;
9567     /**
9568      * Returns the mode the transaction was created with ("readonly" or "readwrite"), or "versionchange" for an upgrade transaction.
9569      */
9570     readonly mode: IDBTransactionMode;
9571     /**
9572      * 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.
9573      */
9574     readonly objectStoreNames: DOMStringList;
9575     onabort: ((this: IDBTransaction, ev: Event) => any) | null;
9576     oncomplete: ((this: IDBTransaction, ev: Event) => any) | null;
9577     onerror: ((this: IDBTransaction, ev: Event) => any) | null;
9578     /**
9579      * Aborts the transaction. All pending requests will fail with a "AbortError" DOMException and all changes made to the database will be reverted.
9580      */
9581     abort(): void;
9582     /**
9583      * Returns an IDBObjectStore in the transaction's scope.
9584      */
9585     objectStore(name: string): IDBObjectStore;
9586     addEventListener<K extends keyof IDBTransactionEventMap>(type: K, listener: (this: IDBTransaction, ev: IDBTransactionEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9587     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9588     removeEventListener<K extends keyof IDBTransactionEventMap>(type: K, listener: (this: IDBTransaction, ev: IDBTransactionEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9589     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9590 }
9591
9592 declare var IDBTransaction: {
9593     prototype: IDBTransaction;
9594     new(): IDBTransaction;
9595 };
9596
9597 /** This IndexedDB API interface indicates that the version of the database has changed, as the result of an IDBOpenDBRequest.onupgradeneeded event handler function. */
9598 interface IDBVersionChangeEvent extends Event {
9599     readonly newVersion: number | null;
9600     readonly oldVersion: number;
9601 }
9602
9603 declare var IDBVersionChangeEvent: {
9604     prototype: IDBVersionChangeEvent;
9605     new(type: string, eventInitDict?: IDBVersionChangeEventInit): IDBVersionChangeEvent;
9606 };
9607
9608 /** 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. */
9609 interface IIRFilterNode extends AudioNode {
9610     getFrequencyResponse(frequencyHz: Float32Array, magResponse: Float32Array, phaseResponse: Float32Array): void;
9611 }
9612
9613 declare var IIRFilterNode: {
9614     prototype: IIRFilterNode;
9615     new(context: BaseAudioContext, options: IIRFilterOptions): IIRFilterNode;
9616 };
9617
9618 interface ImageBitmap {
9619     /**
9620      * Returns the intrinsic height of the image, in CSS pixels.
9621      */
9622     readonly height: number;
9623     /**
9624      * Returns the intrinsic width of the image, in CSS pixels.
9625      */
9626     readonly width: number;
9627     /**
9628      * Releases imageBitmap's underlying bitmap data.
9629      */
9630     close(): void;
9631 }
9632
9633 declare var ImageBitmap: {
9634     prototype: ImageBitmap;
9635     new(): ImageBitmap;
9636 };
9637
9638 interface ImageBitmapRenderingContext {
9639     /**
9640      * Returns the canvas element that the context is bound to.
9641      */
9642     readonly canvas: HTMLCanvasElement | OffscreenCanvas;
9643     /**
9644      * Transfers the underlying bitmap data from imageBitmap to context, and the bitmap becomes the contents of the canvas element to which context is bound.
9645      */
9646     transferFromImageBitmap(bitmap: ImageBitmap | null): void;
9647 }
9648
9649 declare var ImageBitmapRenderingContext: {
9650     prototype: ImageBitmapRenderingContext;
9651     new(): ImageBitmapRenderingContext;
9652 };
9653
9654 /** 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(). */
9655 interface ImageData {
9656     /**
9657      * Returns the one-dimensional array containing the data in RGBA order, as integers in the range 0 to 255.
9658      */
9659     readonly data: Uint8ClampedArray;
9660     /**
9661      * Returns the actual dimensions of the data in the ImageData object, in pixels.
9662      */
9663     readonly height: number;
9664     /**
9665      * Returns the actual dimensions of the data in the ImageData object, in pixels.
9666      */
9667     readonly width: number;
9668 }
9669
9670 declare var ImageData: {
9671     prototype: ImageData;
9672     new(sw: number, sh: number): ImageData;
9673     new(data: Uint8ClampedArray, sw: number, sh?: number): ImageData;
9674 };
9675
9676 interface InnerHTML {
9677     innerHTML: string;
9678 }
9679
9680 interface InputDeviceInfo extends MediaDeviceInfo {
9681     getCapabilities(): MediaTrackCapabilities;
9682 }
9683
9684 declare var InputDeviceInfo: {
9685     prototype: InputDeviceInfo;
9686     new(): InputDeviceInfo;
9687 };
9688
9689 interface InputEvent extends UIEvent {
9690     readonly data: string | null;
9691     readonly inputType: string;
9692     readonly isComposing: boolean;
9693 }
9694
9695 declare var InputEvent: {
9696     prototype: InputEvent;
9697     new(type: string, eventInitDict?: InputEventInit): InputEvent;
9698 };
9699
9700 /** 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. */
9701 interface IntersectionObserver {
9702     readonly root: Element | Document | null;
9703     readonly rootMargin: string;
9704     readonly thresholds: ReadonlyArray<number>;
9705     disconnect(): void;
9706     observe(target: Element): void;
9707     takeRecords(): IntersectionObserverEntry[];
9708     unobserve(target: Element): void;
9709 }
9710
9711 declare var IntersectionObserver: {
9712     prototype: IntersectionObserver;
9713     new(callback: IntersectionObserverCallback, options?: IntersectionObserverInit): IntersectionObserver;
9714 };
9715
9716 /** This Intersection Observer API interface describes the intersection between the target element and its root container at a specific moment of transition. */
9717 interface IntersectionObserverEntry {
9718     readonly boundingClientRect: DOMRectReadOnly;
9719     readonly intersectionRatio: number;
9720     readonly intersectionRect: DOMRectReadOnly;
9721     readonly isIntersecting: boolean;
9722     readonly rootBounds: DOMRectReadOnly | null;
9723     readonly target: Element;
9724     readonly time: number;
9725 }
9726
9727 declare var IntersectionObserverEntry: {
9728     prototype: IntersectionObserverEntry;
9729     new(intersectionObserverEntryInit: IntersectionObserverEntryInit): IntersectionObserverEntry;
9730 };
9731
9732 /** 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. */
9733 interface KeyboardEvent extends UIEvent {
9734     readonly altKey: boolean;
9735     /** @deprecated */
9736     char: string;
9737     /** @deprecated */
9738     readonly charCode: number;
9739     readonly code: string;
9740     readonly ctrlKey: boolean;
9741     readonly isComposing: boolean;
9742     readonly key: string;
9743     /** @deprecated */
9744     readonly keyCode: number;
9745     readonly location: number;
9746     readonly metaKey: boolean;
9747     readonly repeat: boolean;
9748     readonly shiftKey: boolean;
9749     getModifierState(keyArg: string): boolean;
9750     readonly DOM_KEY_LOCATION_LEFT: number;
9751     readonly DOM_KEY_LOCATION_NUMPAD: number;
9752     readonly DOM_KEY_LOCATION_RIGHT: number;
9753     readonly DOM_KEY_LOCATION_STANDARD: number;
9754 }
9755
9756 declare var KeyboardEvent: {
9757     prototype: KeyboardEvent;
9758     new(type: string, eventInitDict?: KeyboardEventInit): KeyboardEvent;
9759     readonly DOM_KEY_LOCATION_LEFT: number;
9760     readonly DOM_KEY_LOCATION_NUMPAD: number;
9761     readonly DOM_KEY_LOCATION_RIGHT: number;
9762     readonly DOM_KEY_LOCATION_STANDARD: number;
9763 };
9764
9765 interface KeyframeEffect extends AnimationEffect {
9766     composite: CompositeOperation;
9767     iterationComposite: IterationCompositeOperation;
9768     target: Element | null;
9769     getKeyframes(): ComputedKeyframe[];
9770     setKeyframes(keyframes: Keyframe[] | PropertyIndexedKeyframes | null): void;
9771 }
9772
9773 declare var KeyframeEffect: {
9774     prototype: KeyframeEffect;
9775     new(target: Element | null, keyframes: Keyframe[] | PropertyIndexedKeyframes | null, options?: number | KeyframeEffectOptions): KeyframeEffect;
9776     new(source: KeyframeEffect): KeyframeEffect;
9777 };
9778
9779 interface LinkStyle {
9780     readonly sheet: CSSStyleSheet | null;
9781 }
9782
9783 interface ListeningStateChangedEvent extends Event {
9784     readonly label: string;
9785     readonly state: ListeningState;
9786 }
9787
9788 declare var ListeningStateChangedEvent: {
9789     prototype: ListeningStateChangedEvent;
9790     new(): ListeningStateChangedEvent;
9791 };
9792
9793 /** 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. */
9794 interface Location {
9795     /**
9796      * Returns a DOMStringList object listing the origins of the ancestor browsing contexts, from the parent browsing context to the top-level browsing context.
9797      */
9798     readonly ancestorOrigins: DOMStringList;
9799     /**
9800      * Returns the Location object's URL's fragment (includes leading "#" if non-empty).
9801      *
9802      * Can be set, to navigate to the same URL with a changed fragment (ignores leading "#").
9803      */
9804     hash: string;
9805     /**
9806      * Returns the Location object's URL's host and port (if different from the default port for the scheme).
9807      *
9808      * Can be set, to navigate to the same URL with a changed host and port.
9809      */
9810     host: string;
9811     /**
9812      * Returns the Location object's URL's host.
9813      *
9814      * Can be set, to navigate to the same URL with a changed host.
9815      */
9816     hostname: string;
9817     /**
9818      * Returns the Location object's URL.
9819      *
9820      * Can be set, to navigate to the given URL.
9821      */
9822     href: string;
9823     toString(): string;
9824     /**
9825      * Returns the Location object's URL's origin.
9826      */
9827     readonly origin: string;
9828     /**
9829      * Returns the Location object's URL's path.
9830      *
9831      * Can be set, to navigate to the same URL with a changed path.
9832      */
9833     pathname: string;
9834     /**
9835      * Returns the Location object's URL's port.
9836      *
9837      * Can be set, to navigate to the same URL with a changed port.
9838      */
9839     port: string;
9840     /**
9841      * Returns the Location object's URL's scheme.
9842      *
9843      * Can be set, to navigate to the same URL with a changed scheme.
9844      */
9845     protocol: string;
9846     /**
9847      * Returns the Location object's URL's query (includes leading "?" if non-empty).
9848      *
9849      * Can be set, to navigate to the same URL with a changed query (ignores leading "?").
9850      */
9851     search: string;
9852     /**
9853      * Navigates to the given URL.
9854      */
9855     assign(url: string): void;
9856     /**
9857      * Reloads the current page.
9858      */
9859     reload(): void;
9860     /** @deprecated */
9861     reload(forcedReload: boolean): void;
9862     /**
9863      * Removes the current page from the session history and navigates to the given URL.
9864      */
9865     replace(url: string): void;
9866 }
9867
9868 declare var Location: {
9869     prototype: Location;
9870     new(): Location;
9871 };
9872
9873 interface MSAssertion {
9874     readonly id: string;
9875     readonly type: MSCredentialType;
9876 }
9877
9878 declare var MSAssertion: {
9879     prototype: MSAssertion;
9880     new(): MSAssertion;
9881 };
9882
9883 interface MSBlobBuilder {
9884     append(data: any, endings?: string): void;
9885     getBlob(contentType?: string): Blob;
9886 }
9887
9888 declare var MSBlobBuilder: {
9889     prototype: MSBlobBuilder;
9890     new(): MSBlobBuilder;
9891 };
9892
9893 interface MSFIDOCredentialAssertion extends MSAssertion {
9894     readonly algorithm: string | Algorithm;
9895     readonly attestation: any;
9896     readonly publicKey: string;
9897     readonly transportHints: MSTransportType[];
9898 }
9899
9900 declare var MSFIDOCredentialAssertion: {
9901     prototype: MSFIDOCredentialAssertion;
9902     new(): MSFIDOCredentialAssertion;
9903 };
9904
9905 interface MSFIDOSignature {
9906     readonly authnrData: string;
9907     readonly clientData: string;
9908     readonly signature: string;
9909 }
9910
9911 declare var MSFIDOSignature: {
9912     prototype: MSFIDOSignature;
9913     new(): MSFIDOSignature;
9914 };
9915
9916 interface MSFIDOSignatureAssertion extends MSAssertion {
9917     readonly signature: MSFIDOSignature;
9918 }
9919
9920 declare var MSFIDOSignatureAssertion: {
9921     prototype: MSFIDOSignatureAssertion;
9922     new(): MSFIDOSignatureAssertion;
9923 };
9924
9925 interface MSFileSaver {
9926     msSaveBlob(blob: any, defaultName?: string): boolean;
9927     msSaveOrOpenBlob(blob: any, defaultName?: string): boolean;
9928 }
9929
9930 interface MSGesture {
9931     target: Element;
9932     addPointer(pointerId: number): void;
9933     stop(): void;
9934 }
9935
9936 declare var MSGesture: {
9937     prototype: MSGesture;
9938     new(): MSGesture;
9939 };
9940
9941 /** The MSGestureEvent is a proprietary interface specific to Internet Explorer and Microsoft Edge which represents events that occur due to touch gestures. Events using this interface include MSGestureStart, MSGestureEnd, MSGestureTap, MSGestureHold, MSGestureChange, and MSInertiaStart. */
9942 interface MSGestureEvent extends UIEvent {
9943     readonly clientX: number;
9944     readonly clientY: number;
9945     readonly expansion: number;
9946     readonly gestureObject: any;
9947     readonly hwTimestamp: number;
9948     readonly offsetX: number;
9949     readonly offsetY: number;
9950     readonly rotation: number;
9951     readonly scale: number;
9952     readonly screenX: number;
9953     readonly screenY: number;
9954     readonly translationX: number;
9955     readonly translationY: number;
9956     readonly velocityAngular: number;
9957     readonly velocityExpansion: number;
9958     readonly velocityX: number;
9959     readonly velocityY: number;
9960     initGestureEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, viewArg: Window, detailArg: number, screenXArg: number, screenYArg: number, clientXArg: number, clientYArg: number, offsetXArg: number, offsetYArg: number, translationXArg: number, translationYArg: number, scaleArg: number, expansionArg: number, rotationArg: number, velocityXArg: number, velocityYArg: number, velocityExpansionArg: number, velocityAngularArg: number, hwTimestampArg: number): void;
9961     readonly MSGESTURE_FLAG_BEGIN: number;
9962     readonly MSGESTURE_FLAG_CANCEL: number;
9963     readonly MSGESTURE_FLAG_END: number;
9964     readonly MSGESTURE_FLAG_INERTIA: number;
9965     readonly MSGESTURE_FLAG_NONE: number;
9966 }
9967
9968 declare var MSGestureEvent: {
9969     prototype: MSGestureEvent;
9970     new(): MSGestureEvent;
9971     readonly MSGESTURE_FLAG_BEGIN: number;
9972     readonly MSGESTURE_FLAG_CANCEL: number;
9973     readonly MSGESTURE_FLAG_END: number;
9974     readonly MSGESTURE_FLAG_INERTIA: number;
9975     readonly MSGESTURE_FLAG_NONE: number;
9976 };
9977
9978 /** The msGraphicsTrust() constructor returns an object that provides properties for info on protected video playback. */
9979 interface MSGraphicsTrust {
9980     readonly constrictionActive: boolean;
9981     readonly status: string;
9982 }
9983
9984 declare var MSGraphicsTrust: {
9985     prototype: MSGraphicsTrust;
9986     new(): MSGraphicsTrust;
9987 };
9988
9989 interface MSInputMethodContextEventMap {
9990     "MSCandidateWindowHide": Event;
9991     "MSCandidateWindowShow": Event;
9992     "MSCandidateWindowUpdate": Event;
9993 }
9994
9995 interface MSInputMethodContext extends EventTarget {
9996     readonly compositionEndOffset: number;
9997     readonly compositionStartOffset: number;
9998     oncandidatewindowhide: ((this: MSInputMethodContext, ev: Event) => any) | null;
9999     oncandidatewindowshow: ((this: MSInputMethodContext, ev: Event) => any) | null;
10000     oncandidatewindowupdate: ((this: MSInputMethodContext, ev: Event) => any) | null;
10001     readonly target: HTMLElement;
10002     getCandidateWindowClientRect(): ClientRect;
10003     getCompositionAlternatives(): string[];
10004     hasComposition(): boolean;
10005     isCandidateWindowVisible(): boolean;
10006     addEventListener<K extends keyof MSInputMethodContextEventMap>(type: K, listener: (this: MSInputMethodContext, ev: MSInputMethodContextEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10007     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10008     removeEventListener<K extends keyof MSInputMethodContextEventMap>(type: K, listener: (this: MSInputMethodContext, ev: MSInputMethodContextEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10009     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10010 }
10011
10012 declare var MSInputMethodContext: {
10013     prototype: MSInputMethodContext;
10014     new(): MSInputMethodContext;
10015 };
10016
10017 interface MSMediaKeyError {
10018     readonly code: number;
10019     readonly systemCode: number;
10020     readonly MS_MEDIA_KEYERR_CLIENT: number;
10021     readonly MS_MEDIA_KEYERR_DOMAIN: number;
10022     readonly MS_MEDIA_KEYERR_HARDWARECHANGE: number;
10023     readonly MS_MEDIA_KEYERR_OUTPUT: number;
10024     readonly MS_MEDIA_KEYERR_SERVICE: number;
10025     readonly MS_MEDIA_KEYERR_UNKNOWN: number;
10026 }
10027
10028 declare var MSMediaKeyError: {
10029     prototype: MSMediaKeyError;
10030     new(): MSMediaKeyError;
10031     readonly MS_MEDIA_KEYERR_CLIENT: number;
10032     readonly MS_MEDIA_KEYERR_DOMAIN: number;
10033     readonly MS_MEDIA_KEYERR_HARDWARECHANGE: number;
10034     readonly MS_MEDIA_KEYERR_OUTPUT: number;
10035     readonly MS_MEDIA_KEYERR_SERVICE: number;
10036     readonly MS_MEDIA_KEYERR_UNKNOWN: number;
10037 };
10038
10039 interface MSMediaKeyMessageEvent extends Event {
10040     readonly destinationURL: string | null;
10041     readonly message: Uint8Array;
10042 }
10043
10044 declare var MSMediaKeyMessageEvent: {
10045     prototype: MSMediaKeyMessageEvent;
10046     new(): MSMediaKeyMessageEvent;
10047 };
10048
10049 interface MSMediaKeyNeededEvent extends Event {
10050     readonly initData: Uint8Array | null;
10051 }
10052
10053 declare var MSMediaKeyNeededEvent: {
10054     prototype: MSMediaKeyNeededEvent;
10055     new(): MSMediaKeyNeededEvent;
10056 };
10057
10058 interface MSMediaKeySession extends EventTarget {
10059     readonly error: MSMediaKeyError | null;
10060     readonly keySystem: string;
10061     readonly sessionId: string;
10062     close(): void;
10063     update(key: Uint8Array): void;
10064 }
10065
10066 declare var MSMediaKeySession: {
10067     prototype: MSMediaKeySession;
10068     new(): MSMediaKeySession;
10069 };
10070
10071 interface MSMediaKeys {
10072     readonly keySystem: string;
10073     createSession(type: string, initData: Uint8Array, cdmData?: Uint8Array | null): MSMediaKeySession;
10074 }
10075
10076 declare var MSMediaKeys: {
10077     prototype: MSMediaKeys;
10078     new(keySystem: string): MSMediaKeys;
10079     isTypeSupported(keySystem: string, type?: string | null): boolean;
10080     isTypeSupportedWithFeatures(keySystem: string, type?: string | null): string;
10081 };
10082
10083 interface MSNavigatorDoNotTrack {
10084     confirmSiteSpecificTrackingException(args: ConfirmSiteSpecificExceptionsInformation): boolean;
10085     confirmWebWideTrackingException(args: ExceptionInformation): boolean;
10086     removeSiteSpecificTrackingException(args: ExceptionInformation): void;
10087     removeWebWideTrackingException(args: ExceptionInformation): void;
10088     storeSiteSpecificTrackingException(args: StoreSiteSpecificExceptionsInformation): void;
10089     storeWebWideTrackingException(args: StoreExceptionsInformation): void;
10090 }
10091
10092 interface MSPointerEvent extends MouseEvent {
10093     readonly currentPoint: any;
10094     readonly height: number;
10095     readonly hwTimestamp: number;
10096     readonly intermediatePoints: any;
10097     readonly isPrimary: boolean;
10098     readonly pointerId: number;
10099     readonly pointerType: any;
10100     readonly pressure: number;
10101     readonly rotation: number;
10102     readonly tiltX: number;
10103     readonly tiltY: number;
10104     readonly width: number;
10105     getCurrentPoint(element: Element): void;
10106     getIntermediatePoints(element: Element): void;
10107     initPointerEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, viewArg: Window, detailArg: number, screenXArg: number, screenYArg: number, clientXArg: number, clientYArg: number, ctrlKeyArg: boolean, altKeyArg: boolean, shiftKeyArg: boolean, metaKeyArg: boolean, buttonArg: number, relatedTargetArg: EventTarget, offsetXArg: number, offsetYArg: number, widthArg: number, heightArg: number, pressure: number, rotation: number, tiltX: number, tiltY: number, pointerIdArg: number, pointerType: any, hwTimestampArg: number, isPrimary: boolean): void;
10108 }
10109
10110 declare var MSPointerEvent: {
10111     prototype: MSPointerEvent;
10112     new(typeArg: string, eventInitDict?: PointerEventInit): MSPointerEvent;
10113 };
10114
10115 interface MSStream {
10116     readonly type: string;
10117     msClose(): void;
10118     msDetachStream(): any;
10119 }
10120
10121 declare var MSStream: {
10122     prototype: MSStream;
10123     new(): MSStream;
10124 };
10125
10126 /** The MediaDevicesInfo interface contains information that describes a single media input or output device. */
10127 interface MediaDeviceInfo {
10128     readonly deviceId: string;
10129     readonly groupId: string;
10130     readonly kind: MediaDeviceKind;
10131     readonly label: string;
10132     toJSON(): any;
10133 }
10134
10135 declare var MediaDeviceInfo: {
10136     prototype: MediaDeviceInfo;
10137     new(): MediaDeviceInfo;
10138 };
10139
10140 interface MediaDevicesEventMap {
10141     "devicechange": Event;
10142 }
10143
10144 /** Provides access to connected media input devices like cameras and microphones, as well as screen sharing. In essence, it lets you obtain access to any hardware source of media data. */
10145 interface MediaDevices extends EventTarget {
10146     ondevicechange: ((this: MediaDevices, ev: Event) => any) | null;
10147     enumerateDevices(): Promise<MediaDeviceInfo[]>;
10148     getSupportedConstraints(): MediaTrackSupportedConstraints;
10149     getUserMedia(constraints?: MediaStreamConstraints): Promise<MediaStream>;
10150     addEventListener<K extends keyof MediaDevicesEventMap>(type: K, listener: (this: MediaDevices, ev: MediaDevicesEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10151     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10152     removeEventListener<K extends keyof MediaDevicesEventMap>(type: K, listener: (this: MediaDevices, ev: MediaDevicesEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10153     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10154 }
10155
10156 declare var MediaDevices: {
10157     prototype: MediaDevices;
10158     new(): MediaDevices;
10159 };
10160
10161 /** A MediaElementSourceNode has no inputs and exactly one output, and is created using the AudioContext.createMediaElementSource method. The amount of channels in the output equals the number of channels of the audio referenced by the HTMLMediaElement used in the creation of the node, or is 1 if the HTMLMediaElement has no audio. */
10162 interface MediaElementAudioSourceNode extends AudioNode {
10163     readonly mediaElement: HTMLMediaElement;
10164 }
10165
10166 declare var MediaElementAudioSourceNode: {
10167     prototype: MediaElementAudioSourceNode;
10168     new(context: AudioContext, options: MediaElementAudioSourceOptions): MediaElementAudioSourceNode;
10169 };
10170
10171 interface MediaEncryptedEvent extends Event {
10172     readonly initData: ArrayBuffer | null;
10173     readonly initDataType: string;
10174 }
10175
10176 declare var MediaEncryptedEvent: {
10177     prototype: MediaEncryptedEvent;
10178     new(type: string, eventInitDict?: MediaEncryptedEventInit): MediaEncryptedEvent;
10179 };
10180
10181 /** An error which occurred while handling media in an HTML media element based on HTMLMediaElement, such as <audio> or <video>. */
10182 interface MediaError {
10183     readonly code: number;
10184     readonly message: string;
10185     readonly MEDIA_ERR_ABORTED: number;
10186     readonly MEDIA_ERR_DECODE: number;
10187     readonly MEDIA_ERR_NETWORK: number;
10188     readonly MEDIA_ERR_SRC_NOT_SUPPORTED: number;
10189 }
10190
10191 declare var MediaError: {
10192     prototype: MediaError;
10193     new(): MediaError;
10194     readonly MEDIA_ERR_ABORTED: number;
10195     readonly MEDIA_ERR_DECODE: number;
10196     readonly MEDIA_ERR_NETWORK: number;
10197     readonly MEDIA_ERR_SRC_NOT_SUPPORTED: number;
10198 };
10199
10200 /** This EncryptedMediaExtensions API interface contains the content and related data when the content decryption module generates a message for the session. */
10201 interface MediaKeyMessageEvent extends Event {
10202     readonly message: ArrayBuffer;
10203     readonly messageType: MediaKeyMessageType;
10204 }
10205
10206 declare var MediaKeyMessageEvent: {
10207     prototype: MediaKeyMessageEvent;
10208     new(type: string, eventInitDict: MediaKeyMessageEventInit): MediaKeyMessageEvent;
10209 };
10210
10211 interface MediaKeySessionEventMap {
10212     "keystatuseschange": Event;
10213     "message": MediaKeyMessageEvent;
10214 }
10215
10216 /** This EncryptedMediaExtensions API interface represents a context for message exchange with a content decryption module (CDM). */
10217 interface MediaKeySession extends EventTarget {
10218     readonly closed: Promise<void>;
10219     readonly expiration: number;
10220     readonly keyStatuses: MediaKeyStatusMap;
10221     onkeystatuseschange: ((this: MediaKeySession, ev: Event) => any) | null;
10222     onmessage: ((this: MediaKeySession, ev: MediaKeyMessageEvent) => any) | null;
10223     readonly sessionId: string;
10224     close(): Promise<void>;
10225     generateRequest(initDataType: string, initData: BufferSource): Promise<void>;
10226     load(sessionId: string): Promise<boolean>;
10227     remove(): Promise<void>;
10228     update(response: BufferSource): Promise<void>;
10229     addEventListener<K extends keyof MediaKeySessionEventMap>(type: K, listener: (this: MediaKeySession, ev: MediaKeySessionEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10230     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10231     removeEventListener<K extends keyof MediaKeySessionEventMap>(type: K, listener: (this: MediaKeySession, ev: MediaKeySessionEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10232     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10233 }
10234
10235 declare var MediaKeySession: {
10236     prototype: MediaKeySession;
10237     new(): MediaKeySession;
10238 };
10239
10240 /** This EncryptedMediaExtensions API interface is a read-only map of media key statuses by key IDs. */
10241 interface MediaKeyStatusMap {
10242     readonly size: number;
10243     get(keyId: BufferSource): MediaKeyStatus | undefined;
10244     has(keyId: BufferSource): boolean;
10245     forEach(callbackfn: (value: MediaKeyStatus, key: BufferSource, parent: MediaKeyStatusMap) => void, thisArg?: any): void;
10246 }
10247
10248 declare var MediaKeyStatusMap: {
10249     prototype: MediaKeyStatusMap;
10250     new(): MediaKeyStatusMap;
10251 };
10252
10253 /** This EncryptedMediaExtensions API interface provides access to a Key System for decryption and/or a content protection provider. You can request an instance of this object using the Navigator.requestMediaKeySystemAccess method. */
10254 interface MediaKeySystemAccess {
10255     readonly keySystem: string;
10256     createMediaKeys(): Promise<MediaKeys>;
10257     getConfiguration(): MediaKeySystemConfiguration;
10258 }
10259
10260 declare var MediaKeySystemAccess: {
10261     prototype: MediaKeySystemAccess;
10262     new(): MediaKeySystemAccess;
10263 };
10264
10265 /** This EncryptedMediaExtensions API interface the represents a set of keys that an associated HTMLMediaElement can use for decryption of media data during playback. */
10266 interface MediaKeys {
10267     createSession(sessionType?: MediaKeySessionType): MediaKeySession;
10268     setServerCertificate(serverCertificate: BufferSource): Promise<boolean>;
10269 }
10270
10271 declare var MediaKeys: {
10272     prototype: MediaKeys;
10273     new(): MediaKeys;
10274 };
10275
10276 interface MediaList {
10277     readonly length: number;
10278     mediaText: string;
10279     toString(): string;
10280     appendMedium(medium: string): void;
10281     deleteMedium(medium: string): void;
10282     item(index: number): string | null;
10283     [index: number]: string;
10284 }
10285
10286 declare var MediaList: {
10287     prototype: MediaList;
10288     new(): MediaList;
10289 };
10290
10291 interface MediaQueryListEventMap {
10292     "change": MediaQueryListEvent;
10293 }
10294
10295 /** Stores information on a media query applied to a document, and handles sending notifications to listeners when the media query state change (i.e. when the media query test starts or stops evaluating to true). */
10296 interface MediaQueryList extends EventTarget {
10297     readonly matches: boolean;
10298     readonly media: string;
10299     onchange: ((this: MediaQueryList, ev: MediaQueryListEvent) => any) | null;
10300     /** @deprecated */
10301     addListener(listener: ((this: MediaQueryList, ev: MediaQueryListEvent) => any) | null): void;
10302     /** @deprecated */
10303     removeListener(listener: ((this: MediaQueryList, ev: MediaQueryListEvent) => any) | null): void;
10304     addEventListener<K extends keyof MediaQueryListEventMap>(type: K, listener: (this: MediaQueryList, ev: MediaQueryListEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10305     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10306     removeEventListener<K extends keyof MediaQueryListEventMap>(type: K, listener: (this: MediaQueryList, ev: MediaQueryListEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10307     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10308 }
10309
10310 declare var MediaQueryList: {
10311     prototype: MediaQueryList;
10312     new(): MediaQueryList;
10313 };
10314
10315 interface MediaQueryListEvent extends Event {
10316     readonly matches: boolean;
10317     readonly media: string;
10318 }
10319
10320 declare var MediaQueryListEvent: {
10321     prototype: MediaQueryListEvent;
10322     new(type: string, eventInitDict?: MediaQueryListEventInit): MediaQueryListEvent;
10323 };
10324
10325 interface MediaSourceEventMap {
10326     "sourceclose": Event;
10327     "sourceended": Event;
10328     "sourceopen": Event;
10329 }
10330
10331 /** This Media Source Extensions API interface represents a source of media data for an HTMLMediaElement object. A MediaSource object can be attached to a HTMLMediaElement to be played in the user agent. */
10332 interface MediaSource extends EventTarget {
10333     readonly activeSourceBuffers: SourceBufferList;
10334     duration: number;
10335     onsourceclose: ((this: MediaSource, ev: Event) => any) | null;
10336     onsourceended: ((this: MediaSource, ev: Event) => any) | null;
10337     onsourceopen: ((this: MediaSource, ev: Event) => any) | null;
10338     readonly readyState: ReadyState;
10339     readonly sourceBuffers: SourceBufferList;
10340     addSourceBuffer(type: string): SourceBuffer;
10341     clearLiveSeekableRange(): void;
10342     endOfStream(error?: EndOfStreamError): void;
10343     removeSourceBuffer(sourceBuffer: SourceBuffer): void;
10344     setLiveSeekableRange(start: number, end: number): void;
10345     addEventListener<K extends keyof MediaSourceEventMap>(type: K, listener: (this: MediaSource, ev: MediaSourceEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10346     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10347     removeEventListener<K extends keyof MediaSourceEventMap>(type: K, listener: (this: MediaSource, ev: MediaSourceEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10348     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10349 }
10350
10351 declare var MediaSource: {
10352     prototype: MediaSource;
10353     new(): MediaSource;
10354     isTypeSupported(type: string): boolean;
10355 };
10356
10357 interface MediaStreamEventMap {
10358     "addtrack": MediaStreamTrackEvent;
10359     "removetrack": MediaStreamTrackEvent;
10360 }
10361
10362 /** A stream of media content. A stream consists of several tracks such as video or audio tracks. Each track is specified as an instance of MediaStreamTrack. */
10363 interface MediaStream extends EventTarget {
10364     readonly active: boolean;
10365     readonly id: string;
10366     onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
10367     onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
10368     addTrack(track: MediaStreamTrack): void;
10369     clone(): MediaStream;
10370     getAudioTracks(): MediaStreamTrack[];
10371     getTrackById(trackId: string): MediaStreamTrack | null;
10372     getTracks(): MediaStreamTrack[];
10373     getVideoTracks(): MediaStreamTrack[];
10374     removeTrack(track: MediaStreamTrack): void;
10375     addEventListener<K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10376     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10377     removeEventListener<K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10378     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10379 }
10380
10381 declare var MediaStream: {
10382     prototype: MediaStream;
10383     new(): MediaStream;
10384     new(stream: MediaStream): MediaStream;
10385     new(tracks: MediaStreamTrack[]): MediaStream;
10386 };
10387
10388 interface MediaStreamAudioDestinationNode extends AudioNode {
10389     readonly stream: MediaStream;
10390 }
10391
10392 declare var MediaStreamAudioDestinationNode: {
10393     prototype: MediaStreamAudioDestinationNode;
10394     new(context: AudioContext, options?: AudioNodeOptions): MediaStreamAudioDestinationNode;
10395 };
10396
10397 /** A type of AudioNode which operates as an audio source whose media is received from a MediaStream obtained using the WebRTC or Media Capture and Streams APIs. */
10398 interface MediaStreamAudioSourceNode extends AudioNode {
10399     readonly mediaStream: MediaStream;
10400 }
10401
10402 declare var MediaStreamAudioSourceNode: {
10403     prototype: MediaStreamAudioSourceNode;
10404     new(context: AudioContext, options: MediaStreamAudioSourceOptions): MediaStreamAudioSourceNode;
10405 };
10406
10407 interface MediaStreamError {
10408     readonly constraintName: string | null;
10409     readonly message: string | null;
10410     readonly name: string;
10411 }
10412
10413 declare var MediaStreamError: {
10414     prototype: MediaStreamError;
10415     new(): MediaStreamError;
10416 };
10417
10418 interface MediaStreamErrorEvent extends Event {
10419     readonly error: MediaStreamError | null;
10420 }
10421
10422 declare var MediaStreamErrorEvent: {
10423     prototype: MediaStreamErrorEvent;
10424     new(typeArg: string, eventInitDict?: MediaStreamErrorEventInit): MediaStreamErrorEvent;
10425 };
10426
10427 /** Events that occurs in relation to a MediaStream. Two events of this type can be thrown: addstream and removestream. */
10428 interface MediaStreamEvent extends Event {
10429     readonly stream: MediaStream | null;
10430 }
10431
10432 declare var MediaStreamEvent: {
10433     prototype: MediaStreamEvent;
10434     new(type: string, eventInitDict: MediaStreamEventInit): MediaStreamEvent;
10435 };
10436
10437 interface MediaStreamTrackEventMap {
10438     "ended": Event;
10439     "isolationchange": Event;
10440     "mute": Event;
10441     "unmute": Event;
10442 }
10443
10444 /** A single media track within a stream; typically, these are audio or video tracks, but other track types may exist as well. */
10445 interface MediaStreamTrack extends EventTarget {
10446     enabled: boolean;
10447     readonly id: string;
10448     readonly isolated: boolean;
10449     readonly kind: string;
10450     readonly label: string;
10451     readonly muted: boolean;
10452     onended: ((this: MediaStreamTrack, ev: Event) => any) | null;
10453     onisolationchange: ((this: MediaStreamTrack, ev: Event) => any) | null;
10454     onmute: ((this: MediaStreamTrack, ev: Event) => any) | null;
10455     onunmute: ((this: MediaStreamTrack, ev: Event) => any) | null;
10456     readonly readyState: MediaStreamTrackState;
10457     applyConstraints(constraints?: MediaTrackConstraints): Promise<void>;
10458     clone(): MediaStreamTrack;
10459     getCapabilities(): MediaTrackCapabilities;
10460     getConstraints(): MediaTrackConstraints;
10461     getSettings(): MediaTrackSettings;
10462     stop(): void;
10463     addEventListener<K extends keyof MediaStreamTrackEventMap>(type: K, listener: (this: MediaStreamTrack, ev: MediaStreamTrackEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10464     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10465     removeEventListener<K extends keyof MediaStreamTrackEventMap>(type: K, listener: (this: MediaStreamTrack, ev: MediaStreamTrackEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10466     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10467 }
10468
10469 declare var MediaStreamTrack: {
10470     prototype: MediaStreamTrack;
10471     new(): MediaStreamTrack;
10472 };
10473
10474 interface MediaStreamTrackAudioSourceNode extends AudioNode {
10475 }
10476
10477 declare var MediaStreamTrackAudioSourceNode: {
10478     prototype: MediaStreamTrackAudioSourceNode;
10479     new(context: AudioContext, options: MediaStreamTrackAudioSourceOptions): MediaStreamTrackAudioSourceNode;
10480 };
10481
10482 /** Events which indicate that a MediaStream has had tracks added to or removed from the stream through calls to Media Stream API methods. These events are sent to the stream when these changes occur. */
10483 interface MediaStreamTrackEvent extends Event {
10484     readonly track: MediaStreamTrack;
10485 }
10486
10487 declare var MediaStreamTrackEvent: {
10488     prototype: MediaStreamTrackEvent;
10489     new(type: string, eventInitDict: MediaStreamTrackEventInit): MediaStreamTrackEvent;
10490 };
10491
10492 /** This Channel Messaging API interface allows us to create a new message channel and send data through it via its two MessagePort properties. */
10493 interface MessageChannel {
10494     /**
10495      * Returns the first MessagePort object.
10496      */
10497     readonly port1: MessagePort;
10498     /**
10499      * Returns the second MessagePort object.
10500      */
10501     readonly port2: MessagePort;
10502 }
10503
10504 declare var MessageChannel: {
10505     prototype: MessageChannel;
10506     new(): MessageChannel;
10507 };
10508
10509 /** A message received by a target object. */
10510 interface MessageEvent<T = any> extends Event {
10511     /**
10512      * Returns the data of the message.
10513      */
10514     readonly data: T;
10515     /**
10516      * Returns the last event ID string, for server-sent events.
10517      */
10518     readonly lastEventId: string;
10519     /**
10520      * Returns the origin of the message, for server-sent events and cross-document messaging.
10521      */
10522     readonly origin: string;
10523     /**
10524      * Returns the MessagePort array sent with the message, for cross-document messaging and channel messaging.
10525      */
10526     readonly ports: ReadonlyArray<MessagePort>;
10527     /**
10528      * Returns the WindowProxy of the source window, for cross-document messaging, and the MessagePort being attached, in the connect event fired at SharedWorkerGlobalScope objects.
10529      */
10530     readonly source: MessageEventSource | null;
10531 }
10532
10533 declare var MessageEvent: {
10534     prototype: MessageEvent;
10535     new<T>(type: string, eventInitDict?: MessageEventInit<T>): MessageEvent<T>;
10536 };
10537
10538 interface MessagePortEventMap {
10539     "message": MessageEvent;
10540     "messageerror": MessageEvent;
10541 }
10542
10543 /** This Channel Messaging API interface represents one of the two ports of a MessageChannel, allowing messages to be sent from one port and listening out for them arriving at the other. */
10544 interface MessagePort extends EventTarget {
10545     onmessage: ((this: MessagePort, ev: MessageEvent) => any) | null;
10546     onmessageerror: ((this: MessagePort, ev: MessageEvent) => any) | null;
10547     /**
10548      * Disconnects the port, so that it is no longer active.
10549      */
10550     close(): void;
10551     /**
10552      * Posts a message through the channel. Objects listed in transfer are transferred, not just cloned, meaning that they are no longer usable on the sending side.
10553      *
10554      * Throws a "DataCloneError" DOMException if transfer contains duplicate objects or port, or if message could not be cloned.
10555      */
10556     postMessage(message: any, transfer: Transferable[]): void;
10557     postMessage(message: any, options?: PostMessageOptions): void;
10558     /**
10559      * Begins dispatching messages received on the port.
10560      */
10561     start(): void;
10562     addEventListener<K extends keyof MessagePortEventMap>(type: K, listener: (this: MessagePort, ev: MessagePortEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10563     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10564     removeEventListener<K extends keyof MessagePortEventMap>(type: K, listener: (this: MessagePort, ev: MessagePortEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10565     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10566 }
10567
10568 declare var MessagePort: {
10569     prototype: MessagePort;
10570     new(): MessagePort;
10571 };
10572
10573 /** Provides contains information about a MIME type associated with a particular plugin. NavigatorPlugins.mimeTypes returns an array of this object. */
10574 interface MimeType {
10575     /**
10576      * Returns the MIME type's description.
10577      */
10578     readonly description: string;
10579     /**
10580      * Returns the Plugin object that implements this MIME type.
10581      */
10582     readonly enabledPlugin: Plugin;
10583     /**
10584      * Returns the MIME type's typical file extensions, in a comma-separated list.
10585      */
10586     readonly suffixes: string;
10587     /**
10588      * Returns the MIME type.
10589      */
10590     readonly type: string;
10591 }
10592
10593 declare var MimeType: {
10594     prototype: MimeType;
10595     new(): MimeType;
10596 };
10597
10598 /** Returns an array of MimeType instances, each of which contains information about a supported browser plugins. This object is returned by NavigatorPlugins.mimeTypes. */
10599 interface MimeTypeArray {
10600     readonly length: number;
10601     item(index: number): MimeType | null;
10602     namedItem(name: string): MimeType | null;
10603     [index: number]: MimeType;
10604 }
10605
10606 declare var MimeTypeArray: {
10607     prototype: MimeTypeArray;
10608     new(): MimeTypeArray;
10609 };
10610
10611 /** Events that occur due to the user interacting with a pointing device (such as a mouse). Common events using this interface include click, dblclick, mouseup, mousedown. */
10612 interface MouseEvent extends UIEvent {
10613     readonly altKey: boolean;
10614     readonly button: number;
10615     readonly buttons: number;
10616     readonly clientX: number;
10617     readonly clientY: number;
10618     readonly ctrlKey: boolean;
10619     readonly metaKey: boolean;
10620     readonly movementX: number;
10621     readonly movementY: number;
10622     readonly offsetX: number;
10623     readonly offsetY: number;
10624     readonly pageX: number;
10625     readonly pageY: number;
10626     readonly relatedTarget: EventTarget | null;
10627     readonly screenX: number;
10628     readonly screenY: number;
10629     readonly shiftKey: boolean;
10630     readonly x: number;
10631     readonly y: number;
10632     getModifierState(keyArg: string): boolean;
10633     initMouseEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, viewArg: Window, detailArg: number, screenXArg: number, screenYArg: number, clientXArg: number, clientYArg: number, ctrlKeyArg: boolean, altKeyArg: boolean, shiftKeyArg: boolean, metaKeyArg: boolean, buttonArg: number, relatedTargetArg: EventTarget | null): void;
10634 }
10635
10636 declare var MouseEvent: {
10637     prototype: MouseEvent;
10638     new(type: string, eventInitDict?: MouseEventInit): MouseEvent;
10639 };
10640
10641 /** Provides event properties that are specific to modifications to the Document Object Model (DOM) hierarchy and nodes.
10642  * @deprecated DOM4 [DOM] provides a new mechanism using a MutationObserver interface which addresses the use cases that mutation events solve, but in a more performant manner. Thus, this specification describes mutation events for reference and completeness of legacy behavior, but deprecates the use of the MutationEvent interface. */
10643 interface MutationEvent extends Event {
10644     readonly attrChange: number;
10645     readonly attrName: string;
10646     readonly newValue: string;
10647     readonly prevValue: string;
10648     readonly relatedNode: Node;
10649     initMutationEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, relatedNodeArg: Node, prevValueArg: string, newValueArg: string, attrNameArg: string, attrChangeArg: number): void;
10650     readonly ADDITION: number;
10651     readonly MODIFICATION: number;
10652     readonly REMOVAL: number;
10653 }
10654
10655 declare var MutationEvent: {
10656     prototype: MutationEvent;
10657     new(): MutationEvent;
10658     readonly ADDITION: number;
10659     readonly MODIFICATION: number;
10660     readonly REMOVAL: number;
10661 };
10662
10663 /** Provides the ability to watch for changes being made to the DOM tree. It is designed as a replacement for the older Mutation Events feature which was part of the DOM3 Events specification. */
10664 interface MutationObserver {
10665     /**
10666      * Stops observer from observing any mutations. Until the observe() method is used again, observer's callback will not be invoked.
10667      */
10668     disconnect(): void;
10669     /**
10670      * Instructs the user agent to observe a given target (a node) and report any mutations based on the criteria given by options (an object).
10671      *
10672      * The options argument allows for setting mutation observation options via object members.
10673      */
10674     observe(target: Node, options?: MutationObserverInit): void;
10675     /**
10676      * Empties the record queue and returns what was in there.
10677      */
10678     takeRecords(): MutationRecord[];
10679 }
10680
10681 declare var MutationObserver: {
10682     prototype: MutationObserver;
10683     new(callback: MutationCallback): MutationObserver;
10684 };
10685
10686 /** A MutationRecord represents an individual DOM mutation. It is the object that is passed to MutationObserver's callback. */
10687 interface MutationRecord {
10688     /**
10689      * Return the nodes added and removed respectively.
10690      */
10691     readonly addedNodes: NodeList;
10692     /**
10693      * Returns the local name of the changed attribute, and null otherwise.
10694      */
10695     readonly attributeName: string | null;
10696     /**
10697      * Returns the namespace of the changed attribute, and null otherwise.
10698      */
10699     readonly attributeNamespace: string | null;
10700     /**
10701      * Return the previous and next sibling respectively of the added or removed nodes, and null otherwise.
10702      */
10703     readonly nextSibling: Node | null;
10704     /**
10705      * The return value depends on type. For "attributes", it is the value of the changed attribute before the change. For "characterData", it is the data of the changed node before the change. For "childList", it is null.
10706      */
10707     readonly oldValue: string | null;
10708     /**
10709      * Return the previous and next sibling respectively of the added or removed nodes, and null otherwise.
10710      */
10711     readonly previousSibling: Node | null;
10712     /**
10713      * Return the nodes added and removed respectively.
10714      */
10715     readonly removedNodes: NodeList;
10716     /**
10717      * Returns the node the mutation affected, depending on the type. For "attributes", it is the element whose attribute changed. For "characterData", it is the CharacterData node. For "childList", it is the node whose children changed.
10718      */
10719     readonly target: Node;
10720     /**
10721      * Returns "attributes" if it was an attribute mutation. "characterData" if it was a mutation to a CharacterData node. And "childList" if it was a mutation to the tree of nodes.
10722      */
10723     readonly type: MutationRecordType;
10724 }
10725
10726 declare var MutationRecord: {
10727     prototype: MutationRecord;
10728     new(): MutationRecord;
10729 };
10730
10731 /** A collection of Attr objects. Objects inside a NamedNodeMap are not in any particular order, unlike NodeList, although they may be accessed by an index as in an array. */
10732 interface NamedNodeMap {
10733     readonly length: number;
10734     getNamedItem(qualifiedName: string): Attr | null;
10735     getNamedItemNS(namespace: string | null, localName: string): Attr | null;
10736     item(index: number): Attr | null;
10737     removeNamedItem(qualifiedName: string): Attr;
10738     removeNamedItemNS(namespace: string | null, localName: string): Attr;
10739     setNamedItem(attr: Attr): Attr | null;
10740     setNamedItemNS(attr: Attr): Attr | null;
10741     [index: number]: Attr;
10742 }
10743
10744 declare var NamedNodeMap: {
10745     prototype: NamedNodeMap;
10746     new(): NamedNodeMap;
10747 };
10748
10749 interface NavigationPreloadManager {
10750     disable(): Promise<void>;
10751     enable(): Promise<void>;
10752     getState(): Promise<NavigationPreloadState>;
10753     setHeaderValue(value: string): Promise<void>;
10754 }
10755
10756 declare var NavigationPreloadManager: {
10757     prototype: NavigationPreloadManager;
10758     new(): NavigationPreloadManager;
10759 };
10760
10761 /** The state and the identity of the user agent. It allows scripts to query it and to register themselves to carry on some activities. */
10762 interface Navigator extends MSFileSaver, MSNavigatorDoNotTrack, NavigatorAutomationInformation, NavigatorBeacon, NavigatorConcurrentHardware, NavigatorContentUtils, NavigatorCookies, NavigatorID, NavigatorLanguage, NavigatorOnLine, NavigatorPlugins, NavigatorStorage {
10763     readonly activeVRDisplays: ReadonlyArray<VRDisplay>;
10764     readonly clipboard: Clipboard;
10765     readonly credentials: CredentialsContainer;
10766     readonly doNotTrack: string | null;
10767     readonly geolocation: Geolocation;
10768     readonly maxTouchPoints: number;
10769     readonly mediaDevices: MediaDevices;
10770     readonly msManipulationViewsEnabled: boolean;
10771     readonly msMaxTouchPoints: number;
10772     readonly msPointerEnabled: boolean;
10773     readonly permissions: Permissions;
10774     readonly pointerEnabled: boolean;
10775     readonly serviceWorker: ServiceWorkerContainer;
10776     getGamepads(): (Gamepad | null)[];
10777     getUserMedia(constraints: MediaStreamConstraints, successCallback: NavigatorUserMediaSuccessCallback, errorCallback: NavigatorUserMediaErrorCallback): void;
10778     getVRDisplays(): Promise<VRDisplay[]>;
10779     msLaunchUri(uri: string, successCallback?: MSLaunchUriCallback, noHandlerCallback?: MSLaunchUriCallback): void;
10780     requestMediaKeySystemAccess(keySystem: string, supportedConfigurations: MediaKeySystemConfiguration[]): Promise<MediaKeySystemAccess>;
10781     sendBeacon(url: string, data?: BodyInit | null): boolean;
10782     share(data?: ShareData): Promise<void>;
10783     vibrate(pattern: number | number[]): boolean;
10784 }
10785
10786 declare var Navigator: {
10787     prototype: Navigator;
10788     new(): Navigator;
10789 };
10790
10791 interface NavigatorAutomationInformation {
10792     readonly webdriver: boolean;
10793 }
10794
10795 interface NavigatorBeacon {
10796     sendBeacon(url: string, data?: Blob | Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer | FormData | string | null): boolean;
10797 }
10798
10799 interface NavigatorConcurrentHardware {
10800     readonly hardwareConcurrency: number;
10801 }
10802
10803 interface NavigatorContentUtils {
10804     registerProtocolHandler(scheme: string, url: string, title: string): void;
10805     unregisterProtocolHandler(scheme: string, url: string): void;
10806 }
10807
10808 interface NavigatorCookies {
10809     readonly cookieEnabled: boolean;
10810 }
10811
10812 interface NavigatorID {
10813     readonly appCodeName: string;
10814     readonly appName: string;
10815     readonly appVersion: string;
10816     readonly platform: string;
10817     readonly product: string;
10818     readonly productSub: string;
10819     readonly userAgent: string;
10820     readonly vendor: string;
10821     readonly vendorSub: string;
10822 }
10823
10824 interface NavigatorLanguage {
10825     readonly language: string;
10826     readonly languages: ReadonlyArray<string>;
10827 }
10828
10829 interface NavigatorOnLine {
10830     readonly onLine: boolean;
10831 }
10832
10833 interface NavigatorPlugins {
10834     readonly mimeTypes: MimeTypeArray;
10835     readonly plugins: PluginArray;
10836     javaEnabled(): boolean;
10837 }
10838
10839 interface NavigatorStorage {
10840     readonly storage: StorageManager;
10841 }
10842
10843 /** Node is an interface from which a number of DOM API object types inherit. It allows those types to be treated similarly; for example, inheriting the same set of methods, or being tested in the same way. */
10844 interface Node extends EventTarget {
10845     /**
10846      * Returns node's node document's document base URL.
10847      */
10848     readonly baseURI: string;
10849     /**
10850      * Returns the children.
10851      */
10852     readonly childNodes: NodeListOf<ChildNode>;
10853     /**
10854      * Returns the first child.
10855      */
10856     readonly firstChild: ChildNode | null;
10857     /**
10858      * Returns true if node is connected and false otherwise.
10859      */
10860     readonly isConnected: boolean;
10861     /**
10862      * Returns the last child.
10863      */
10864     readonly lastChild: ChildNode | null;
10865     /** @deprecated */
10866     readonly namespaceURI: string | null;
10867     /**
10868      * Returns the next sibling.
10869      */
10870     readonly nextSibling: ChildNode | null;
10871     /**
10872      * Returns a string appropriate for the type of node.
10873      */
10874     readonly nodeName: string;
10875     /**
10876      * Returns the type of node.
10877      */
10878     readonly nodeType: number;
10879     nodeValue: string | null;
10880     /**
10881      * Returns the node document. Returns null for documents.
10882      */
10883     readonly ownerDocument: Document | null;
10884     /**
10885      * Returns the parent element.
10886      */
10887     readonly parentElement: HTMLElement | null;
10888     /**
10889      * Returns the parent.
10890      */
10891     readonly parentNode: Node & ParentNode | null;
10892     /**
10893      * Returns the previous sibling.
10894      */
10895     readonly previousSibling: ChildNode | null;
10896     textContent: string | null;
10897     appendChild<T extends Node>(newChild: T): T;
10898     /**
10899      * Returns a copy of node. If deep is true, the copy also includes the node's descendants.
10900      */
10901     cloneNode(deep?: boolean): Node;
10902     /**
10903      * Returns a bitmask indicating the position of other relative to node.
10904      */
10905     compareDocumentPosition(other: Node): number;
10906     /**
10907      * Returns true if other is an inclusive descendant of node, and false otherwise.
10908      */
10909     contains(other: Node | null): boolean;
10910     /**
10911      * Returns node's root.
10912      */
10913     getRootNode(options?: GetRootNodeOptions): Node;
10914     /**
10915      * Returns whether node has children.
10916      */
10917     hasChildNodes(): boolean;
10918     insertBefore<T extends Node>(newChild: T, refChild: Node | null): T;
10919     isDefaultNamespace(namespace: string | null): boolean;
10920     /**
10921      * Returns whether node and otherNode have the same properties.
10922      */
10923     isEqualNode(otherNode: Node | null): boolean;
10924     isSameNode(otherNode: Node | null): boolean;
10925     lookupNamespaceURI(prefix: string | null): string | null;
10926     lookupPrefix(namespace: string | null): string | null;
10927     /**
10928      * Removes empty exclusive Text nodes and concatenates the data of remaining contiguous exclusive Text nodes into the first of their nodes.
10929      */
10930     normalize(): void;
10931     removeChild<T extends Node>(oldChild: T): T;
10932     replaceChild<T extends Node>(newChild: Node, oldChild: T): T;
10933     readonly ATTRIBUTE_NODE: number;
10934     /**
10935      * node is a CDATASection node.
10936      */
10937     readonly CDATA_SECTION_NODE: number;
10938     /**
10939      * node is a Comment node.
10940      */
10941     readonly COMMENT_NODE: number;
10942     /**
10943      * node is a DocumentFragment node.
10944      */
10945     readonly DOCUMENT_FRAGMENT_NODE: number;
10946     /**
10947      * node is a document.
10948      */
10949     readonly DOCUMENT_NODE: number;
10950     /**
10951      * Set when other is a descendant of node.
10952      */
10953     readonly DOCUMENT_POSITION_CONTAINED_BY: number;
10954     /**
10955      * Set when other is an ancestor of node.
10956      */
10957     readonly DOCUMENT_POSITION_CONTAINS: number;
10958     /**
10959      * Set when node and other are not in the same tree.
10960      */
10961     readonly DOCUMENT_POSITION_DISCONNECTED: number;
10962     /**
10963      * Set when other is following node.
10964      */
10965     readonly DOCUMENT_POSITION_FOLLOWING: number;
10966     readonly DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC: number;
10967     /**
10968      * Set when other is preceding node.
10969      */
10970     readonly DOCUMENT_POSITION_PRECEDING: number;
10971     /**
10972      * node is a doctype.
10973      */
10974     readonly DOCUMENT_TYPE_NODE: number;
10975     /**
10976      * node is an element.
10977      */
10978     readonly ELEMENT_NODE: number;
10979     readonly ENTITY_NODE: number;
10980     readonly ENTITY_REFERENCE_NODE: number;
10981     readonly NOTATION_NODE: number;
10982     /**
10983      * node is a ProcessingInstruction node.
10984      */
10985     readonly PROCESSING_INSTRUCTION_NODE: number;
10986     /**
10987      * node is a Text node.
10988      */
10989     readonly TEXT_NODE: number;
10990 }
10991
10992 declare var Node: {
10993     prototype: Node;
10994     new(): Node;
10995     readonly ATTRIBUTE_NODE: number;
10996     /**
10997      * node is a CDATASection node.
10998      */
10999     readonly CDATA_SECTION_NODE: number;
11000     /**
11001      * node is a Comment node.
11002      */
11003     readonly COMMENT_NODE: number;
11004     /**
11005      * node is a DocumentFragment node.
11006      */
11007     readonly DOCUMENT_FRAGMENT_NODE: number;
11008     /**
11009      * node is a document.
11010      */
11011     readonly DOCUMENT_NODE: number;
11012     /**
11013      * Set when other is a descendant of node.
11014      */
11015     readonly DOCUMENT_POSITION_CONTAINED_BY: number;
11016     /**
11017      * Set when other is an ancestor of node.
11018      */
11019     readonly DOCUMENT_POSITION_CONTAINS: number;
11020     /**
11021      * Set when node and other are not in the same tree.
11022      */
11023     readonly DOCUMENT_POSITION_DISCONNECTED: number;
11024     /**
11025      * Set when other is following node.
11026      */
11027     readonly DOCUMENT_POSITION_FOLLOWING: number;
11028     readonly DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC: number;
11029     /**
11030      * Set when other is preceding node.
11031      */
11032     readonly DOCUMENT_POSITION_PRECEDING: number;
11033     /**
11034      * node is a doctype.
11035      */
11036     readonly DOCUMENT_TYPE_NODE: number;
11037     /**
11038      * node is an element.
11039      */
11040     readonly ELEMENT_NODE: number;
11041     readonly ENTITY_NODE: number;
11042     readonly ENTITY_REFERENCE_NODE: number;
11043     readonly NOTATION_NODE: number;
11044     /**
11045      * node is a ProcessingInstruction node.
11046      */
11047     readonly PROCESSING_INSTRUCTION_NODE: number;
11048     /**
11049      * node is a Text node.
11050      */
11051     readonly TEXT_NODE: number;
11052 };
11053
11054 /** An object used to filter the nodes in a NodeIterator or TreeWalker. They don't know anything about the DOM or how to traverse nodes; they just know how to evaluate a single node against the provided filter. */
11055 interface NodeFilter {
11056     acceptNode(node: Node): number;
11057 }
11058
11059 declare var NodeFilter: {
11060     readonly FILTER_ACCEPT: number;
11061     readonly FILTER_REJECT: number;
11062     readonly FILTER_SKIP: number;
11063     readonly SHOW_ALL: number;
11064     readonly SHOW_ATTRIBUTE: number;
11065     readonly SHOW_CDATA_SECTION: number;
11066     readonly SHOW_COMMENT: number;
11067     readonly SHOW_DOCUMENT: number;
11068     readonly SHOW_DOCUMENT_FRAGMENT: number;
11069     readonly SHOW_DOCUMENT_TYPE: number;
11070     readonly SHOW_ELEMENT: number;
11071     readonly SHOW_ENTITY: number;
11072     readonly SHOW_ENTITY_REFERENCE: number;
11073     readonly SHOW_NOTATION: number;
11074     readonly SHOW_PROCESSING_INSTRUCTION: number;
11075     readonly SHOW_TEXT: number;
11076 };
11077
11078 /** An iterator over the members of a list of the nodes in a subtree of the DOM. The nodes will be returned in document order. */
11079 interface NodeIterator {
11080     readonly filter: NodeFilter | null;
11081     readonly pointerBeforeReferenceNode: boolean;
11082     readonly referenceNode: Node;
11083     readonly root: Node;
11084     readonly whatToShow: number;
11085     detach(): void;
11086     nextNode(): Node | null;
11087     previousNode(): Node | null;
11088 }
11089
11090 declare var NodeIterator: {
11091     prototype: NodeIterator;
11092     new(): NodeIterator;
11093 };
11094
11095 /** NodeList objects are collections of nodes, usually returned by properties such as Node.childNodes and methods such as document.querySelectorAll(). */
11096 interface NodeList {
11097     /**
11098      * Returns the number of nodes in the collection.
11099      */
11100     readonly length: number;
11101     /**
11102      * Returns the node with index index from the collection. The nodes are sorted in tree order.
11103      */
11104     item(index: number): Node | null;
11105     /**
11106      * Performs the specified action for each node in an list.
11107      * @param callbackfn  A function that accepts up to three arguments. forEach calls the callbackfn function one time for each element in the list.
11108      * @param thisArg  An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
11109      */
11110     forEach(callbackfn: (value: Node, key: number, parent: NodeList) => void, thisArg?: any): void;
11111     [index: number]: Node;
11112 }
11113
11114 declare var NodeList: {
11115     prototype: NodeList;
11116     new(): NodeList;
11117 };
11118
11119 interface NodeListOf<TNode extends Node> extends NodeList {
11120     item(index: number): TNode;
11121     /**
11122      * Performs the specified action for each node in an list.
11123      * @param callbackfn  A function that accepts up to three arguments. forEach calls the callbackfn function one time for each element in the list.
11124      * @param thisArg  An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
11125      */
11126     forEach(callbackfn: (value: TNode, key: number, parent: NodeListOf<TNode>) => void, thisArg?: any): void;
11127     [index: number]: TNode;
11128 }
11129
11130 interface NonDocumentTypeChildNode {
11131     /**
11132      * Returns the first following sibling that is an element, and null otherwise.
11133      */
11134     readonly nextElementSibling: Element | null;
11135     /**
11136      * Returns the first preceding sibling that is an element, and null otherwise.
11137      */
11138     readonly previousElementSibling: Element | null;
11139 }
11140
11141 interface NonElementParentNode {
11142     /**
11143      * Returns the first element within node's descendants whose ID is elementId.
11144      */
11145     getElementById(elementId: string): Element | null;
11146 }
11147
11148 interface NotificationEventMap {
11149     "click": Event;
11150     "close": Event;
11151     "error": Event;
11152     "show": Event;
11153 }
11154
11155 /** This Notifications API interface is used to configure and display desktop notifications to the user. */
11156 interface Notification extends EventTarget {
11157     readonly actions: ReadonlyArray<NotificationAction>;
11158     readonly badge: string;
11159     readonly body: string;
11160     readonly data: any;
11161     readonly dir: NotificationDirection;
11162     readonly icon: string;
11163     readonly image: string;
11164     readonly lang: string;
11165     onclick: ((this: Notification, ev: Event) => any) | null;
11166     onclose: ((this: Notification, ev: Event) => any) | null;
11167     onerror: ((this: Notification, ev: Event) => any) | null;
11168     onshow: ((this: Notification, ev: Event) => any) | null;
11169     readonly renotify: boolean;
11170     readonly requireInteraction: boolean;
11171     readonly silent: boolean;
11172     readonly tag: string;
11173     readonly timestamp: number;
11174     readonly title: string;
11175     readonly vibrate: ReadonlyArray<number>;
11176     close(): void;
11177     addEventListener<K extends keyof NotificationEventMap>(type: K, listener: (this: Notification, ev: NotificationEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11178     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11179     removeEventListener<K extends keyof NotificationEventMap>(type: K, listener: (this: Notification, ev: NotificationEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11180     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11181 }
11182
11183 declare var Notification: {
11184     prototype: Notification;
11185     new(title: string, options?: NotificationOptions): Notification;
11186     readonly maxActions: number;
11187     readonly permission: NotificationPermission;
11188     requestPermission(deprecatedCallback?: NotificationPermissionCallback): Promise<NotificationPermission>;
11189 };
11190
11191 /** The OES_element_index_uint extension is part of the WebGL API and adds support for gl.UNSIGNED_INT types to WebGLRenderingContext.drawElements(). */
11192 interface OES_element_index_uint {
11193 }
11194
11195 /** The OES_standard_derivatives extension is part of the WebGL API and adds the GLSL derivative functions dFdx, dFdy, and fwidth. */
11196 interface OES_standard_derivatives {
11197     readonly FRAGMENT_SHADER_DERIVATIVE_HINT_OES: GLenum;
11198 }
11199
11200 /** The OES_texture_float extension is part of the WebGL API and exposes floating-point pixel types for textures. */
11201 interface OES_texture_float {
11202 }
11203
11204 /** The OES_texture_float_linear extension is part of the WebGL API and allows linear filtering with floating-point pixel types for textures. */
11205 interface OES_texture_float_linear {
11206 }
11207
11208 /** The OES_texture_half_float extension is part of the WebGL API and adds texture formats with 16- (aka half float) and 32-bit floating-point components. */
11209 interface OES_texture_half_float {
11210     readonly HALF_FLOAT_OES: GLenum;
11211 }
11212
11213 /** The OES_texture_half_float_linear extension is part of the WebGL API and allows linear filtering with half floating-point pixel types for textures. */
11214 interface OES_texture_half_float_linear {
11215 }
11216
11217 interface OES_vertex_array_object {
11218     bindVertexArrayOES(arrayObject: WebGLVertexArrayObjectOES | null): void;
11219     createVertexArrayOES(): WebGLVertexArrayObjectOES | null;
11220     deleteVertexArrayOES(arrayObject: WebGLVertexArrayObjectOES | null): void;
11221     isVertexArrayOES(arrayObject: WebGLVertexArrayObjectOES | null): GLboolean;
11222     readonly VERTEX_ARRAY_BINDING_OES: GLenum;
11223 }
11224
11225 /** The Web Audio API OfflineAudioCompletionEvent interface represents events that occur when the processing of an OfflineAudioContext is terminated. The complete event implements this interface. */
11226 interface OfflineAudioCompletionEvent extends Event {
11227     readonly renderedBuffer: AudioBuffer;
11228 }
11229
11230 declare var OfflineAudioCompletionEvent: {
11231     prototype: OfflineAudioCompletionEvent;
11232     new(type: string, eventInitDict: OfflineAudioCompletionEventInit): OfflineAudioCompletionEvent;
11233 };
11234
11235 interface OfflineAudioContextEventMap extends BaseAudioContextEventMap {
11236     "complete": OfflineAudioCompletionEvent;
11237 }
11238
11239 /** An AudioContext interface representing an audio-processing graph built from linked together AudioNodes. In contrast with a standard AudioContext, an OfflineAudioContext doesn't render the audio to the device hardware; instead, it generates it, as fast as it can, and outputs the result to an AudioBuffer. */
11240 interface OfflineAudioContext extends BaseAudioContext {
11241     readonly length: number;
11242     oncomplete: ((this: OfflineAudioContext, ev: OfflineAudioCompletionEvent) => any) | null;
11243     resume(): Promise<void>;
11244     startRendering(): Promise<AudioBuffer>;
11245     suspend(suspendTime: number): Promise<void>;
11246     addEventListener<K extends keyof OfflineAudioContextEventMap>(type: K, listener: (this: OfflineAudioContext, ev: OfflineAudioContextEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11247     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11248     removeEventListener<K extends keyof OfflineAudioContextEventMap>(type: K, listener: (this: OfflineAudioContext, ev: OfflineAudioContextEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11249     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11250 }
11251
11252 declare var OfflineAudioContext: {
11253     prototype: OfflineAudioContext;
11254     new(contextOptions: OfflineAudioContextOptions): OfflineAudioContext;
11255     new(numberOfChannels: number, length: number, sampleRate: number): OfflineAudioContext;
11256 };
11257
11258 interface OffscreenCanvas extends EventTarget {
11259     /**
11260      * These attributes return the dimensions of the OffscreenCanvas object's bitmap.
11261      *
11262      * They can be set, to replace the bitmap with a new, transparent black bitmap of the specified dimensions (effectively resizing it).
11263      */
11264     height: number;
11265     /**
11266      * These attributes return the dimensions of the OffscreenCanvas object's bitmap.
11267      *
11268      * They can be set, to replace the bitmap with a new, transparent black bitmap of the specified dimensions (effectively resizing it).
11269      */
11270     width: number;
11271     /**
11272      * Returns a promise that will fulfill with a new Blob object representing a file containing the image in the OffscreenCanvas object.
11273      *
11274      * The argument, if provided, is a dictionary that controls the encoding options of the image file to be created. The type field specifies the file format and has a default value of "image/png"; that type is also used if the requested type isn't supported. If the image format supports variable quality (such as "image/jpeg"), then the quality field is a number in the range 0.0 to 1.0 inclusive indicating the desired quality level for the resulting image.
11275      */
11276     convertToBlob(options?: ImageEncodeOptions): Promise<Blob>;
11277     /**
11278      * Returns an object that exposes an API for drawing on the OffscreenCanvas object. contextId specifies the desired API: "2d", "bitmaprenderer", "webgl", or "webgl2". options is handled by that API.
11279      *
11280      * This specification defines the "2d" context below, which is similar but distinct from the "2d" context that is created from a canvas element. The WebGL specifications define the "webgl" and "webgl2" contexts. [WEBGL]
11281      *
11282      * Returns null if the canvas has already been initialized with another context type (e.g., trying to get a "2d" context after getting a "webgl" context).
11283      */
11284     getContext(contextId: "2d", options?: CanvasRenderingContext2DSettings): OffscreenCanvasRenderingContext2D | null;
11285     getContext(contextId: "bitmaprenderer", options?: ImageBitmapRenderingContextSettings): ImageBitmapRenderingContext | null;
11286     getContext(contextId: "webgl", options?: WebGLContextAttributes): WebGLRenderingContext | null;
11287     getContext(contextId: "webgl2", options?: WebGLContextAttributes): WebGL2RenderingContext | null;
11288     getContext(contextId: OffscreenRenderingContextId, options?: any): OffscreenRenderingContext | null;
11289     /**
11290      * Returns a newly created ImageBitmap object with the image in the OffscreenCanvas object. The image in the OffscreenCanvas object is replaced with a new blank image.
11291      */
11292     transferToImageBitmap(): ImageBitmap;
11293 }
11294
11295 declare var OffscreenCanvas: {
11296     prototype: OffscreenCanvas;
11297     new(width: number, height: number): OffscreenCanvas;
11298 };
11299
11300 interface OffscreenCanvasRenderingContext2D extends CanvasCompositing, CanvasDrawImage, CanvasDrawPath, CanvasFillStrokeStyles, CanvasFilters, CanvasImageData, CanvasImageSmoothing, CanvasPath, CanvasPathDrawingStyles, CanvasRect, CanvasShadowStyles, CanvasState, CanvasText, CanvasTextDrawingStyles, CanvasTransform {
11301     readonly canvas: OffscreenCanvas;
11302     commit(): void;
11303 }
11304
11305 declare var OffscreenCanvasRenderingContext2D: {
11306     prototype: OffscreenCanvasRenderingContext2D;
11307     new(): OffscreenCanvasRenderingContext2D;
11308 };
11309
11310 /** The OscillatorNode interface represents a periodic waveform, such as a sine wave. It is an AudioScheduledSourceNode audio-processing module that causes a specified frequency of a given wave to be created—in effect, a constant tone. */
11311 interface OscillatorNode extends AudioScheduledSourceNode {
11312     readonly detune: AudioParam;
11313     readonly frequency: AudioParam;
11314     type: OscillatorType;
11315     setPeriodicWave(periodicWave: PeriodicWave): void;
11316     addEventListener<K extends keyof AudioScheduledSourceNodeEventMap>(type: K, listener: (this: OscillatorNode, ev: AudioScheduledSourceNodeEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11317     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11318     removeEventListener<K extends keyof AudioScheduledSourceNodeEventMap>(type: K, listener: (this: OscillatorNode, ev: AudioScheduledSourceNodeEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11319     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11320 }
11321
11322 declare var OscillatorNode: {
11323     prototype: OscillatorNode;
11324     new(context: BaseAudioContext, options?: OscillatorOptions): OscillatorNode;
11325 };
11326
11327 interface OverconstrainedError extends Error {
11328     constraint: string;
11329 }
11330
11331 declare var OverconstrainedError: {
11332     prototype: OverconstrainedError;
11333     new(): OverconstrainedError;
11334 };
11335
11336 interface OverflowEvent extends UIEvent {
11337     readonly horizontalOverflow: boolean;
11338     readonly orient: number;
11339     readonly verticalOverflow: boolean;
11340     readonly BOTH: number;
11341     readonly HORIZONTAL: number;
11342     readonly VERTICAL: number;
11343 }
11344
11345 declare var OverflowEvent: {
11346     prototype: OverflowEvent;
11347     new(): OverflowEvent;
11348     readonly BOTH: number;
11349     readonly HORIZONTAL: number;
11350     readonly VERTICAL: number;
11351 };
11352
11353 /** The PageTransitionEvent is fired when a document is being loaded or unloaded. */
11354 interface PageTransitionEvent extends Event {
11355     /**
11356      * For the pageshow event, returns false if the page is newly being loaded (and the load event will fire). Otherwise, returns true.
11357      *
11358      * For the pagehide event, returns false if the page is going away for the last time. Otherwise, returns true, meaning that (if nothing conspires to make the page unsalvageable) the page might be reused if the user navigates back to this page.
11359      *
11360      * Things that can cause the page to be unsalvageable include:
11361      *
11362      * Listening for beforeunload events
11363      * Listening for unload events
11364      * Having iframes that are not salvageable
11365      * Active WebSocket objects
11366      * Aborting a Document
11367      */
11368     readonly persisted: boolean;
11369 }
11370
11371 declare var PageTransitionEvent: {
11372     prototype: PageTransitionEvent;
11373     new(type: string, eventInitDict?: PageTransitionEventInit): PageTransitionEvent;
11374 };
11375
11376 /** A PannerNode always has exactly one input and one output: the input can be mono or stereo but the output is always stereo (2 channels); you can't have panning effects without at least two audio channels! */
11377 interface PannerNode extends AudioNode {
11378     coneInnerAngle: number;
11379     coneOuterAngle: number;
11380     coneOuterGain: number;
11381     distanceModel: DistanceModelType;
11382     maxDistance: number;
11383     readonly orientationX: AudioParam;
11384     readonly orientationY: AudioParam;
11385     readonly orientationZ: AudioParam;
11386     panningModel: PanningModelType;
11387     readonly positionX: AudioParam;
11388     readonly positionY: AudioParam;
11389     readonly positionZ: AudioParam;
11390     refDistance: number;
11391     rolloffFactor: number;
11392     /** @deprecated */
11393     setOrientation(x: number, y: number, z: number): void;
11394     /** @deprecated */
11395     setPosition(x: number, y: number, z: number): void;
11396 }
11397
11398 declare var PannerNode: {
11399     prototype: PannerNode;
11400     new(context: BaseAudioContext, options?: PannerOptions): PannerNode;
11401 };
11402
11403 interface ParentNode {
11404     readonly childElementCount: number;
11405     /**
11406      * Returns the child elements.
11407      */
11408     readonly children: HTMLCollection;
11409     /**
11410      * Returns the first child that is an element, and null otherwise.
11411      */
11412     readonly firstElementChild: Element | null;
11413     /**
11414      * Returns the last child that is an element, and null otherwise.
11415      */
11416     readonly lastElementChild: Element | null;
11417     /**
11418      * Inserts nodes after the last child of node, while replacing strings in nodes with equivalent Text nodes.
11419      *
11420      * Throws a "HierarchyRequestError" DOMException if the constraints of the node tree are violated.
11421      */
11422     append(...nodes: (Node | string)[]): void;
11423     /**
11424      * Inserts nodes before the first child of node, while replacing strings in nodes with equivalent Text nodes.
11425      *
11426      * Throws a "HierarchyRequestError" DOMException if the constraints of the node tree are violated.
11427      */
11428     prepend(...nodes: (Node | string)[]): void;
11429     /**
11430      * Returns the first element that is a descendant of node that matches selectors.
11431      */
11432     querySelector<K extends keyof HTMLElementTagNameMap>(selectors: K): HTMLElementTagNameMap[K] | null;
11433     querySelector<K extends keyof SVGElementTagNameMap>(selectors: K): SVGElementTagNameMap[K] | null;
11434     querySelector<E extends Element = Element>(selectors: string): E | null;
11435     /**
11436      * Returns all element descendants of node that match selectors.
11437      */
11438     querySelectorAll<K extends keyof HTMLElementTagNameMap>(selectors: K): NodeListOf<HTMLElementTagNameMap[K]>;
11439     querySelectorAll<K extends keyof SVGElementTagNameMap>(selectors: K): NodeListOf<SVGElementTagNameMap[K]>;
11440     querySelectorAll<E extends Element = Element>(selectors: string): NodeListOf<E>;
11441 }
11442
11443 /** This Canvas 2D API interface is used to declare a path that can then be used on a CanvasRenderingContext2D object. The path methods of the CanvasRenderingContext2D interface are also present on this interface, which gives you the convenience of being able to retain and replay your path whenever desired. */
11444 interface Path2D extends CanvasPath {
11445     /**
11446      * Adds to the path the path given by the argument.
11447      */
11448     addPath(path: Path2D, transform?: DOMMatrix2DInit): void;
11449 }
11450
11451 declare var Path2D: {
11452     prototype: Path2D;
11453     new(path?: Path2D | string): Path2D;
11454 };
11455
11456 /** This Payment Request API interface is used to store shipping or payment address information. */
11457 interface PaymentAddress {
11458     readonly addressLine: string[];
11459     readonly city: string;
11460     readonly country: string;
11461     readonly dependentLocality: string;
11462     readonly languageCode: string;
11463     readonly organization: string;
11464     readonly phone: string;
11465     readonly postalCode: string;
11466     readonly recipient: string;
11467     readonly region: string;
11468     readonly sortingCode: string;
11469     toJSON(): any;
11470 }
11471
11472 declare var PaymentAddress: {
11473     prototype: PaymentAddress;
11474     new(): PaymentAddress;
11475 };
11476
11477 interface PaymentRequestEventMap {
11478     "shippingaddresschange": Event;
11479     "shippingoptionchange": Event;
11480 }
11481
11482 /** This Payment Request API interface is the primary access point into the API, and lets web content and apps accept payments from the end user. */
11483 interface PaymentRequest extends EventTarget {
11484     readonly id: string;
11485     onshippingaddresschange: ((this: PaymentRequest, ev: Event) => any) | null;
11486     onshippingoptionchange: ((this: PaymentRequest, ev: Event) => any) | null;
11487     readonly shippingAddress: PaymentAddress | null;
11488     readonly shippingOption: string | null;
11489     readonly shippingType: PaymentShippingType | null;
11490     abort(): Promise<void>;
11491     canMakePayment(): Promise<boolean>;
11492     show(): Promise<PaymentResponse>;
11493     addEventListener<K extends keyof PaymentRequestEventMap>(type: K, listener: (this: PaymentRequest, ev: PaymentRequestEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11494     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11495     removeEventListener<K extends keyof PaymentRequestEventMap>(type: K, listener: (this: PaymentRequest, ev: PaymentRequestEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11496     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11497 }
11498
11499 declare var PaymentRequest: {
11500     prototype: PaymentRequest;
11501     new(methodData: PaymentMethodData[], details: PaymentDetailsInit, options?: PaymentOptions): PaymentRequest;
11502 };
11503
11504 /** This Payment Request API interface enables a web page to update the details of a PaymentRequest in response to a user action. */
11505 interface PaymentRequestUpdateEvent extends Event {
11506     updateWith(detailsPromise: PaymentDetailsUpdate | Promise<PaymentDetailsUpdate>): void;
11507 }
11508
11509 declare var PaymentRequestUpdateEvent: {
11510     prototype: PaymentRequestUpdateEvent;
11511     new(type: string, eventInitDict?: PaymentRequestUpdateEventInit): PaymentRequestUpdateEvent;
11512 };
11513
11514 /** This Payment Request API interface is returned after a user selects a payment method and approves a payment request. */
11515 interface PaymentResponse {
11516     readonly details: any;
11517     readonly methodName: string;
11518     readonly payerEmail: string | null;
11519     readonly payerName: string | null;
11520     readonly payerPhone: string | null;
11521     readonly requestId: string;
11522     readonly shippingAddress: PaymentAddress | null;
11523     readonly shippingOption: string | null;
11524     complete(result?: PaymentComplete): Promise<void>;
11525     toJSON(): any;
11526 }
11527
11528 declare var PaymentResponse: {
11529     prototype: PaymentResponse;
11530     new(): PaymentResponse;
11531 };
11532
11533 interface PerfWidgetExternal {
11534     readonly activeNetworkRequestCount: number;
11535     readonly averageFrameTime: number;
11536     readonly averagePaintTime: number;
11537     readonly extraInformationEnabled: boolean;
11538     readonly independentRenderingEnabled: boolean;
11539     readonly irDisablingContentString: string;
11540     readonly irStatusAvailable: boolean;
11541     readonly maxCpuSpeed: number;
11542     readonly paintRequestsPerSecond: number;
11543     readonly performanceCounter: number;
11544     readonly performanceCounterFrequency: number;
11545     addEventListener(eventType: string, callback: Function): void;
11546     getMemoryUsage(): number;
11547     getProcessCpuUsage(): number;
11548     getRecentCpuUsage(last: number | null): any;
11549     getRecentFrames(last: number | null): any;
11550     getRecentMemoryUsage(last: number | null): any;
11551     getRecentPaintRequests(last: number | null): any;
11552     removeEventListener(eventType: string, callback: Function): void;
11553     repositionWindow(x: number, y: number): void;
11554     resizeWindow(width: number, height: number): void;
11555 }
11556
11557 declare var PerfWidgetExternal: {
11558     prototype: PerfWidgetExternal;
11559     new(): PerfWidgetExternal;
11560 };
11561
11562 interface PerformanceEventMap {
11563     "resourcetimingbufferfull": Event;
11564 }
11565
11566 /** Provides access to performance-related information for the current page. It's part of the High Resolution Time API, but is enhanced by the Performance Timeline API, the Navigation Timing API, the User Timing API, and the Resource Timing API. */
11567 interface Performance extends EventTarget {
11568     /** @deprecated */
11569     readonly navigation: PerformanceNavigation;
11570     onresourcetimingbufferfull: ((this: Performance, ev: Event) => any) | null;
11571     readonly timeOrigin: number;
11572     /** @deprecated */
11573     readonly timing: PerformanceTiming;
11574     clearMarks(markName?: string): void;
11575     clearMeasures(measureName?: string): void;
11576     clearResourceTimings(): void;
11577     getEntries(): PerformanceEntryList;
11578     getEntriesByName(name: string, type?: string): PerformanceEntryList;
11579     getEntriesByType(type: string): PerformanceEntryList;
11580     mark(markName: string): void;
11581     measure(measureName: string, startMark?: string, endMark?: string): void;
11582     now(): number;
11583     setResourceTimingBufferSize(maxSize: number): void;
11584     toJSON(): any;
11585     addEventListener<K extends keyof PerformanceEventMap>(type: K, listener: (this: Performance, ev: PerformanceEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11586     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11587     removeEventListener<K extends keyof PerformanceEventMap>(type: K, listener: (this: Performance, ev: PerformanceEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11588     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11589 }
11590
11591 declare var Performance: {
11592     prototype: Performance;
11593     new(): Performance;
11594 };
11595
11596 /** Encapsulates a single performance metric that is part of the performance timeline. A performance entry can be directly created by making a performance mark or measure (for example by calling the mark() method) at an explicit point in an application. Performance entries are also created in indirect ways such as loading a resource (such as an image). */
11597 interface PerformanceEntry {
11598     readonly duration: number;
11599     readonly entryType: string;
11600     readonly name: string;
11601     readonly startTime: number;
11602     toJSON(): any;
11603 }
11604
11605 declare var PerformanceEntry: {
11606     prototype: PerformanceEntry;
11607     new(): PerformanceEntry;
11608 };
11609
11610 /** PerformanceMark is an abstract interface for PerformanceEntry objects with an entryType of "mark". Entries of this type are created by calling performance.mark() to add a named DOMHighResTimeStamp (the mark) to the browser's performance timeline. */
11611 interface PerformanceMark extends PerformanceEntry {
11612 }
11613
11614 declare var PerformanceMark: {
11615     prototype: PerformanceMark;
11616     new(): PerformanceMark;
11617 };
11618
11619 /** PerformanceMeasure is an abstract interface for PerformanceEntry objects with an entryType of "measure". Entries of this type are created by calling performance.measure() to add a named DOMHighResTimeStamp (the measure) between two marks to the browser's performance timeline. */
11620 interface PerformanceMeasure extends PerformanceEntry {
11621 }
11622
11623 declare var PerformanceMeasure: {
11624     prototype: PerformanceMeasure;
11625     new(): PerformanceMeasure;
11626 };
11627
11628 /** The legacy PerformanceNavigation interface represents information about how the navigation to the current document was done.
11629  * @deprecated This interface is deprecated in the Navigation Timing Level 2 specification. Please use the PerformanceNavigationTiming interface instead.
11630  */
11631 interface PerformanceNavigation {
11632     readonly redirectCount: number;
11633     readonly type: number;
11634     toJSON(): any;
11635     readonly TYPE_BACK_FORWARD: number;
11636     readonly TYPE_NAVIGATE: number;
11637     readonly TYPE_RELOAD: number;
11638     readonly TYPE_RESERVED: number;
11639 }
11640
11641 declare var PerformanceNavigation: {
11642     prototype: PerformanceNavigation;
11643     new(): PerformanceNavigation;
11644     readonly TYPE_BACK_FORWARD: number;
11645     readonly TYPE_NAVIGATE: number;
11646     readonly TYPE_RELOAD: number;
11647     readonly TYPE_RESERVED: number;
11648 };
11649
11650 /** Provides methods and properties to store and retrieve metrics regarding the browser's document navigation events. For example, this interface can be used to determine how much time it takes to load or unload a document. */
11651 interface PerformanceNavigationTiming extends PerformanceResourceTiming {
11652     readonly domComplete: number;
11653     readonly domContentLoadedEventEnd: number;
11654     readonly domContentLoadedEventStart: number;
11655     readonly domInteractive: number;
11656     readonly loadEventEnd: number;
11657     readonly loadEventStart: number;
11658     readonly redirectCount: number;
11659     readonly type: NavigationType;
11660     readonly unloadEventEnd: number;
11661     readonly unloadEventStart: number;
11662     toJSON(): any;
11663 }
11664
11665 declare var PerformanceNavigationTiming: {
11666     prototype: PerformanceNavigationTiming;
11667     new(): PerformanceNavigationTiming;
11668 };
11669
11670 interface PerformanceObserver {
11671     disconnect(): void;
11672     observe(options?: PerformanceObserverInit): void;
11673     takeRecords(): PerformanceEntryList;
11674 }
11675
11676 declare var PerformanceObserver: {
11677     prototype: PerformanceObserver;
11678     new(callback: PerformanceObserverCallback): PerformanceObserver;
11679     readonly supportedEntryTypes: ReadonlyArray<string>;
11680 };
11681
11682 interface PerformanceObserverEntryList {
11683     getEntries(): PerformanceEntryList;
11684     getEntriesByName(name: string, type?: string): PerformanceEntryList;
11685     getEntriesByType(type: string): PerformanceEntryList;
11686 }
11687
11688 declare var PerformanceObserverEntryList: {
11689     prototype: PerformanceObserverEntryList;
11690     new(): PerformanceObserverEntryList;
11691 };
11692
11693 /** Enables retrieval and analysis of detailed network timing data regarding the loading of an application's resources. An application can use the timing metrics to determine, for example, the length of time it takes to fetch a specific resource, such as an XMLHttpRequest, <SVG>, image, or script. */
11694 interface PerformanceResourceTiming extends PerformanceEntry {
11695     readonly connectEnd: number;
11696     readonly connectStart: number;
11697     readonly decodedBodySize: number;
11698     readonly domainLookupEnd: number;
11699     readonly domainLookupStart: number;
11700     readonly encodedBodySize: number;
11701     readonly fetchStart: number;
11702     readonly initiatorType: string;
11703     readonly nextHopProtocol: string;
11704     readonly redirectEnd: number;
11705     readonly redirectStart: number;
11706     readonly requestStart: number;
11707     readonly responseEnd: number;
11708     readonly responseStart: number;
11709     readonly secureConnectionStart: number;
11710     readonly transferSize: number;
11711     readonly workerStart: number;
11712     toJSON(): any;
11713 }
11714
11715 declare var PerformanceResourceTiming: {
11716     prototype: PerformanceResourceTiming;
11717     new(): PerformanceResourceTiming;
11718 };
11719
11720 /** A legacy interface kept for backwards compatibility and contains properties that offer performance timing information for various events which occur during the loading and use of the current page. You get a PerformanceTiming object describing your page using the window.performance.timing property.
11721  * @deprecated This interface is deprecated in the Navigation Timing Level 2 specification. Please use the PerformanceNavigationTiming interface instead.
11722  */
11723 interface PerformanceTiming {
11724     readonly connectEnd: number;
11725     readonly connectStart: number;
11726     readonly domComplete: number;
11727     readonly domContentLoadedEventEnd: number;
11728     readonly domContentLoadedEventStart: number;
11729     readonly domInteractive: number;
11730     readonly domLoading: number;
11731     readonly domainLookupEnd: number;
11732     readonly domainLookupStart: number;
11733     readonly fetchStart: number;
11734     readonly loadEventEnd: number;
11735     readonly loadEventStart: number;
11736     readonly navigationStart: number;
11737     readonly redirectEnd: number;
11738     readonly redirectStart: number;
11739     readonly requestStart: number;
11740     readonly responseEnd: number;
11741     readonly responseStart: number;
11742     readonly secureConnectionStart: number;
11743     readonly unloadEventEnd: number;
11744     readonly unloadEventStart: number;
11745     toJSON(): any;
11746 }
11747
11748 declare var PerformanceTiming: {
11749     prototype: PerformanceTiming;
11750     new(): PerformanceTiming;
11751 };
11752
11753 /** PeriodicWave has no inputs or outputs; it is used to define custom oscillators when calling OscillatorNode.setPeriodicWave(). The PeriodicWave itself is created/returned by AudioContext.createPeriodicWave(). */
11754 interface PeriodicWave {
11755 }
11756
11757 declare var PeriodicWave: {
11758     prototype: PeriodicWave;
11759     new(context: BaseAudioContext, options?: PeriodicWaveOptions): PeriodicWave;
11760 };
11761
11762 interface PermissionRequest extends DeferredPermissionRequest {
11763     readonly state: MSWebViewPermissionState;
11764     defer(): void;
11765 }
11766
11767 declare var PermissionRequest: {
11768     prototype: PermissionRequest;
11769     new(): PermissionRequest;
11770 };
11771
11772 interface PermissionRequestedEvent extends Event {
11773     readonly permissionRequest: PermissionRequest;
11774 }
11775
11776 declare var PermissionRequestedEvent: {
11777     prototype: PermissionRequestedEvent;
11778     new(): PermissionRequestedEvent;
11779 };
11780
11781 interface PermissionStatusEventMap {
11782     "change": Event;
11783 }
11784
11785 interface PermissionStatus extends EventTarget {
11786     onchange: ((this: PermissionStatus, ev: Event) => any) | null;
11787     readonly state: PermissionState;
11788     addEventListener<K extends keyof PermissionStatusEventMap>(type: K, listener: (this: PermissionStatus, ev: PermissionStatusEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11789     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11790     removeEventListener<K extends keyof PermissionStatusEventMap>(type: K, listener: (this: PermissionStatus, ev: PermissionStatusEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11791     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11792 }
11793
11794 declare var PermissionStatus: {
11795     prototype: PermissionStatus;
11796     new(): PermissionStatus;
11797 };
11798
11799 interface Permissions {
11800     query(permissionDesc: PermissionDescriptor | DevicePermissionDescriptor | MidiPermissionDescriptor | PushPermissionDescriptor): Promise<PermissionStatus>;
11801 }
11802
11803 declare var Permissions: {
11804     prototype: Permissions;
11805     new(): Permissions;
11806 };
11807
11808 /** Provides information about a browser plugin. */
11809 interface Plugin {
11810     /**
11811      * Returns the plugin's description.
11812      */
11813     readonly description: string;
11814     /**
11815      * Returns the plugin library's filename, if applicable on the current platform.
11816      */
11817     readonly filename: string;
11818     /**
11819      * Returns the number of MIME types, represented by MimeType objects, supported by the plugin.
11820      */
11821     readonly length: number;
11822     /**
11823      * Returns the plugin's name.
11824      */
11825     readonly name: string;
11826     /**
11827      * Returns the specified MimeType object.
11828      */
11829     item(index: number): MimeType | null;
11830     namedItem(name: string): MimeType | null;
11831     [index: number]: MimeType;
11832 }
11833
11834 declare var Plugin: {
11835     prototype: Plugin;
11836     new(): Plugin;
11837 };
11838
11839 /** Used to store a list of Plugin objects describing the available plugins; it's returned by the window.navigator.plugins property. The PluginArray is not a JavaScript array, but has the length property and supports accessing individual items using bracket notation (plugins[2]), as well as via item(index) and namedItem("name") methods. */
11840 interface PluginArray {
11841     readonly length: number;
11842     item(index: number): Plugin | null;
11843     namedItem(name: string): Plugin | null;
11844     refresh(reload?: boolean): void;
11845     [index: number]: Plugin;
11846 }
11847
11848 declare var PluginArray: {
11849     prototype: PluginArray;
11850     new(): PluginArray;
11851 };
11852
11853 /** The state of a DOM event produced by a pointer such as the geometry of the contact point, the device type that generated the event, the amount of pressure that was applied on the contact surface, etc. */
11854 interface PointerEvent extends MouseEvent {
11855     readonly height: number;
11856     readonly isPrimary: boolean;
11857     readonly pointerId: number;
11858     readonly pointerType: string;
11859     readonly pressure: number;
11860     readonly tangentialPressure: number;
11861     readonly tiltX: number;
11862     readonly tiltY: number;
11863     readonly twist: number;
11864     readonly width: number;
11865     getCoalescedEvents(): PointerEvent[];
11866     getPredictedEvents(): PointerEvent[];
11867 }
11868
11869 declare var PointerEvent: {
11870     prototype: PointerEvent;
11871     new(type: string, eventInitDict?: PointerEventInit): PointerEvent;
11872 };
11873
11874 /** PopStateEvent is an event handler for the popstate event on the window. */
11875 interface PopStateEvent extends Event {
11876     /**
11877      * Returns a copy of the information that was provided to pushState() or replaceState().
11878      */
11879     readonly state: any;
11880 }
11881
11882 declare var PopStateEvent: {
11883     prototype: PopStateEvent;
11884     new(type: string, eventInitDict?: PopStateEventInit): PopStateEvent;
11885 };
11886
11887 /** A processing instruction embeds application-specific instructions in XML which can be ignored by other applications that don't recognize them. */
11888 interface ProcessingInstruction extends CharacterData, LinkStyle {
11889     readonly ownerDocument: Document;
11890     readonly target: string;
11891 }
11892
11893 declare var ProcessingInstruction: {
11894     prototype: ProcessingInstruction;
11895     new(): ProcessingInstruction;
11896 };
11897
11898 /** Events measuring progress of an underlying process, like an HTTP request (for an XMLHttpRequest, or the loading of the underlying resource of an <img>, <audio>, <video>, <style> or <link>). */
11899 interface ProgressEvent<T extends EventTarget = EventTarget> extends Event {
11900     readonly lengthComputable: boolean;
11901     readonly loaded: number;
11902     readonly target: T | null;
11903     readonly total: number;
11904 }
11905
11906 declare var ProgressEvent: {
11907     prototype: ProgressEvent;
11908     new(type: string, eventInitDict?: ProgressEventInit): ProgressEvent;
11909 };
11910
11911 interface PromiseRejectionEvent extends Event {
11912     readonly promise: Promise<any>;
11913     readonly reason: any;
11914 }
11915
11916 declare var PromiseRejectionEvent: {
11917     prototype: PromiseRejectionEvent;
11918     new(type: string, eventInitDict: PromiseRejectionEventInit): PromiseRejectionEvent;
11919 };
11920
11921 interface PublicKeyCredential extends Credential {
11922     readonly rawId: ArrayBuffer;
11923     readonly response: AuthenticatorResponse;
11924     getClientExtensionResults(): AuthenticationExtensionsClientOutputs;
11925 }
11926
11927 declare var PublicKeyCredential: {
11928     prototype: PublicKeyCredential;
11929     new(): PublicKeyCredential;
11930     isUserVerifyingPlatformAuthenticatorAvailable(): Promise<boolean>;
11931 };
11932
11933 /** This Push API interface provides a way to receive notifications from third-party servers as well as request URLs for push notifications. */
11934 interface PushManager {
11935     getSubscription(): Promise<PushSubscription | null>;
11936     permissionState(options?: PushSubscriptionOptionsInit): Promise<PushPermissionState>;
11937     subscribe(options?: PushSubscriptionOptionsInit): Promise<PushSubscription>;
11938 }
11939
11940 declare var PushManager: {
11941     prototype: PushManager;
11942     new(): PushManager;
11943     readonly supportedContentEncodings: ReadonlyArray<string>;
11944 };
11945
11946 /** This Push API interface provides a subcription's URL endpoint and allows unsubscription from a push service. */
11947 interface PushSubscription {
11948     readonly endpoint: string;
11949     readonly expirationTime: number | null;
11950     readonly options: PushSubscriptionOptions;
11951     getKey(name: PushEncryptionKeyName): ArrayBuffer | null;
11952     toJSON(): PushSubscriptionJSON;
11953     unsubscribe(): Promise<boolean>;
11954 }
11955
11956 declare var PushSubscription: {
11957     prototype: PushSubscription;
11958     new(): PushSubscription;
11959 };
11960
11961 interface PushSubscriptionOptions {
11962     readonly applicationServerKey: ArrayBuffer | null;
11963     readonly userVisibleOnly: boolean;
11964 }
11965
11966 declare var PushSubscriptionOptions: {
11967     prototype: PushSubscriptionOptions;
11968     new(): PushSubscriptionOptions;
11969 };
11970
11971 interface RTCCertificate {
11972     readonly expires: number;
11973     getFingerprints(): RTCDtlsFingerprint[];
11974 }
11975
11976 declare var RTCCertificate: {
11977     prototype: RTCCertificate;
11978     new(): RTCCertificate;
11979     getSupportedAlgorithms(): AlgorithmIdentifier[];
11980 };
11981
11982 interface RTCDTMFSenderEventMap {
11983     "tonechange": RTCDTMFToneChangeEvent;
11984 }
11985
11986 interface RTCDTMFSender extends EventTarget {
11987     readonly canInsertDTMF: boolean;
11988     ontonechange: ((this: RTCDTMFSender, ev: RTCDTMFToneChangeEvent) => any) | null;
11989     readonly toneBuffer: string;
11990     insertDTMF(tones: string, duration?: number, interToneGap?: number): void;
11991     addEventListener<K extends keyof RTCDTMFSenderEventMap>(type: K, listener: (this: RTCDTMFSender, ev: RTCDTMFSenderEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11992     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11993     removeEventListener<K extends keyof RTCDTMFSenderEventMap>(type: K, listener: (this: RTCDTMFSender, ev: RTCDTMFSenderEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11994     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11995 }
11996
11997 declare var RTCDTMFSender: {
11998     prototype: RTCDTMFSender;
11999     new(): RTCDTMFSender;
12000 };
12001
12002 /** Events sent to indicate that DTMF tones have started or finished playing. This interface is used by the tonechange event. */
12003 interface RTCDTMFToneChangeEvent extends Event {
12004     readonly tone: string;
12005 }
12006
12007 declare var RTCDTMFToneChangeEvent: {
12008     prototype: RTCDTMFToneChangeEvent;
12009     new(type: string, eventInitDict: RTCDTMFToneChangeEventInit): RTCDTMFToneChangeEvent;
12010 };
12011
12012 interface RTCDataChannelEventMap {
12013     "bufferedamountlow": Event;
12014     "close": Event;
12015     "error": RTCErrorEvent;
12016     "message": MessageEvent;
12017     "open": Event;
12018 }
12019
12020 interface RTCDataChannel extends EventTarget {
12021     binaryType: string;
12022     readonly bufferedAmount: number;
12023     bufferedAmountLowThreshold: number;
12024     readonly id: number | null;
12025     readonly label: string;
12026     readonly maxPacketLifeTime: number | null;
12027     readonly maxRetransmits: number | null;
12028     readonly negotiated: boolean;
12029     onbufferedamountlow: ((this: RTCDataChannel, ev: Event) => any) | null;
12030     onclose: ((this: RTCDataChannel, ev: Event) => any) | null;
12031     onerror: ((this: RTCDataChannel, ev: RTCErrorEvent) => any) | null;
12032     onmessage: ((this: RTCDataChannel, ev: MessageEvent) => any) | null;
12033     onopen: ((this: RTCDataChannel, ev: Event) => any) | null;
12034     readonly ordered: boolean;
12035     readonly priority: RTCPriorityType;
12036     readonly protocol: string;
12037     readonly readyState: RTCDataChannelState;
12038     close(): void;
12039     send(data: string): void;
12040     send(data: Blob): void;
12041     send(data: ArrayBuffer): void;
12042     send(data: ArrayBufferView): void;
12043     addEventListener<K extends keyof RTCDataChannelEventMap>(type: K, listener: (this: RTCDataChannel, ev: RTCDataChannelEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12044     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12045     removeEventListener<K extends keyof RTCDataChannelEventMap>(type: K, listener: (this: RTCDataChannel, ev: RTCDataChannelEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12046     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12047 }
12048
12049 declare var RTCDataChannel: {
12050     prototype: RTCDataChannel;
12051     new(): RTCDataChannel;
12052 };
12053
12054 interface RTCDataChannelEvent extends Event {
12055     readonly channel: RTCDataChannel;
12056 }
12057
12058 declare var RTCDataChannelEvent: {
12059     prototype: RTCDataChannelEvent;
12060     new(type: string, eventInitDict: RTCDataChannelEventInit): RTCDataChannelEvent;
12061 };
12062
12063 interface RTCDtlsTransportEventMap {
12064     "error": RTCErrorEvent;
12065     "statechange": Event;
12066 }
12067
12068 interface RTCDtlsTransport extends EventTarget {
12069     readonly iceTransport: RTCIceTransport;
12070     onerror: ((this: RTCDtlsTransport, ev: RTCErrorEvent) => any) | null;
12071     onstatechange: ((this: RTCDtlsTransport, ev: Event) => any) | null;
12072     readonly state: RTCDtlsTransportState;
12073     getRemoteCertificates(): ArrayBuffer[];
12074     addEventListener<K extends keyof RTCDtlsTransportEventMap>(type: K, listener: (this: RTCDtlsTransport, ev: RTCDtlsTransportEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12075     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12076     removeEventListener<K extends keyof RTCDtlsTransportEventMap>(type: K, listener: (this: RTCDtlsTransport, ev: RTCDtlsTransportEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12077     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12078 }
12079
12080 declare var RTCDtlsTransport: {
12081     prototype: RTCDtlsTransport;
12082     new(): RTCDtlsTransport;
12083 };
12084
12085 interface RTCDtlsTransportStateChangedEvent extends Event {
12086     readonly state: RTCDtlsTransportState;
12087 }
12088
12089 declare var RTCDtlsTransportStateChangedEvent: {
12090     prototype: RTCDtlsTransportStateChangedEvent;
12091     new(): RTCDtlsTransportStateChangedEvent;
12092 };
12093
12094 interface RTCDtmfSenderEventMap {
12095     "tonechange": RTCDTMFToneChangeEvent;
12096 }
12097
12098 interface RTCDtmfSender extends EventTarget {
12099     readonly canInsertDTMF: boolean;
12100     readonly duration: number;
12101     readonly interToneGap: number;
12102     ontonechange: ((this: RTCDtmfSender, ev: RTCDTMFToneChangeEvent) => any) | null;
12103     readonly sender: RTCRtpSender;
12104     readonly toneBuffer: string;
12105     insertDTMF(tones: string, duration?: number, interToneGap?: number): void;
12106     addEventListener<K extends keyof RTCDtmfSenderEventMap>(type: K, listener: (this: RTCDtmfSender, ev: RTCDtmfSenderEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12107     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12108     removeEventListener<K extends keyof RTCDtmfSenderEventMap>(type: K, listener: (this: RTCDtmfSender, ev: RTCDtmfSenderEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12109     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12110 }
12111
12112 declare var RTCDtmfSender: {
12113     prototype: RTCDtmfSender;
12114     new(sender: RTCRtpSender): RTCDtmfSender;
12115 };
12116
12117 interface RTCError extends DOMException {
12118     readonly errorDetail: RTCErrorDetailType;
12119     readonly httpRequestStatusCode: number | null;
12120     readonly receivedAlert: number | null;
12121     readonly sctpCauseCode: number | null;
12122     readonly sdpLineNumber: number | null;
12123     readonly sentAlert: number | null;
12124 }
12125
12126 declare var RTCError: {
12127     prototype: RTCError;
12128     new(init: RTCErrorInit, message?: string): RTCError;
12129 };
12130
12131 interface RTCErrorEvent extends Event {
12132     readonly error: RTCError;
12133 }
12134
12135 declare var RTCErrorEvent: {
12136     prototype: RTCErrorEvent;
12137     new(type: string, eventInitDict: RTCErrorEventInit): RTCErrorEvent;
12138 };
12139
12140 /** The RTCIceCandidate interface—part of the WebRTC API—represents a candidate Internet Connectivity Establishment (ICE) configuration which may be used to establish an RTCPeerConnection. */
12141 interface RTCIceCandidate {
12142     readonly candidate: string;
12143     readonly component: RTCIceComponent | null;
12144     readonly foundation: string | null;
12145     readonly port: number | null;
12146     readonly priority: number | null;
12147     readonly protocol: RTCIceProtocol | null;
12148     readonly relatedAddress: string | null;
12149     readonly relatedPort: number | null;
12150     readonly sdpMLineIndex: number | null;
12151     readonly sdpMid: string | null;
12152     readonly tcpType: RTCIceTcpCandidateType | null;
12153     readonly type: RTCIceCandidateType | null;
12154     readonly usernameFragment: string | null;
12155     toJSON(): RTCIceCandidateInit;
12156 }
12157
12158 declare var RTCIceCandidate: {
12159     prototype: RTCIceCandidate;
12160     new(candidateInitDict?: RTCIceCandidateInit): RTCIceCandidate;
12161 };
12162
12163 interface RTCIceCandidatePairChangedEvent extends Event {
12164     readonly pair: RTCIceCandidatePair;
12165 }
12166
12167 declare var RTCIceCandidatePairChangedEvent: {
12168     prototype: RTCIceCandidatePairChangedEvent;
12169     new(): RTCIceCandidatePairChangedEvent;
12170 };
12171
12172 interface RTCIceGathererEventMap {
12173     "error": Event;
12174     "localcandidate": RTCIceGathererEvent;
12175 }
12176
12177 interface RTCIceGatherer extends RTCStatsProvider {
12178     readonly component: RTCIceComponent;
12179     onerror: ((this: RTCIceGatherer, ev: Event) => any) | null;
12180     onlocalcandidate: ((this: RTCIceGatherer, ev: RTCIceGathererEvent) => any) | null;
12181     createAssociatedGatherer(): RTCIceGatherer;
12182     getLocalCandidates(): RTCIceCandidateDictionary[];
12183     getLocalParameters(): RTCIceParameters;
12184     addEventListener<K extends keyof RTCIceGathererEventMap>(type: K, listener: (this: RTCIceGatherer, ev: RTCIceGathererEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12185     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12186     removeEventListener<K extends keyof RTCIceGathererEventMap>(type: K, listener: (this: RTCIceGatherer, ev: RTCIceGathererEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12187     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12188 }
12189
12190 declare var RTCIceGatherer: {
12191     prototype: RTCIceGatherer;
12192     new(options: RTCIceGatherOptions): RTCIceGatherer;
12193 };
12194
12195 interface RTCIceGathererEvent extends Event {
12196     readonly candidate: RTCIceCandidateDictionary | RTCIceCandidateComplete;
12197 }
12198
12199 declare var RTCIceGathererEvent: {
12200     prototype: RTCIceGathererEvent;
12201     new(): RTCIceGathererEvent;
12202 };
12203
12204 interface RTCIceTransportEventMap {
12205     "gatheringstatechange": Event;
12206     "selectedcandidatepairchange": Event;
12207     "statechange": Event;
12208 }
12209
12210 /** Provides access to information about the ICE transport layer over which the data is being sent and received. */
12211 interface RTCIceTransport extends EventTarget {
12212     readonly component: RTCIceComponent;
12213     readonly gatheringState: RTCIceGathererState;
12214     ongatheringstatechange: ((this: RTCIceTransport, ev: Event) => any) | null;
12215     onselectedcandidatepairchange: ((this: RTCIceTransport, ev: Event) => any) | null;
12216     onstatechange: ((this: RTCIceTransport, ev: Event) => any) | null;
12217     readonly role: RTCIceRole;
12218     readonly state: RTCIceTransportState;
12219     getLocalCandidates(): RTCIceCandidate[];
12220     getLocalParameters(): RTCIceParameters | null;
12221     getRemoteCandidates(): RTCIceCandidate[];
12222     getRemoteParameters(): RTCIceParameters | null;
12223     getSelectedCandidatePair(): RTCIceCandidatePair | null;
12224     addEventListener<K extends keyof RTCIceTransportEventMap>(type: K, listener: (this: RTCIceTransport, ev: RTCIceTransportEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12225     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12226     removeEventListener<K extends keyof RTCIceTransportEventMap>(type: K, listener: (this: RTCIceTransport, ev: RTCIceTransportEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12227     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12228 }
12229
12230 declare var RTCIceTransport: {
12231     prototype: RTCIceTransport;
12232     new(): RTCIceTransport;
12233 };
12234
12235 interface RTCIceTransportStateChangedEvent extends Event {
12236     readonly state: RTCIceTransportState;
12237 }
12238
12239 declare var RTCIceTransportStateChangedEvent: {
12240     prototype: RTCIceTransportStateChangedEvent;
12241     new(): RTCIceTransportStateChangedEvent;
12242 };
12243
12244 interface RTCIdentityAssertion {
12245     idp: string;
12246     name: string;
12247 }
12248
12249 declare var RTCIdentityAssertion: {
12250     prototype: RTCIdentityAssertion;
12251     new(idp: string, name: string): RTCIdentityAssertion;
12252 };
12253
12254 interface RTCPeerConnectionEventMap {
12255     "connectionstatechange": Event;
12256     "datachannel": RTCDataChannelEvent;
12257     "icecandidate": RTCPeerConnectionIceEvent;
12258     "icecandidateerror": RTCPeerConnectionIceErrorEvent;
12259     "iceconnectionstatechange": Event;
12260     "icegatheringstatechange": Event;
12261     "negotiationneeded": Event;
12262     "signalingstatechange": Event;
12263     "statsended": RTCStatsEvent;
12264     "track": RTCTrackEvent;
12265 }
12266
12267 /** A WebRTC connection between the local computer and a remote peer. It provides methods to connect to a remote peer, maintain and monitor the connection, and close the connection once it's no longer needed. */
12268 interface RTCPeerConnection extends EventTarget {
12269     readonly canTrickleIceCandidates: boolean | null;
12270     readonly connectionState: RTCPeerConnectionState;
12271     readonly currentLocalDescription: RTCSessionDescription | null;
12272     readonly currentRemoteDescription: RTCSessionDescription | null;
12273     readonly iceConnectionState: RTCIceConnectionState;
12274     readonly iceGatheringState: RTCIceGatheringState;
12275     readonly idpErrorInfo: string | null;
12276     readonly idpLoginUrl: string | null;
12277     readonly localDescription: RTCSessionDescription | null;
12278     onconnectionstatechange: ((this: RTCPeerConnection, ev: Event) => any) | null;
12279     ondatachannel: ((this: RTCPeerConnection, ev: RTCDataChannelEvent) => any) | null;
12280     onicecandidate: ((this: RTCPeerConnection, ev: RTCPeerConnectionIceEvent) => any) | null;
12281     onicecandidateerror: ((this: RTCPeerConnection, ev: RTCPeerConnectionIceErrorEvent) => any) | null;
12282     oniceconnectionstatechange: ((this: RTCPeerConnection, ev: Event) => any) | null;
12283     onicegatheringstatechange: ((this: RTCPeerConnection, ev: Event) => any) | null;
12284     onnegotiationneeded: ((this: RTCPeerConnection, ev: Event) => any) | null;
12285     onsignalingstatechange: ((this: RTCPeerConnection, ev: Event) => any) | null;
12286     onstatsended: ((this: RTCPeerConnection, ev: RTCStatsEvent) => any) | null;
12287     ontrack: ((this: RTCPeerConnection, ev: RTCTrackEvent) => any) | null;
12288     readonly peerIdentity: Promise<RTCIdentityAssertion>;
12289     readonly pendingLocalDescription: RTCSessionDescription | null;
12290     readonly pendingRemoteDescription: RTCSessionDescription | null;
12291     readonly remoteDescription: RTCSessionDescription | null;
12292     readonly sctp: RTCSctpTransport | null;
12293     readonly signalingState: RTCSignalingState;
12294     addIceCandidate(candidate: RTCIceCandidateInit | RTCIceCandidate): Promise<void>;
12295     addTrack(track: MediaStreamTrack, ...streams: MediaStream[]): RTCRtpSender;
12296     addTransceiver(trackOrKind: MediaStreamTrack | string, init?: RTCRtpTransceiverInit): RTCRtpTransceiver;
12297     close(): void;
12298     createAnswer(options?: RTCOfferOptions): Promise<RTCSessionDescriptionInit>;
12299     createDataChannel(label: string, dataChannelDict?: RTCDataChannelInit): RTCDataChannel;
12300     createOffer(options?: RTCOfferOptions): Promise<RTCSessionDescriptionInit>;
12301     getConfiguration(): RTCConfiguration;
12302     getIdentityAssertion(): Promise<string>;
12303     getReceivers(): RTCRtpReceiver[];
12304     getSenders(): RTCRtpSender[];
12305     getStats(selector?: MediaStreamTrack | null): Promise<RTCStatsReport>;
12306     getTransceivers(): RTCRtpTransceiver[];
12307     removeTrack(sender: RTCRtpSender): void;
12308     setConfiguration(configuration: RTCConfiguration): void;
12309     setIdentityProvider(provider: string, options?: RTCIdentityProviderOptions): void;
12310     setLocalDescription(description: RTCSessionDescriptionInit): Promise<void>;
12311     setRemoteDescription(description: RTCSessionDescriptionInit): Promise<void>;
12312     addEventListener<K extends keyof RTCPeerConnectionEventMap>(type: K, listener: (this: RTCPeerConnection, ev: RTCPeerConnectionEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12313     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12314     removeEventListener<K extends keyof RTCPeerConnectionEventMap>(type: K, listener: (this: RTCPeerConnection, ev: RTCPeerConnectionEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12315     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12316 }
12317
12318 declare var RTCPeerConnection: {
12319     prototype: RTCPeerConnection;
12320     new(configuration?: RTCConfiguration): RTCPeerConnection;
12321     generateCertificate(keygenAlgorithm: AlgorithmIdentifier): Promise<RTCCertificate>;
12322     getDefaultIceServers(): RTCIceServer[];
12323 };
12324
12325 interface RTCPeerConnectionIceErrorEvent extends Event {
12326     readonly errorCode: number;
12327     readonly errorText: string;
12328     readonly hostCandidate: string;
12329     readonly url: string;
12330 }
12331
12332 declare var RTCPeerConnectionIceErrorEvent: {
12333     prototype: RTCPeerConnectionIceErrorEvent;
12334     new(type: string, eventInitDict: RTCPeerConnectionIceErrorEventInit): RTCPeerConnectionIceErrorEvent;
12335 };
12336
12337 /** Events that occurs in relation to ICE candidates with the target, usually an RTCPeerConnection. Only one event is of this type: icecandidate. */
12338 interface RTCPeerConnectionIceEvent extends Event {
12339     readonly candidate: RTCIceCandidate | null;
12340     readonly url: string | null;
12341 }
12342
12343 declare var RTCPeerConnectionIceEvent: {
12344     prototype: RTCPeerConnectionIceEvent;
12345     new(type: string, eventInitDict?: RTCPeerConnectionIceEventInit): RTCPeerConnectionIceEvent;
12346 };
12347
12348 /** This WebRTC API interface manages the reception and decoding of data for a MediaStreamTrack on an RTCPeerConnection. */
12349 interface RTCRtpReceiver {
12350     readonly rtcpTransport: RTCDtlsTransport | null;
12351     readonly track: MediaStreamTrack;
12352     readonly transport: RTCDtlsTransport | null;
12353     getContributingSources(): RTCRtpContributingSource[];
12354     getParameters(): RTCRtpReceiveParameters;
12355     getStats(): Promise<RTCStatsReport>;
12356     getSynchronizationSources(): RTCRtpSynchronizationSource[];
12357 }
12358
12359 declare var RTCRtpReceiver: {
12360     prototype: RTCRtpReceiver;
12361     new(): RTCRtpReceiver;
12362     getCapabilities(kind: string): RTCRtpCapabilities | null;
12363 };
12364
12365 /** Provides the ability to control and obtain details about how a particular MediaStreamTrack is encoded and sent to a remote peer. */
12366 interface RTCRtpSender {
12367     readonly dtmf: RTCDTMFSender | null;
12368     readonly rtcpTransport: RTCDtlsTransport | null;
12369     readonly track: MediaStreamTrack | null;
12370     readonly transport: RTCDtlsTransport | null;
12371     getParameters(): RTCRtpSendParameters;
12372     getStats(): Promise<RTCStatsReport>;
12373     replaceTrack(withTrack: MediaStreamTrack | null): Promise<void>;
12374     setParameters(parameters: RTCRtpSendParameters): Promise<void>;
12375     setStreams(...streams: MediaStream[]): void;
12376 }
12377
12378 declare var RTCRtpSender: {
12379     prototype: RTCRtpSender;
12380     new(): RTCRtpSender;
12381     getCapabilities(kind: string): RTCRtpCapabilities | null;
12382 };
12383
12384 interface RTCRtpTransceiver {
12385     readonly currentDirection: RTCRtpTransceiverDirection | null;
12386     direction: RTCRtpTransceiverDirection;
12387     readonly mid: string | null;
12388     readonly receiver: RTCRtpReceiver;
12389     readonly sender: RTCRtpSender;
12390     setCodecPreferences(codecs: RTCRtpCodecCapability[]): void;
12391     stop(): void;
12392 }
12393
12394 declare var RTCRtpTransceiver: {
12395     prototype: RTCRtpTransceiver;
12396     new(): RTCRtpTransceiver;
12397 };
12398
12399 interface RTCSctpTransportEventMap {
12400     "statechange": Event;
12401 }
12402
12403 interface RTCSctpTransport extends EventTarget {
12404     readonly maxChannels: number | null;
12405     readonly maxMessageSize: number;
12406     onstatechange: ((this: RTCSctpTransport, ev: Event) => any) | null;
12407     readonly state: RTCSctpTransportState;
12408     readonly transport: RTCDtlsTransport;
12409     addEventListener<K extends keyof RTCSctpTransportEventMap>(type: K, listener: (this: RTCSctpTransport, ev: RTCSctpTransportEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12410     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12411     removeEventListener<K extends keyof RTCSctpTransportEventMap>(type: K, listener: (this: RTCSctpTransport, ev: RTCSctpTransportEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12412     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12413 }
12414
12415 declare var RTCSctpTransport: {
12416     prototype: RTCSctpTransport;
12417     new(): RTCSctpTransport;
12418 };
12419
12420 /** One end of a connection—or potential connection—and how it's configured. Each RTCSessionDescription consists of a description type indicating which part of the offer/answer negotiation process it describes and of the SDP descriptor of the session. */
12421 interface RTCSessionDescription {
12422     readonly sdp: string;
12423     readonly type: RTCSdpType;
12424     toJSON(): any;
12425 }
12426
12427 declare var RTCSessionDescription: {
12428     prototype: RTCSessionDescription;
12429     new(descriptionInitDict?: RTCSessionDescriptionInit): RTCSessionDescription;
12430 };
12431
12432 interface RTCSrtpSdesTransportEventMap {
12433     "error": Event;
12434 }
12435
12436 interface RTCSrtpSdesTransport extends EventTarget {
12437     onerror: ((this: RTCSrtpSdesTransport, ev: Event) => any) | null;
12438     readonly transport: RTCIceTransport;
12439     addEventListener<K extends keyof RTCSrtpSdesTransportEventMap>(type: K, listener: (this: RTCSrtpSdesTransport, ev: RTCSrtpSdesTransportEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12440     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12441     removeEventListener<K extends keyof RTCSrtpSdesTransportEventMap>(type: K, listener: (this: RTCSrtpSdesTransport, ev: RTCSrtpSdesTransportEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12442     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12443 }
12444
12445 declare var RTCSrtpSdesTransport: {
12446     prototype: RTCSrtpSdesTransport;
12447     new(transport: RTCIceTransport, encryptParameters: RTCSrtpSdesParameters, decryptParameters: RTCSrtpSdesParameters): RTCSrtpSdesTransport;
12448     getLocalParameters(): RTCSrtpSdesParameters[];
12449 };
12450
12451 interface RTCSsrcConflictEvent extends Event {
12452     readonly ssrc: number;
12453 }
12454
12455 declare var RTCSsrcConflictEvent: {
12456     prototype: RTCSsrcConflictEvent;
12457     new(): RTCSsrcConflictEvent;
12458 };
12459
12460 interface RTCStatsEvent extends Event {
12461     readonly report: RTCStatsReport;
12462 }
12463
12464 declare var RTCStatsEvent: {
12465     prototype: RTCStatsEvent;
12466     new(type: string, eventInitDict: RTCStatsEventInit): RTCStatsEvent;
12467 };
12468
12469 interface RTCStatsProvider extends EventTarget {
12470     getStats(): Promise<RTCStatsReport>;
12471     msGetStats(): Promise<RTCStatsReport>;
12472 }
12473
12474 declare var RTCStatsProvider: {
12475     prototype: RTCStatsProvider;
12476     new(): RTCStatsProvider;
12477 };
12478
12479 interface RTCStatsReport {
12480     forEach(callbackfn: (value: any, key: string, parent: RTCStatsReport) => void, thisArg?: any): void;
12481 }
12482
12483 declare var RTCStatsReport: {
12484     prototype: RTCStatsReport;
12485     new(): RTCStatsReport;
12486 };
12487
12488 interface RTCTrackEvent extends Event {
12489     readonly receiver: RTCRtpReceiver;
12490     readonly streams: ReadonlyArray<MediaStream>;
12491     readonly track: MediaStreamTrack;
12492     readonly transceiver: RTCRtpTransceiver;
12493 }
12494
12495 declare var RTCTrackEvent: {
12496     prototype: RTCTrackEvent;
12497     new(type: string, eventInitDict: RTCTrackEventInit): RTCTrackEvent;
12498 };
12499
12500 interface RadioNodeList extends NodeList {
12501     value: string;
12502 }
12503
12504 declare var RadioNodeList: {
12505     prototype: RadioNodeList;
12506     new(): RadioNodeList;
12507 };
12508
12509 interface RandomSource {
12510     getRandomValues<T extends Int8Array | Uint8ClampedArray | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array>(array: T): T;
12511 }
12512
12513 declare var RandomSource: {
12514     prototype: RandomSource;
12515     new(): RandomSource;
12516 };
12517
12518 /** A fragment of a document that can contain nodes and parts of text nodes. */
12519 interface Range extends AbstractRange {
12520     /**
12521      * Returns the node, furthest away from the document, that is an ancestor of both range's start node and end node.
12522      */
12523     readonly commonAncestorContainer: Node;
12524     cloneContents(): DocumentFragment;
12525     cloneRange(): Range;
12526     collapse(toStart?: boolean): void;
12527     compareBoundaryPoints(how: number, sourceRange: Range): number;
12528     /**
12529      * Returns −1 if the point is before the range, 0 if the point is in the range, and 1 if the point is after the range.
12530      */
12531     comparePoint(node: Node, offset: number): number;
12532     createContextualFragment(fragment: string): DocumentFragment;
12533     deleteContents(): void;
12534     detach(): void;
12535     extractContents(): DocumentFragment;
12536     getBoundingClientRect(): DOMRect;
12537     getClientRects(): DOMRectList;
12538     insertNode(node: Node): void;
12539     /**
12540      * Returns whether range intersects node.
12541      */
12542     intersectsNode(node: Node): boolean;
12543     isPointInRange(node: Node, offset: number): boolean;
12544     selectNode(node: Node): void;
12545     selectNodeContents(node: Node): void;
12546     setEnd(node: Node, offset: number): void;
12547     setEndAfter(node: Node): void;
12548     setEndBefore(node: Node): void;
12549     setStart(node: Node, offset: number): void;
12550     setStartAfter(node: Node): void;
12551     setStartBefore(node: Node): void;
12552     surroundContents(newParent: Node): void;
12553     toString(): string;
12554     readonly END_TO_END: number;
12555     readonly END_TO_START: number;
12556     readonly START_TO_END: number;
12557     readonly START_TO_START: number;
12558 }
12559
12560 declare var Range: {
12561     prototype: Range;
12562     new(): Range;
12563     readonly END_TO_END: number;
12564     readonly END_TO_START: number;
12565     readonly START_TO_END: number;
12566     readonly START_TO_START: number;
12567     toString(): string;
12568 };
12569
12570 /** This Streams API interface represents a readable stream of byte data. The Fetch API offers a concrete instance of a ReadableStream through the body property of a Response object. */
12571 interface ReadableStream<R = any> {
12572     readonly locked: boolean;
12573     cancel(reason?: any): Promise<void>;
12574     getReader(): ReadableStreamDefaultReader<R>;
12575     pipeThrough<T>(transform: ReadableWritablePair<T, R>, options?: StreamPipeOptions): ReadableStream<T>;
12576     pipeTo(dest: WritableStream<R>, options?: StreamPipeOptions): Promise<void>;
12577     tee(): [ReadableStream<R>, ReadableStream<R>];
12578 }
12579
12580 declare var ReadableStream: {
12581     prototype: ReadableStream;
12582     new<R = any>(underlyingSource?: UnderlyingSource<R>, strategy?: QueuingStrategy<R>): ReadableStream<R>;
12583 };
12584
12585 interface ReadableStreamDefaultController<R = any> {
12586     readonly desiredSize: number | null;
12587     close(): void;
12588     enqueue(chunk: R): void;
12589     error(e?: any): void;
12590 }
12591
12592 declare var ReadableStreamDefaultController: {
12593     prototype: ReadableStreamDefaultController;
12594     new(): ReadableStreamDefaultController;
12595 };
12596
12597 interface ReadableStreamDefaultReader<R = any> extends ReadableStreamGenericReader {
12598     read(): Promise<ReadableStreamDefaultReadResult<R>>;
12599     releaseLock(): void;
12600 }
12601
12602 declare var ReadableStreamDefaultReader: {
12603     prototype: ReadableStreamDefaultReader;
12604     new<R = any>(stream: ReadableStream<R>): ReadableStreamDefaultReader<R>;
12605 };
12606
12607 interface ReadableStreamGenericReader {
12608     readonly closed: Promise<undefined>;
12609     cancel(reason?: any): Promise<void>;
12610 }
12611
12612 /** This Fetch API interface represents a resource request. */
12613 interface Request extends Body {
12614     /**
12615      * Returns the cache mode associated with request, which is a string indicating how the request will interact with the browser's cache when fetching.
12616      */
12617     readonly cache: RequestCache;
12618     /**
12619      * Returns the credentials mode associated with request, which is a string indicating whether credentials will be sent with the request always, never, or only when sent to a same-origin URL.
12620      */
12621     readonly credentials: RequestCredentials;
12622     /**
12623      * Returns the kind of resource requested by request, e.g., "document" or "script".
12624      */
12625     readonly destination: RequestDestination;
12626     /**
12627      * Returns a Headers object consisting of the headers associated with request. Note that headers added in the network layer by the user agent will not be accounted for in this object, e.g., the "Host" header.
12628      */
12629     readonly headers: Headers;
12630     /**
12631      * Returns request's subresource integrity metadata, which is a cryptographic hash of the resource being fetched. Its value consists of multiple hashes separated by whitespace. [SRI]
12632      */
12633     readonly integrity: string;
12634     /**
12635      * Returns a boolean indicating whether or not request is for a history navigation (a.k.a. back-foward navigation).
12636      */
12637     readonly isHistoryNavigation: boolean;
12638     /**
12639      * Returns a boolean indicating whether or not request is for a reload navigation.
12640      */
12641     readonly isReloadNavigation: boolean;
12642     /**
12643      * Returns a boolean indicating whether or not request can outlive the global in which it was created.
12644      */
12645     readonly keepalive: boolean;
12646     /**
12647      * Returns request's HTTP method, which is "GET" by default.
12648      */
12649     readonly method: string;
12650     /**
12651      * Returns the mode associated with request, which is a string indicating whether the request will use CORS, or will be restricted to same-origin URLs.
12652      */
12653     readonly mode: RequestMode;
12654     /**
12655      * Returns the redirect mode associated with request, which is a string indicating how redirects for the request will be handled during fetching. A request will follow redirects by default.
12656      */
12657     readonly redirect: RequestRedirect;
12658     /**
12659      * Returns the referrer of request. Its value can be a same-origin URL if explicitly set in init, the empty string to indicate no referrer, and "about:client" when defaulting to the global's default. This is used during fetching to determine the value of the `Referer` header of the request being made.
12660      */
12661     readonly referrer: string;
12662     /**
12663      * Returns the referrer policy associated with request. This is used during fetching to compute the value of the request's referrer.
12664      */
12665     readonly referrerPolicy: ReferrerPolicy;
12666     /**
12667      * Returns the signal associated with request, which is an AbortSignal object indicating whether or not request has been aborted, and its abort event handler.
12668      */
12669     readonly signal: AbortSignal;
12670     /**
12671      * Returns the URL of request as a string.
12672      */
12673     readonly url: string;
12674     clone(): Request;
12675 }
12676
12677 declare var Request: {
12678     prototype: Request;
12679     new(input: RequestInfo, init?: RequestInit): Request;
12680 };
12681
12682 interface ResizeObserver {
12683     disconnect(): void;
12684     observe(target: Element, options?: ResizeObserverOptions): void;
12685     unobserve(target: Element): void;
12686 }
12687
12688 declare var ResizeObserver: {
12689     prototype: ResizeObserver;
12690     new(callback: ResizeObserverCallback): ResizeObserver;
12691 };
12692
12693 interface ResizeObserverEntry {
12694     readonly borderBoxSize: ReadonlyArray<ResizeObserverSize>;
12695     readonly contentBoxSize: ReadonlyArray<ResizeObserverSize>;
12696     readonly contentRect: DOMRectReadOnly;
12697     readonly target: Element;
12698 }
12699
12700 declare var ResizeObserverEntry: {
12701     prototype: ResizeObserverEntry;
12702     new(): ResizeObserverEntry;
12703 };
12704
12705 interface ResizeObserverSize {
12706     readonly blockSize: number;
12707     readonly inlineSize: number;
12708 }
12709
12710 declare var ResizeObserverSize: {
12711     prototype: ResizeObserverSize;
12712     new(): ResizeObserverSize;
12713 };
12714
12715 /** This Fetch API interface represents the response to a request. */
12716 interface Response extends Body {
12717     readonly headers: Headers;
12718     readonly ok: boolean;
12719     readonly redirected: boolean;
12720     readonly status: number;
12721     readonly statusText: string;
12722     readonly trailer: Promise<Headers>;
12723     readonly type: ResponseType;
12724     readonly url: string;
12725     clone(): Response;
12726 }
12727
12728 declare var Response: {
12729     prototype: Response;
12730     new(body?: BodyInit | null, init?: ResponseInit): Response;
12731     error(): Response;
12732     redirect(url: string, status?: number): Response;
12733 };
12734
12735 /** Provides access to the properties of <a> element, as well as methods to manipulate them. */
12736 interface SVGAElement extends SVGGraphicsElement, SVGURIReference {
12737     readonly target: SVGAnimatedString;
12738     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGAElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12739     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12740     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGAElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12741     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12742 }
12743
12744 declare var SVGAElement: {
12745     prototype: SVGAElement;
12746     new(): SVGAElement;
12747 };
12748
12749 /** Used to represent a value that can be an <angle> or <number> value. An SVGAngle reflected through the animVal attribute is always read only. */
12750 interface SVGAngle {
12751     readonly unitType: number;
12752     value: number;
12753     valueAsString: string;
12754     valueInSpecifiedUnits: number;
12755     convertToSpecifiedUnits(unitType: number): void;
12756     newValueSpecifiedUnits(unitType: number, valueInSpecifiedUnits: number): void;
12757     readonly SVG_ANGLETYPE_DEG: number;
12758     readonly SVG_ANGLETYPE_GRAD: number;
12759     readonly SVG_ANGLETYPE_RAD: number;
12760     readonly SVG_ANGLETYPE_UNKNOWN: number;
12761     readonly SVG_ANGLETYPE_UNSPECIFIED: number;
12762 }
12763
12764 declare var SVGAngle: {
12765     prototype: SVGAngle;
12766     new(): SVGAngle;
12767     readonly SVG_ANGLETYPE_DEG: number;
12768     readonly SVG_ANGLETYPE_GRAD: number;
12769     readonly SVG_ANGLETYPE_RAD: number;
12770     readonly SVG_ANGLETYPE_UNKNOWN: number;
12771     readonly SVG_ANGLETYPE_UNSPECIFIED: number;
12772 };
12773
12774 interface SVGAnimateElement extends SVGAnimationElement {
12775     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGAnimateElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12776     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12777     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGAnimateElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12778     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12779 }
12780
12781 declare var SVGAnimateElement: {
12782     prototype: SVGAnimateElement;
12783     new(): SVGAnimateElement;
12784 };
12785
12786 interface SVGAnimateMotionElement extends SVGAnimationElement {
12787     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGAnimateMotionElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12788     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12789     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGAnimateMotionElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12790     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12791 }
12792
12793 declare var SVGAnimateMotionElement: {
12794     prototype: SVGAnimateMotionElement;
12795     new(): SVGAnimateMotionElement;
12796 };
12797
12798 interface SVGAnimateTransformElement extends SVGAnimationElement {
12799     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGAnimateTransformElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12800     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12801     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGAnimateTransformElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12802     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12803 }
12804
12805 declare var SVGAnimateTransformElement: {
12806     prototype: SVGAnimateTransformElement;
12807     new(): SVGAnimateTransformElement;
12808 };
12809
12810 /** Used for attributes of basic type <angle> which can be animated. */
12811 interface SVGAnimatedAngle {
12812     readonly animVal: SVGAngle;
12813     readonly baseVal: SVGAngle;
12814 }
12815
12816 declare var SVGAnimatedAngle: {
12817     prototype: SVGAnimatedAngle;
12818     new(): SVGAnimatedAngle;
12819 };
12820
12821 /** Used for attributes of type boolean which can be animated. */
12822 interface SVGAnimatedBoolean {
12823     readonly animVal: boolean;
12824     baseVal: boolean;
12825 }
12826
12827 declare var SVGAnimatedBoolean: {
12828     prototype: SVGAnimatedBoolean;
12829     new(): SVGAnimatedBoolean;
12830 };
12831
12832 /** Used for attributes whose value must be a constant from a particular enumeration and which can be animated. */
12833 interface SVGAnimatedEnumeration {
12834     readonly animVal: number;
12835     baseVal: number;
12836 }
12837
12838 declare var SVGAnimatedEnumeration: {
12839     prototype: SVGAnimatedEnumeration;
12840     new(): SVGAnimatedEnumeration;
12841 };
12842
12843 /** Used for attributes of basic type <integer> which can be animated. */
12844 interface SVGAnimatedInteger {
12845     readonly animVal: number;
12846     baseVal: number;
12847 }
12848
12849 declare var SVGAnimatedInteger: {
12850     prototype: SVGAnimatedInteger;
12851     new(): SVGAnimatedInteger;
12852 };
12853
12854 /** Used for attributes of basic type <length> which can be animated. */
12855 interface SVGAnimatedLength {
12856     readonly animVal: SVGLength;
12857     readonly baseVal: SVGLength;
12858 }
12859
12860 declare var SVGAnimatedLength: {
12861     prototype: SVGAnimatedLength;
12862     new(): SVGAnimatedLength;
12863 };
12864
12865 /** Used for attributes of type SVGLengthList which can be animated. */
12866 interface SVGAnimatedLengthList {
12867     readonly animVal: SVGLengthList;
12868     readonly baseVal: SVGLengthList;
12869 }
12870
12871 declare var SVGAnimatedLengthList: {
12872     prototype: SVGAnimatedLengthList;
12873     new(): SVGAnimatedLengthList;
12874 };
12875
12876 /** Used for attributes of basic type <Number> which can be animated. */
12877 interface SVGAnimatedNumber {
12878     readonly animVal: number;
12879     baseVal: number;
12880 }
12881
12882 declare var SVGAnimatedNumber: {
12883     prototype: SVGAnimatedNumber;
12884     new(): SVGAnimatedNumber;
12885 };
12886
12887 /** The SVGAnimatedNumber interface is used for attributes which take a list of numbers and which can be animated. */
12888 interface SVGAnimatedNumberList {
12889     readonly animVal: SVGNumberList;
12890     readonly baseVal: SVGNumberList;
12891 }
12892
12893 declare var SVGAnimatedNumberList: {
12894     prototype: SVGAnimatedNumberList;
12895     new(): SVGAnimatedNumberList;
12896 };
12897
12898 interface SVGAnimatedPoints {
12899     readonly animatedPoints: SVGPointList;
12900     readonly points: SVGPointList;
12901 }
12902
12903 /** Used for attributes of type SVGPreserveAspectRatio which can be animated. */
12904 interface SVGAnimatedPreserveAspectRatio {
12905     readonly animVal: SVGPreserveAspectRatio;
12906     readonly baseVal: SVGPreserveAspectRatio;
12907 }
12908
12909 declare var SVGAnimatedPreserveAspectRatio: {
12910     prototype: SVGAnimatedPreserveAspectRatio;
12911     new(): SVGAnimatedPreserveAspectRatio;
12912 };
12913
12914 /** Used for attributes of basic SVGRect which can be animated. */
12915 interface SVGAnimatedRect {
12916     readonly animVal: DOMRectReadOnly;
12917     readonly baseVal: DOMRect;
12918 }
12919
12920 declare var SVGAnimatedRect: {
12921     prototype: SVGAnimatedRect;
12922     new(): SVGAnimatedRect;
12923 };
12924
12925 /** The SVGAnimatedString interface represents string attributes which can be animated from each SVG declaration. You need to create SVG attribute before doing anything else, everything should be declared inside this. */
12926 interface SVGAnimatedString {
12927     readonly animVal: string;
12928     baseVal: string;
12929 }
12930
12931 declare var SVGAnimatedString: {
12932     prototype: SVGAnimatedString;
12933     new(): SVGAnimatedString;
12934 };
12935
12936 /** Used for attributes which take a list of numbers and which can be animated. */
12937 interface SVGAnimatedTransformList {
12938     readonly animVal: SVGTransformList;
12939     readonly baseVal: SVGTransformList;
12940 }
12941
12942 declare var SVGAnimatedTransformList: {
12943     prototype: SVGAnimatedTransformList;
12944     new(): SVGAnimatedTransformList;
12945 };
12946
12947 interface SVGAnimationElement extends SVGElement {
12948     readonly targetElement: SVGElement;
12949     getCurrentTime(): number;
12950     getSimpleDuration(): number;
12951     getStartTime(): number;
12952     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGAnimationElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12953     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12954     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGAnimationElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12955     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12956 }
12957
12958 declare var SVGAnimationElement: {
12959     prototype: SVGAnimationElement;
12960     new(): SVGAnimationElement;
12961 };
12962
12963 /** An interface for the <circle> element. The circle element is defined by the cx and cy attributes that denote the coordinates of the centre of the circle. */
12964 interface SVGCircleElement extends SVGGeometryElement {
12965     readonly cx: SVGAnimatedLength;
12966     readonly cy: SVGAnimatedLength;
12967     readonly r: SVGAnimatedLength;
12968     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGCircleElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12969     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12970     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGCircleElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12971     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12972 }
12973
12974 declare var SVGCircleElement: {
12975     prototype: SVGCircleElement;
12976     new(): SVGCircleElement;
12977 };
12978
12979 /** Provides access to the properties of <clipPath> elements, as well as methods to manipulate them. */
12980 interface SVGClipPathElement extends SVGElement {
12981     readonly clipPathUnits: SVGAnimatedEnumeration;
12982     readonly transform: SVGAnimatedTransformList;
12983     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGClipPathElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12984     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12985     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGClipPathElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12986     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12987 }
12988
12989 declare var SVGClipPathElement: {
12990     prototype: SVGClipPathElement;
12991     new(): SVGClipPathElement;
12992 };
12993
12994 /** A base interface used by the component transfer function interfaces. */
12995 interface SVGComponentTransferFunctionElement extends SVGElement {
12996     readonly amplitude: SVGAnimatedNumber;
12997     readonly exponent: SVGAnimatedNumber;
12998     readonly intercept: SVGAnimatedNumber;
12999     readonly offset: SVGAnimatedNumber;
13000     readonly slope: SVGAnimatedNumber;
13001     readonly tableValues: SVGAnimatedNumberList;
13002     readonly type: SVGAnimatedEnumeration;
13003     readonly SVG_FECOMPONENTTRANSFER_TYPE_DISCRETE: number;
13004     readonly SVG_FECOMPONENTTRANSFER_TYPE_GAMMA: number;
13005     readonly SVG_FECOMPONENTTRANSFER_TYPE_IDENTITY: number;
13006     readonly SVG_FECOMPONENTTRANSFER_TYPE_LINEAR: number;
13007     readonly SVG_FECOMPONENTTRANSFER_TYPE_TABLE: number;
13008     readonly SVG_FECOMPONENTTRANSFER_TYPE_UNKNOWN: number;
13009     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGComponentTransferFunctionElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13010     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13011     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGComponentTransferFunctionElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13012     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13013 }
13014
13015 declare var SVGComponentTransferFunctionElement: {
13016     prototype: SVGComponentTransferFunctionElement;
13017     new(): SVGComponentTransferFunctionElement;
13018     readonly SVG_FECOMPONENTTRANSFER_TYPE_DISCRETE: number;
13019     readonly SVG_FECOMPONENTTRANSFER_TYPE_GAMMA: number;
13020     readonly SVG_FECOMPONENTTRANSFER_TYPE_IDENTITY: number;
13021     readonly SVG_FECOMPONENTTRANSFER_TYPE_LINEAR: number;
13022     readonly SVG_FECOMPONENTTRANSFER_TYPE_TABLE: number;
13023     readonly SVG_FECOMPONENTTRANSFER_TYPE_UNKNOWN: number;
13024 };
13025
13026 interface SVGCursorElement extends SVGElement {
13027     readonly x: SVGAnimatedLength;
13028     readonly y: SVGAnimatedLength;
13029     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGCursorElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13030     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13031     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGCursorElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13032     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13033 }
13034
13035 declare var SVGCursorElement: {
13036     prototype: SVGCursorElement;
13037     new(): SVGCursorElement;
13038 };
13039
13040 /** Corresponds to the <defs> element. */
13041 interface SVGDefsElement extends SVGGraphicsElement {
13042     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGDefsElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13043     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13044     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGDefsElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13045     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13046 }
13047
13048 declare var SVGDefsElement: {
13049     prototype: SVGDefsElement;
13050     new(): SVGDefsElement;
13051 };
13052
13053 /** Corresponds to the <desc> element. */
13054 interface SVGDescElement extends SVGElement {
13055     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGDescElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13056     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13057     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGDescElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13058     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13059 }
13060
13061 declare var SVGDescElement: {
13062     prototype: SVGDescElement;
13063     new(): SVGDescElement;
13064 };
13065
13066 interface SVGElementEventMap extends ElementEventMap, GlobalEventHandlersEventMap, DocumentAndElementEventHandlersEventMap {
13067 }
13068
13069 /** All of the SVG DOM interfaces that correspond directly to elements in the SVG language derive from the SVGElement interface. */
13070 interface SVGElement extends Element, DocumentAndElementEventHandlers, DocumentAndElementEventHandlers, ElementCSSInlineStyle, GlobalEventHandlers, GlobalEventHandlers, HTMLOrSVGElement, SVGElementInstance {
13071     /** @deprecated */
13072     readonly className: any;
13073     readonly ownerSVGElement: SVGSVGElement | null;
13074     readonly viewportElement: SVGElement | null;
13075     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13076     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13077     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13078     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13079 }
13080
13081 declare var SVGElement: {
13082     prototype: SVGElement;
13083     new(): SVGElement;
13084 };
13085
13086 interface SVGElementInstance extends EventTarget {
13087     readonly correspondingElement: SVGElement;
13088     readonly correspondingUseElement: SVGUseElement;
13089 }
13090
13091 declare var SVGElementInstance: {
13092     prototype: SVGElementInstance;
13093     new(): SVGElementInstance;
13094 };
13095
13096 interface SVGElementInstanceList {
13097     /** @deprecated */
13098     readonly length: number;
13099     /** @deprecated */
13100     item(index: number): SVGElementInstance;
13101 }
13102
13103 declare var SVGElementInstanceList: {
13104     prototype: SVGElementInstanceList;
13105     new(): SVGElementInstanceList;
13106 };
13107
13108 /** Provides access to the properties of <ellipse> elements. */
13109 interface SVGEllipseElement extends SVGGeometryElement {
13110     readonly cx: SVGAnimatedLength;
13111     readonly cy: SVGAnimatedLength;
13112     readonly rx: SVGAnimatedLength;
13113     readonly ry: SVGAnimatedLength;
13114     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGEllipseElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13115     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13116     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGEllipseElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13117     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13118 }
13119
13120 declare var SVGEllipseElement: {
13121     prototype: SVGEllipseElement;
13122     new(): SVGEllipseElement;
13123 };
13124
13125 /** Corresponds to the <feBlend> element. */
13126 interface SVGFEBlendElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13127     readonly in1: SVGAnimatedString;
13128     readonly in2: SVGAnimatedString;
13129     readonly mode: SVGAnimatedEnumeration;
13130     readonly SVG_FEBLEND_MODE_COLOR: number;
13131     readonly SVG_FEBLEND_MODE_COLOR_BURN: number;
13132     readonly SVG_FEBLEND_MODE_COLOR_DODGE: number;
13133     readonly SVG_FEBLEND_MODE_DARKEN: number;
13134     readonly SVG_FEBLEND_MODE_DIFFERENCE: number;
13135     readonly SVG_FEBLEND_MODE_EXCLUSION: number;
13136     readonly SVG_FEBLEND_MODE_HARD_LIGHT: number;
13137     readonly SVG_FEBLEND_MODE_HUE: number;
13138     readonly SVG_FEBLEND_MODE_LIGHTEN: number;
13139     readonly SVG_FEBLEND_MODE_LUMINOSITY: number;
13140     readonly SVG_FEBLEND_MODE_MULTIPLY: number;
13141     readonly SVG_FEBLEND_MODE_NORMAL: number;
13142     readonly SVG_FEBLEND_MODE_OVERLAY: number;
13143     readonly SVG_FEBLEND_MODE_SATURATION: number;
13144     readonly SVG_FEBLEND_MODE_SCREEN: number;
13145     readonly SVG_FEBLEND_MODE_SOFT_LIGHT: number;
13146     readonly SVG_FEBLEND_MODE_UNKNOWN: number;
13147     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEBlendElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13148     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13149     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEBlendElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13150     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13151 }
13152
13153 declare var SVGFEBlendElement: {
13154     prototype: SVGFEBlendElement;
13155     new(): SVGFEBlendElement;
13156     readonly SVG_FEBLEND_MODE_COLOR: number;
13157     readonly SVG_FEBLEND_MODE_COLOR_BURN: number;
13158     readonly SVG_FEBLEND_MODE_COLOR_DODGE: number;
13159     readonly SVG_FEBLEND_MODE_DARKEN: number;
13160     readonly SVG_FEBLEND_MODE_DIFFERENCE: number;
13161     readonly SVG_FEBLEND_MODE_EXCLUSION: number;
13162     readonly SVG_FEBLEND_MODE_HARD_LIGHT: number;
13163     readonly SVG_FEBLEND_MODE_HUE: number;
13164     readonly SVG_FEBLEND_MODE_LIGHTEN: number;
13165     readonly SVG_FEBLEND_MODE_LUMINOSITY: number;
13166     readonly SVG_FEBLEND_MODE_MULTIPLY: number;
13167     readonly SVG_FEBLEND_MODE_NORMAL: number;
13168     readonly SVG_FEBLEND_MODE_OVERLAY: number;
13169     readonly SVG_FEBLEND_MODE_SATURATION: number;
13170     readonly SVG_FEBLEND_MODE_SCREEN: number;
13171     readonly SVG_FEBLEND_MODE_SOFT_LIGHT: number;
13172     readonly SVG_FEBLEND_MODE_UNKNOWN: number;
13173 };
13174
13175 /** Corresponds to the <feColorMatrix> element. */
13176 interface SVGFEColorMatrixElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13177     readonly in1: SVGAnimatedString;
13178     readonly type: SVGAnimatedEnumeration;
13179     readonly values: SVGAnimatedNumberList;
13180     readonly SVG_FECOLORMATRIX_TYPE_HUEROTATE: number;
13181     readonly SVG_FECOLORMATRIX_TYPE_LUMINANCETOALPHA: number;
13182     readonly SVG_FECOLORMATRIX_TYPE_MATRIX: number;
13183     readonly SVG_FECOLORMATRIX_TYPE_SATURATE: number;
13184     readonly SVG_FECOLORMATRIX_TYPE_UNKNOWN: number;
13185     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEColorMatrixElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13186     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13187     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEColorMatrixElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13188     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13189 }
13190
13191 declare var SVGFEColorMatrixElement: {
13192     prototype: SVGFEColorMatrixElement;
13193     new(): SVGFEColorMatrixElement;
13194     readonly SVG_FECOLORMATRIX_TYPE_HUEROTATE: number;
13195     readonly SVG_FECOLORMATRIX_TYPE_LUMINANCETOALPHA: number;
13196     readonly SVG_FECOLORMATRIX_TYPE_MATRIX: number;
13197     readonly SVG_FECOLORMATRIX_TYPE_SATURATE: number;
13198     readonly SVG_FECOLORMATRIX_TYPE_UNKNOWN: number;
13199 };
13200
13201 /** Corresponds to the <feComponentTransfer> element. */
13202 interface SVGFEComponentTransferElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13203     readonly in1: SVGAnimatedString;
13204     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEComponentTransferElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13205     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13206     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEComponentTransferElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13207     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13208 }
13209
13210 declare var SVGFEComponentTransferElement: {
13211     prototype: SVGFEComponentTransferElement;
13212     new(): SVGFEComponentTransferElement;
13213 };
13214
13215 /** Corresponds to the <feComposite> element. */
13216 interface SVGFECompositeElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13217     readonly in1: SVGAnimatedString;
13218     readonly in2: SVGAnimatedString;
13219     readonly k1: SVGAnimatedNumber;
13220     readonly k2: SVGAnimatedNumber;
13221     readonly k3: SVGAnimatedNumber;
13222     readonly k4: SVGAnimatedNumber;
13223     readonly operator: SVGAnimatedEnumeration;
13224     readonly SVG_FECOMPOSITE_OPERATOR_ARITHMETIC: number;
13225     readonly SVG_FECOMPOSITE_OPERATOR_ATOP: number;
13226     readonly SVG_FECOMPOSITE_OPERATOR_IN: number;
13227     readonly SVG_FECOMPOSITE_OPERATOR_OUT: number;
13228     readonly SVG_FECOMPOSITE_OPERATOR_OVER: number;
13229     readonly SVG_FECOMPOSITE_OPERATOR_UNKNOWN: number;
13230     readonly SVG_FECOMPOSITE_OPERATOR_XOR: number;
13231     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFECompositeElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13232     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13233     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFECompositeElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13234     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13235 }
13236
13237 declare var SVGFECompositeElement: {
13238     prototype: SVGFECompositeElement;
13239     new(): SVGFECompositeElement;
13240     readonly SVG_FECOMPOSITE_OPERATOR_ARITHMETIC: number;
13241     readonly SVG_FECOMPOSITE_OPERATOR_ATOP: number;
13242     readonly SVG_FECOMPOSITE_OPERATOR_IN: number;
13243     readonly SVG_FECOMPOSITE_OPERATOR_OUT: number;
13244     readonly SVG_FECOMPOSITE_OPERATOR_OVER: number;
13245     readonly SVG_FECOMPOSITE_OPERATOR_UNKNOWN: number;
13246     readonly SVG_FECOMPOSITE_OPERATOR_XOR: number;
13247 };
13248
13249 /** Corresponds to the <feConvolveMatrix> element. */
13250 interface SVGFEConvolveMatrixElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13251     readonly bias: SVGAnimatedNumber;
13252     readonly divisor: SVGAnimatedNumber;
13253     readonly edgeMode: SVGAnimatedEnumeration;
13254     readonly in1: SVGAnimatedString;
13255     readonly kernelMatrix: SVGAnimatedNumberList;
13256     readonly kernelUnitLengthX: SVGAnimatedNumber;
13257     readonly kernelUnitLengthY: SVGAnimatedNumber;
13258     readonly orderX: SVGAnimatedInteger;
13259     readonly orderY: SVGAnimatedInteger;
13260     readonly preserveAlpha: SVGAnimatedBoolean;
13261     readonly targetX: SVGAnimatedInteger;
13262     readonly targetY: SVGAnimatedInteger;
13263     readonly SVG_EDGEMODE_DUPLICATE: number;
13264     readonly SVG_EDGEMODE_NONE: number;
13265     readonly SVG_EDGEMODE_UNKNOWN: number;
13266     readonly SVG_EDGEMODE_WRAP: number;
13267     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEConvolveMatrixElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13268     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13269     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEConvolveMatrixElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13270     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13271 }
13272
13273 declare var SVGFEConvolveMatrixElement: {
13274     prototype: SVGFEConvolveMatrixElement;
13275     new(): SVGFEConvolveMatrixElement;
13276     readonly SVG_EDGEMODE_DUPLICATE: number;
13277     readonly SVG_EDGEMODE_NONE: number;
13278     readonly SVG_EDGEMODE_UNKNOWN: number;
13279     readonly SVG_EDGEMODE_WRAP: number;
13280 };
13281
13282 /** Corresponds to the <feDiffuseLighting> element. */
13283 interface SVGFEDiffuseLightingElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13284     readonly diffuseConstant: SVGAnimatedNumber;
13285     readonly in1: SVGAnimatedString;
13286     readonly kernelUnitLengthX: SVGAnimatedNumber;
13287     readonly kernelUnitLengthY: SVGAnimatedNumber;
13288     readonly surfaceScale: SVGAnimatedNumber;
13289     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEDiffuseLightingElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13290     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13291     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEDiffuseLightingElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13292     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13293 }
13294
13295 declare var SVGFEDiffuseLightingElement: {
13296     prototype: SVGFEDiffuseLightingElement;
13297     new(): SVGFEDiffuseLightingElement;
13298 };
13299
13300 /** Corresponds to the <feDisplacementMap> element. */
13301 interface SVGFEDisplacementMapElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13302     readonly in1: SVGAnimatedString;
13303     readonly in2: SVGAnimatedString;
13304     readonly scale: SVGAnimatedNumber;
13305     readonly xChannelSelector: SVGAnimatedEnumeration;
13306     readonly yChannelSelector: SVGAnimatedEnumeration;
13307     readonly SVG_CHANNEL_A: number;
13308     readonly SVG_CHANNEL_B: number;
13309     readonly SVG_CHANNEL_G: number;
13310     readonly SVG_CHANNEL_R: number;
13311     readonly SVG_CHANNEL_UNKNOWN: number;
13312     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEDisplacementMapElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13313     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13314     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEDisplacementMapElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13315     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13316 }
13317
13318 declare var SVGFEDisplacementMapElement: {
13319     prototype: SVGFEDisplacementMapElement;
13320     new(): SVGFEDisplacementMapElement;
13321     readonly SVG_CHANNEL_A: number;
13322     readonly SVG_CHANNEL_B: number;
13323     readonly SVG_CHANNEL_G: number;
13324     readonly SVG_CHANNEL_R: number;
13325     readonly SVG_CHANNEL_UNKNOWN: number;
13326 };
13327
13328 /** Corresponds to the <feDistantLight> element. */
13329 interface SVGFEDistantLightElement extends SVGElement {
13330     readonly azimuth: SVGAnimatedNumber;
13331     readonly elevation: SVGAnimatedNumber;
13332     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEDistantLightElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13333     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13334     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEDistantLightElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13335     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13336 }
13337
13338 declare var SVGFEDistantLightElement: {
13339     prototype: SVGFEDistantLightElement;
13340     new(): SVGFEDistantLightElement;
13341 };
13342
13343 interface SVGFEDropShadowElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13344     readonly dx: SVGAnimatedNumber;
13345     readonly dy: SVGAnimatedNumber;
13346     readonly in1: SVGAnimatedString;
13347     readonly stdDeviationX: SVGAnimatedNumber;
13348     readonly stdDeviationY: SVGAnimatedNumber;
13349     setStdDeviation(stdDeviationX: number, stdDeviationY: number): void;
13350     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEDropShadowElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13351     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13352     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEDropShadowElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13353     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13354 }
13355
13356 declare var SVGFEDropShadowElement: {
13357     prototype: SVGFEDropShadowElement;
13358     new(): SVGFEDropShadowElement;
13359 };
13360
13361 /** Corresponds to the <feFlood> element. */
13362 interface SVGFEFloodElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13363     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEFloodElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13364     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13365     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEFloodElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13366     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13367 }
13368
13369 declare var SVGFEFloodElement: {
13370     prototype: SVGFEFloodElement;
13371     new(): SVGFEFloodElement;
13372 };
13373
13374 /** Corresponds to the <feFuncA> element. */
13375 interface SVGFEFuncAElement extends SVGComponentTransferFunctionElement {
13376     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEFuncAElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13377     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13378     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEFuncAElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13379     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13380 }
13381
13382 declare var SVGFEFuncAElement: {
13383     prototype: SVGFEFuncAElement;
13384     new(): SVGFEFuncAElement;
13385 };
13386
13387 /** Corresponds to the <feFuncB> element. */
13388 interface SVGFEFuncBElement extends SVGComponentTransferFunctionElement {
13389     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEFuncBElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13390     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13391     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEFuncBElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13392     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13393 }
13394
13395 declare var SVGFEFuncBElement: {
13396     prototype: SVGFEFuncBElement;
13397     new(): SVGFEFuncBElement;
13398 };
13399
13400 /** Corresponds to the <feFuncG> element. */
13401 interface SVGFEFuncGElement extends SVGComponentTransferFunctionElement {
13402     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEFuncGElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13403     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13404     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEFuncGElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13405     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13406 }
13407
13408 declare var SVGFEFuncGElement: {
13409     prototype: SVGFEFuncGElement;
13410     new(): SVGFEFuncGElement;
13411 };
13412
13413 /** Corresponds to the <feFuncR> element. */
13414 interface SVGFEFuncRElement extends SVGComponentTransferFunctionElement {
13415     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEFuncRElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13416     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13417     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEFuncRElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13418     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13419 }
13420
13421 declare var SVGFEFuncRElement: {
13422     prototype: SVGFEFuncRElement;
13423     new(): SVGFEFuncRElement;
13424 };
13425
13426 /** Corresponds to the <feGaussianBlur> element. */
13427 interface SVGFEGaussianBlurElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13428     readonly in1: SVGAnimatedString;
13429     readonly stdDeviationX: SVGAnimatedNumber;
13430     readonly stdDeviationY: SVGAnimatedNumber;
13431     setStdDeviation(stdDeviationX: number, stdDeviationY: number): void;
13432     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEGaussianBlurElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13433     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13434     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEGaussianBlurElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13435     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13436 }
13437
13438 declare var SVGFEGaussianBlurElement: {
13439     prototype: SVGFEGaussianBlurElement;
13440     new(): SVGFEGaussianBlurElement;
13441 };
13442
13443 /** Corresponds to the <feImage> element. */
13444 interface SVGFEImageElement extends SVGElement, SVGFilterPrimitiveStandardAttributes, SVGURIReference {
13445     readonly preserveAspectRatio: SVGAnimatedPreserveAspectRatio;
13446     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEImageElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13447     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13448     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEImageElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13449     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13450 }
13451
13452 declare var SVGFEImageElement: {
13453     prototype: SVGFEImageElement;
13454     new(): SVGFEImageElement;
13455 };
13456
13457 /** Corresponds to the <feMerge> element. */
13458 interface SVGFEMergeElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13459     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEMergeElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13460     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13461     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEMergeElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13462     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13463 }
13464
13465 declare var SVGFEMergeElement: {
13466     prototype: SVGFEMergeElement;
13467     new(): SVGFEMergeElement;
13468 };
13469
13470 /** Corresponds to the <feMergeNode> element. */
13471 interface SVGFEMergeNodeElement extends SVGElement {
13472     readonly in1: SVGAnimatedString;
13473     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEMergeNodeElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13474     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13475     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEMergeNodeElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13476     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13477 }
13478
13479 declare var SVGFEMergeNodeElement: {
13480     prototype: SVGFEMergeNodeElement;
13481     new(): SVGFEMergeNodeElement;
13482 };
13483
13484 /** Corresponds to the <feMorphology> element. */
13485 interface SVGFEMorphologyElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13486     readonly in1: SVGAnimatedString;
13487     readonly operator: SVGAnimatedEnumeration;
13488     readonly radiusX: SVGAnimatedNumber;
13489     readonly radiusY: SVGAnimatedNumber;
13490     readonly SVG_MORPHOLOGY_OPERATOR_DILATE: number;
13491     readonly SVG_MORPHOLOGY_OPERATOR_ERODE: number;
13492     readonly SVG_MORPHOLOGY_OPERATOR_UNKNOWN: number;
13493     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEMorphologyElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13494     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13495     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEMorphologyElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13496     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13497 }
13498
13499 declare var SVGFEMorphologyElement: {
13500     prototype: SVGFEMorphologyElement;
13501     new(): SVGFEMorphologyElement;
13502     readonly SVG_MORPHOLOGY_OPERATOR_DILATE: number;
13503     readonly SVG_MORPHOLOGY_OPERATOR_ERODE: number;
13504     readonly SVG_MORPHOLOGY_OPERATOR_UNKNOWN: number;
13505 };
13506
13507 /** Corresponds to the <feOffset> element. */
13508 interface SVGFEOffsetElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13509     readonly dx: SVGAnimatedNumber;
13510     readonly dy: SVGAnimatedNumber;
13511     readonly in1: SVGAnimatedString;
13512     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEOffsetElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13513     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13514     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEOffsetElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13515     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13516 }
13517
13518 declare var SVGFEOffsetElement: {
13519     prototype: SVGFEOffsetElement;
13520     new(): SVGFEOffsetElement;
13521 };
13522
13523 /** Corresponds to the <fePointLight> element. */
13524 interface SVGFEPointLightElement extends SVGElement {
13525     readonly x: SVGAnimatedNumber;
13526     readonly y: SVGAnimatedNumber;
13527     readonly z: SVGAnimatedNumber;
13528     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEPointLightElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13529     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13530     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEPointLightElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13531     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13532 }
13533
13534 declare var SVGFEPointLightElement: {
13535     prototype: SVGFEPointLightElement;
13536     new(): SVGFEPointLightElement;
13537 };
13538
13539 /** Corresponds to the <feSpecularLighting> element. */
13540 interface SVGFESpecularLightingElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13541     readonly in1: SVGAnimatedString;
13542     readonly kernelUnitLengthX: SVGAnimatedNumber;
13543     readonly kernelUnitLengthY: SVGAnimatedNumber;
13544     readonly specularConstant: SVGAnimatedNumber;
13545     readonly specularExponent: SVGAnimatedNumber;
13546     readonly surfaceScale: SVGAnimatedNumber;
13547     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFESpecularLightingElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13548     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13549     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFESpecularLightingElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13550     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13551 }
13552
13553 declare var SVGFESpecularLightingElement: {
13554     prototype: SVGFESpecularLightingElement;
13555     new(): SVGFESpecularLightingElement;
13556 };
13557
13558 /** Corresponds to the <feSpotLight> element. */
13559 interface SVGFESpotLightElement extends SVGElement {
13560     readonly limitingConeAngle: SVGAnimatedNumber;
13561     readonly pointsAtX: SVGAnimatedNumber;
13562     readonly pointsAtY: SVGAnimatedNumber;
13563     readonly pointsAtZ: SVGAnimatedNumber;
13564     readonly specularExponent: SVGAnimatedNumber;
13565     readonly x: SVGAnimatedNumber;
13566     readonly y: SVGAnimatedNumber;
13567     readonly z: SVGAnimatedNumber;
13568     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFESpotLightElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13569     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13570     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFESpotLightElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13571     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13572 }
13573
13574 declare var SVGFESpotLightElement: {
13575     prototype: SVGFESpotLightElement;
13576     new(): SVGFESpotLightElement;
13577 };
13578
13579 /** Corresponds to the <feTile> element. */
13580 interface SVGFETileElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13581     readonly in1: SVGAnimatedString;
13582     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFETileElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13583     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13584     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFETileElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13585     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13586 }
13587
13588 declare var SVGFETileElement: {
13589     prototype: SVGFETileElement;
13590     new(): SVGFETileElement;
13591 };
13592
13593 /** Corresponds to the <feTurbulence> element. */
13594 interface SVGFETurbulenceElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13595     readonly baseFrequencyX: SVGAnimatedNumber;
13596     readonly baseFrequencyY: SVGAnimatedNumber;
13597     readonly numOctaves: SVGAnimatedInteger;
13598     readonly seed: SVGAnimatedNumber;
13599     readonly stitchTiles: SVGAnimatedEnumeration;
13600     readonly type: SVGAnimatedEnumeration;
13601     readonly SVG_STITCHTYPE_NOSTITCH: number;
13602     readonly SVG_STITCHTYPE_STITCH: number;
13603     readonly SVG_STITCHTYPE_UNKNOWN: number;
13604     readonly SVG_TURBULENCE_TYPE_FRACTALNOISE: number;
13605     readonly SVG_TURBULENCE_TYPE_TURBULENCE: number;
13606     readonly SVG_TURBULENCE_TYPE_UNKNOWN: number;
13607     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFETurbulenceElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13608     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13609     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFETurbulenceElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13610     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13611 }
13612
13613 declare var SVGFETurbulenceElement: {
13614     prototype: SVGFETurbulenceElement;
13615     new(): SVGFETurbulenceElement;
13616     readonly SVG_STITCHTYPE_NOSTITCH: number;
13617     readonly SVG_STITCHTYPE_STITCH: number;
13618     readonly SVG_STITCHTYPE_UNKNOWN: number;
13619     readonly SVG_TURBULENCE_TYPE_FRACTALNOISE: number;
13620     readonly SVG_TURBULENCE_TYPE_TURBULENCE: number;
13621     readonly SVG_TURBULENCE_TYPE_UNKNOWN: number;
13622 };
13623
13624 /** Provides access to the properties of <filter> elements, as well as methods to manipulate them. */
13625 interface SVGFilterElement extends SVGElement, SVGURIReference {
13626     readonly filterUnits: SVGAnimatedEnumeration;
13627     readonly height: SVGAnimatedLength;
13628     readonly primitiveUnits: SVGAnimatedEnumeration;
13629     readonly width: SVGAnimatedLength;
13630     readonly x: SVGAnimatedLength;
13631     readonly y: SVGAnimatedLength;
13632     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFilterElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13633     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13634     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFilterElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13635     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13636 }
13637
13638 declare var SVGFilterElement: {
13639     prototype: SVGFilterElement;
13640     new(): SVGFilterElement;
13641 };
13642
13643 interface SVGFilterPrimitiveStandardAttributes {
13644     readonly height: SVGAnimatedLength;
13645     readonly result: SVGAnimatedString;
13646     readonly width: SVGAnimatedLength;
13647     readonly x: SVGAnimatedLength;
13648     readonly y: SVGAnimatedLength;
13649 }
13650
13651 interface SVGFitToViewBox {
13652     readonly preserveAspectRatio: SVGAnimatedPreserveAspectRatio;
13653     readonly viewBox: SVGAnimatedRect;
13654 }
13655
13656 /** Provides access to the properties of <foreignObject> elements, as well as methods to manipulate them. */
13657 interface SVGForeignObjectElement extends SVGGraphicsElement {
13658     readonly height: SVGAnimatedLength;
13659     readonly width: SVGAnimatedLength;
13660     readonly x: SVGAnimatedLength;
13661     readonly y: SVGAnimatedLength;
13662     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGForeignObjectElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13663     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13664     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGForeignObjectElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13665     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13666 }
13667
13668 declare var SVGForeignObjectElement: {
13669     prototype: SVGForeignObjectElement;
13670     new(): SVGForeignObjectElement;
13671 };
13672
13673 /** Corresponds to the <g> element. */
13674 interface SVGGElement extends SVGGraphicsElement {
13675     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGGElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13676     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13677     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGGElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13678     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13679 }
13680
13681 declare var SVGGElement: {
13682     prototype: SVGGElement;
13683     new(): SVGGElement;
13684 };
13685
13686 interface SVGGeometryElement extends SVGGraphicsElement {
13687     readonly pathLength: SVGAnimatedNumber;
13688     getPointAtLength(distance: number): DOMPoint;
13689     getTotalLength(): number;
13690     isPointInFill(point?: DOMPointInit): boolean;
13691     isPointInStroke(point?: DOMPointInit): boolean;
13692     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGGeometryElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13693     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13694     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGGeometryElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13695     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13696 }
13697
13698 declare var SVGGeometryElement: {
13699     prototype: SVGGeometryElement;
13700     new(): SVGGeometryElement;
13701 };
13702
13703 /** The SVGGradient interface is a base interface used by SVGLinearGradientElement and SVGRadialGradientElement. */
13704 interface SVGGradientElement extends SVGElement, SVGURIReference {
13705     readonly gradientTransform: SVGAnimatedTransformList;
13706     readonly gradientUnits: SVGAnimatedEnumeration;
13707     readonly spreadMethod: SVGAnimatedEnumeration;
13708     readonly SVG_SPREADMETHOD_PAD: number;
13709     readonly SVG_SPREADMETHOD_REFLECT: number;
13710     readonly SVG_SPREADMETHOD_REPEAT: number;
13711     readonly SVG_SPREADMETHOD_UNKNOWN: number;
13712     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGGradientElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13713     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13714     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGGradientElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13715     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13716 }
13717
13718 declare var SVGGradientElement: {
13719     prototype: SVGGradientElement;
13720     new(): SVGGradientElement;
13721     readonly SVG_SPREADMETHOD_PAD: number;
13722     readonly SVG_SPREADMETHOD_REFLECT: number;
13723     readonly SVG_SPREADMETHOD_REPEAT: number;
13724     readonly SVG_SPREADMETHOD_UNKNOWN: number;
13725 };
13726
13727 /** SVG elements whose primary purpose is to directly render graphics into a group. */
13728 interface SVGGraphicsElement extends SVGElement, SVGTests {
13729     readonly transform: SVGAnimatedTransformList;
13730     getBBox(options?: SVGBoundingBoxOptions): DOMRect;
13731     getCTM(): DOMMatrix | null;
13732     getScreenCTM(): DOMMatrix | null;
13733     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGGraphicsElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13734     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13735     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGGraphicsElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13736     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13737 }
13738
13739 declare var SVGGraphicsElement: {
13740     prototype: SVGGraphicsElement;
13741     new(): SVGGraphicsElement;
13742 };
13743
13744 /** Corresponds to the <image> element. */
13745 interface SVGImageElement extends SVGGraphicsElement, SVGURIReference {
13746     readonly height: SVGAnimatedLength;
13747     readonly preserveAspectRatio: SVGAnimatedPreserveAspectRatio;
13748     readonly width: SVGAnimatedLength;
13749     readonly x: SVGAnimatedLength;
13750     readonly y: SVGAnimatedLength;
13751     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGImageElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13752     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13753     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGImageElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13754     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13755 }
13756
13757 declare var SVGImageElement: {
13758     prototype: SVGImageElement;
13759     new(): SVGImageElement;
13760 };
13761
13762 /** Correspond to the <length> basic data type. */
13763 interface SVGLength {
13764     readonly unitType: number;
13765     value: number;
13766     valueAsString: string;
13767     valueInSpecifiedUnits: number;
13768     convertToSpecifiedUnits(unitType: number): void;
13769     newValueSpecifiedUnits(unitType: number, valueInSpecifiedUnits: number): void;
13770     readonly SVG_LENGTHTYPE_CM: number;
13771     readonly SVG_LENGTHTYPE_EMS: number;
13772     readonly SVG_LENGTHTYPE_EXS: number;
13773     readonly SVG_LENGTHTYPE_IN: number;
13774     readonly SVG_LENGTHTYPE_MM: number;
13775     readonly SVG_LENGTHTYPE_NUMBER: number;
13776     readonly SVG_LENGTHTYPE_PC: number;
13777     readonly SVG_LENGTHTYPE_PERCENTAGE: number;
13778     readonly SVG_LENGTHTYPE_PT: number;
13779     readonly SVG_LENGTHTYPE_PX: number;
13780     readonly SVG_LENGTHTYPE_UNKNOWN: number;
13781 }
13782
13783 declare var SVGLength: {
13784     prototype: SVGLength;
13785     new(): SVGLength;
13786     readonly SVG_LENGTHTYPE_CM: number;
13787     readonly SVG_LENGTHTYPE_EMS: number;
13788     readonly SVG_LENGTHTYPE_EXS: number;
13789     readonly SVG_LENGTHTYPE_IN: number;
13790     readonly SVG_LENGTHTYPE_MM: number;
13791     readonly SVG_LENGTHTYPE_NUMBER: number;
13792     readonly SVG_LENGTHTYPE_PC: number;
13793     readonly SVG_LENGTHTYPE_PERCENTAGE: number;
13794     readonly SVG_LENGTHTYPE_PT: number;
13795     readonly SVG_LENGTHTYPE_PX: number;
13796     readonly SVG_LENGTHTYPE_UNKNOWN: number;
13797 };
13798
13799 /** The SVGLengthList defines a list of SVGLength objects. */
13800 interface SVGLengthList {
13801     readonly length: number;
13802     readonly numberOfItems: number;
13803     appendItem(newItem: SVGLength): SVGLength;
13804     clear(): void;
13805     getItem(index: number): SVGLength;
13806     initialize(newItem: SVGLength): SVGLength;
13807     insertItemBefore(newItem: SVGLength, index: number): SVGLength;
13808     removeItem(index: number): SVGLength;
13809     replaceItem(newItem: SVGLength, index: number): SVGLength;
13810     [index: number]: SVGLength;
13811 }
13812
13813 declare var SVGLengthList: {
13814     prototype: SVGLengthList;
13815     new(): SVGLengthList;
13816 };
13817
13818 /** Provides access to the properties of <line> elements, as well as methods to manipulate them. */
13819 interface SVGLineElement extends SVGGeometryElement {
13820     readonly x1: SVGAnimatedLength;
13821     readonly x2: SVGAnimatedLength;
13822     readonly y1: SVGAnimatedLength;
13823     readonly y2: SVGAnimatedLength;
13824     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGLineElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13825     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13826     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGLineElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13827     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13828 }
13829
13830 declare var SVGLineElement: {
13831     prototype: SVGLineElement;
13832     new(): SVGLineElement;
13833 };
13834
13835 /** Corresponds to the <linearGradient> element. */
13836 interface SVGLinearGradientElement extends SVGGradientElement {
13837     readonly x1: SVGAnimatedLength;
13838     readonly x2: SVGAnimatedLength;
13839     readonly y1: SVGAnimatedLength;
13840     readonly y2: SVGAnimatedLength;
13841     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGLinearGradientElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13842     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13843     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGLinearGradientElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13844     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13845 }
13846
13847 declare var SVGLinearGradientElement: {
13848     prototype: SVGLinearGradientElement;
13849     new(): SVGLinearGradientElement;
13850 };
13851
13852 interface SVGMarkerElement extends SVGElement, SVGFitToViewBox {
13853     readonly markerHeight: SVGAnimatedLength;
13854     readonly markerUnits: SVGAnimatedEnumeration;
13855     readonly markerWidth: SVGAnimatedLength;
13856     readonly orientAngle: SVGAnimatedAngle;
13857     readonly orientType: SVGAnimatedEnumeration;
13858     readonly refX: SVGAnimatedLength;
13859     readonly refY: SVGAnimatedLength;
13860     setOrientToAngle(angle: SVGAngle): void;
13861     setOrientToAuto(): void;
13862     readonly SVG_MARKERUNITS_STROKEWIDTH: number;
13863     readonly SVG_MARKERUNITS_UNKNOWN: number;
13864     readonly SVG_MARKERUNITS_USERSPACEONUSE: number;
13865     readonly SVG_MARKER_ORIENT_ANGLE: number;
13866     readonly SVG_MARKER_ORIENT_AUTO: number;
13867     readonly SVG_MARKER_ORIENT_UNKNOWN: number;
13868     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGMarkerElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13869     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13870     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGMarkerElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13871     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13872 }
13873
13874 declare var SVGMarkerElement: {
13875     prototype: SVGMarkerElement;
13876     new(): SVGMarkerElement;
13877     readonly SVG_MARKERUNITS_STROKEWIDTH: number;
13878     readonly SVG_MARKERUNITS_UNKNOWN: number;
13879     readonly SVG_MARKERUNITS_USERSPACEONUSE: number;
13880     readonly SVG_MARKER_ORIENT_ANGLE: number;
13881     readonly SVG_MARKER_ORIENT_AUTO: number;
13882     readonly SVG_MARKER_ORIENT_UNKNOWN: number;
13883 };
13884
13885 /** Provides access to the properties of <mask> elements, as well as methods to manipulate them. */
13886 interface SVGMaskElement extends SVGElement {
13887     readonly height: SVGAnimatedLength;
13888     readonly maskContentUnits: SVGAnimatedEnumeration;
13889     readonly maskUnits: SVGAnimatedEnumeration;
13890     readonly width: SVGAnimatedLength;
13891     readonly x: SVGAnimatedLength;
13892     readonly y: SVGAnimatedLength;
13893     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGMaskElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13894     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13895     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGMaskElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13896     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13897 }
13898
13899 declare var SVGMaskElement: {
13900     prototype: SVGMaskElement;
13901     new(): SVGMaskElement;
13902 };
13903
13904 /** Corresponds to the <metadata> element. */
13905 interface SVGMetadataElement extends SVGElement {
13906     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGMetadataElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13907     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13908     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGMetadataElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13909     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13910 }
13911
13912 declare var SVGMetadataElement: {
13913     prototype: SVGMetadataElement;
13914     new(): SVGMetadataElement;
13915 };
13916
13917 /** Corresponds to the <number> basic data type. */
13918 interface SVGNumber {
13919     value: number;
13920 }
13921
13922 declare var SVGNumber: {
13923     prototype: SVGNumber;
13924     new(): SVGNumber;
13925 };
13926
13927 /** The SVGNumberList defines a list of SVGNumber objects. */
13928 interface SVGNumberList {
13929     readonly length: number;
13930     readonly numberOfItems: number;
13931     appendItem(newItem: SVGNumber): SVGNumber;
13932     clear(): void;
13933     getItem(index: number): SVGNumber;
13934     initialize(newItem: SVGNumber): SVGNumber;
13935     insertItemBefore(newItem: SVGNumber, index: number): SVGNumber;
13936     removeItem(index: number): SVGNumber;
13937     replaceItem(newItem: SVGNumber, index: number): SVGNumber;
13938     [index: number]: SVGNumber;
13939 }
13940
13941 declare var SVGNumberList: {
13942     prototype: SVGNumberList;
13943     new(): SVGNumberList;
13944 };
13945
13946 /** Corresponds to the <path> element. */
13947 interface SVGPathElement extends SVGGraphicsElement {
13948     /** @deprecated */
13949     readonly pathSegList: SVGPathSegList;
13950     /** @deprecated */
13951     createSVGPathSegArcAbs(x: number, y: number, r1: number, r2: number, angle: number, largeArcFlag: boolean, sweepFlag: boolean): SVGPathSegArcAbs;
13952     /** @deprecated */
13953     createSVGPathSegArcRel(x: number, y: number, r1: number, r2: number, angle: number, largeArcFlag: boolean, sweepFlag: boolean): SVGPathSegArcRel;
13954     /** @deprecated */
13955     createSVGPathSegClosePath(): SVGPathSegClosePath;
13956     /** @deprecated */
13957     createSVGPathSegCurvetoCubicAbs(x: number, y: number, x1: number, y1: number, x2: number, y2: number): SVGPathSegCurvetoCubicAbs;
13958     /** @deprecated */
13959     createSVGPathSegCurvetoCubicRel(x: number, y: number, x1: number, y1: number, x2: number, y2: number): SVGPathSegCurvetoCubicRel;
13960     /** @deprecated */
13961     createSVGPathSegCurvetoCubicSmoothAbs(x: number, y: number, x2: number, y2: number): SVGPathSegCurvetoCubicSmoothAbs;
13962     /** @deprecated */
13963     createSVGPathSegCurvetoCubicSmoothRel(x: number, y: number, x2: number, y2: number): SVGPathSegCurvetoCubicSmoothRel;
13964     /** @deprecated */
13965     createSVGPathSegCurvetoQuadraticAbs(x: number, y: number, x1: number, y1: number): SVGPathSegCurvetoQuadraticAbs;
13966     /** @deprecated */
13967     createSVGPathSegCurvetoQuadraticRel(x: number, y: number, x1: number, y1: number): SVGPathSegCurvetoQuadraticRel;
13968     /** @deprecated */
13969     createSVGPathSegCurvetoQuadraticSmoothAbs(x: number, y: number): SVGPathSegCurvetoQuadraticSmoothAbs;
13970     /** @deprecated */
13971     createSVGPathSegCurvetoQuadraticSmoothRel(x: number, y: number): SVGPathSegCurvetoQuadraticSmoothRel;
13972     /** @deprecated */
13973     createSVGPathSegLinetoAbs(x: number, y: number): SVGPathSegLinetoAbs;
13974     /** @deprecated */
13975     createSVGPathSegLinetoHorizontalAbs(x: number): SVGPathSegLinetoHorizontalAbs;
13976     /** @deprecated */
13977     createSVGPathSegLinetoHorizontalRel(x: number): SVGPathSegLinetoHorizontalRel;
13978     /** @deprecated */
13979     createSVGPathSegLinetoRel(x: number, y: number): SVGPathSegLinetoRel;
13980     /** @deprecated */
13981     createSVGPathSegLinetoVerticalAbs(y: number): SVGPathSegLinetoVerticalAbs;
13982     /** @deprecated */
13983     createSVGPathSegLinetoVerticalRel(y: number): SVGPathSegLinetoVerticalRel;
13984     /** @deprecated */
13985     createSVGPathSegMovetoAbs(x: number, y: number): SVGPathSegMovetoAbs;
13986     /** @deprecated */
13987     createSVGPathSegMovetoRel(x: number, y: number): SVGPathSegMovetoRel;
13988     /** @deprecated */
13989     getPathSegAtLength(distance: number): number;
13990     getPointAtLength(distance: number): SVGPoint;
13991     getTotalLength(): number;
13992     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGPathElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13993     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13994     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGPathElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13995     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13996 }
13997
13998 declare var SVGPathElement: {
13999     prototype: SVGPathElement;
14000     new(): SVGPathElement;
14001 };
14002
14003 interface SVGPathSeg {
14004     readonly pathSegType: number;
14005     readonly pathSegTypeAsLetter: string;
14006     readonly PATHSEG_ARC_ABS: number;
14007     readonly PATHSEG_ARC_REL: number;
14008     readonly PATHSEG_CLOSEPATH: number;
14009     readonly PATHSEG_CURVETO_CUBIC_ABS: number;
14010     readonly PATHSEG_CURVETO_CUBIC_REL: number;
14011     readonly PATHSEG_CURVETO_CUBIC_SMOOTH_ABS: number;
14012     readonly PATHSEG_CURVETO_CUBIC_SMOOTH_REL: number;
14013     readonly PATHSEG_CURVETO_QUADRATIC_ABS: number;
14014     readonly PATHSEG_CURVETO_QUADRATIC_REL: number;
14015     readonly PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS: number;
14016     readonly PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL: number;
14017     readonly PATHSEG_LINETO_ABS: number;
14018     readonly PATHSEG_LINETO_HORIZONTAL_ABS: number;
14019     readonly PATHSEG_LINETO_HORIZONTAL_REL: number;
14020     readonly PATHSEG_LINETO_REL: number;
14021     readonly PATHSEG_LINETO_VERTICAL_ABS: number;
14022     readonly PATHSEG_LINETO_VERTICAL_REL: number;
14023     readonly PATHSEG_MOVETO_ABS: number;
14024     readonly PATHSEG_MOVETO_REL: number;
14025     readonly PATHSEG_UNKNOWN: number;
14026 }
14027
14028 declare var SVGPathSeg: {
14029     prototype: SVGPathSeg;
14030     new(): SVGPathSeg;
14031     readonly PATHSEG_ARC_ABS: number;
14032     readonly PATHSEG_ARC_REL: number;
14033     readonly PATHSEG_CLOSEPATH: number;
14034     readonly PATHSEG_CURVETO_CUBIC_ABS: number;
14035     readonly PATHSEG_CURVETO_CUBIC_REL: number;
14036     readonly PATHSEG_CURVETO_CUBIC_SMOOTH_ABS: number;
14037     readonly PATHSEG_CURVETO_CUBIC_SMOOTH_REL: number;
14038     readonly PATHSEG_CURVETO_QUADRATIC_ABS: number;
14039     readonly PATHSEG_CURVETO_QUADRATIC_REL: number;
14040     readonly PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS: number;
14041     readonly PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL: number;
14042     readonly PATHSEG_LINETO_ABS: number;
14043     readonly PATHSEG_LINETO_HORIZONTAL_ABS: number;
14044     readonly PATHSEG_LINETO_HORIZONTAL_REL: number;
14045     readonly PATHSEG_LINETO_REL: number;
14046     readonly PATHSEG_LINETO_VERTICAL_ABS: number;
14047     readonly PATHSEG_LINETO_VERTICAL_REL: number;
14048     readonly PATHSEG_MOVETO_ABS: number;
14049     readonly PATHSEG_MOVETO_REL: number;
14050     readonly PATHSEG_UNKNOWN: number;
14051 };
14052
14053 interface SVGPathSegArcAbs extends SVGPathSeg {
14054     angle: number;
14055     largeArcFlag: boolean;
14056     r1: number;
14057     r2: number;
14058     sweepFlag: boolean;
14059     x: number;
14060     y: number;
14061 }
14062
14063 declare var SVGPathSegArcAbs: {
14064     prototype: SVGPathSegArcAbs;
14065     new(): SVGPathSegArcAbs;
14066 };
14067
14068 interface SVGPathSegArcRel extends SVGPathSeg {
14069     angle: number;
14070     largeArcFlag: boolean;
14071     r1: number;
14072     r2: number;
14073     sweepFlag: boolean;
14074     x: number;
14075     y: number;
14076 }
14077
14078 declare var SVGPathSegArcRel: {
14079     prototype: SVGPathSegArcRel;
14080     new(): SVGPathSegArcRel;
14081 };
14082
14083 interface SVGPathSegClosePath extends SVGPathSeg {
14084 }
14085
14086 declare var SVGPathSegClosePath: {
14087     prototype: SVGPathSegClosePath;
14088     new(): SVGPathSegClosePath;
14089 };
14090
14091 interface SVGPathSegCurvetoCubicAbs extends SVGPathSeg {
14092     x: number;
14093     x1: number;
14094     x2: number;
14095     y: number;
14096     y1: number;
14097     y2: number;
14098 }
14099
14100 declare var SVGPathSegCurvetoCubicAbs: {
14101     prototype: SVGPathSegCurvetoCubicAbs;
14102     new(): SVGPathSegCurvetoCubicAbs;
14103 };
14104
14105 interface SVGPathSegCurvetoCubicRel extends SVGPathSeg {
14106     x: number;
14107     x1: number;
14108     x2: number;
14109     y: number;
14110     y1: number;
14111     y2: number;
14112 }
14113
14114 declare var SVGPathSegCurvetoCubicRel: {
14115     prototype: SVGPathSegCurvetoCubicRel;
14116     new(): SVGPathSegCurvetoCubicRel;
14117 };
14118
14119 interface SVGPathSegCurvetoCubicSmoothAbs extends SVGPathSeg {
14120     x: number;
14121     x2: number;
14122     y: number;
14123     y2: number;
14124 }
14125
14126 declare var SVGPathSegCurvetoCubicSmoothAbs: {
14127     prototype: SVGPathSegCurvetoCubicSmoothAbs;
14128     new(): SVGPathSegCurvetoCubicSmoothAbs;
14129 };
14130
14131 interface SVGPathSegCurvetoCubicSmoothRel extends SVGPathSeg {
14132     x: number;
14133     x2: number;
14134     y: number;
14135     y2: number;
14136 }
14137
14138 declare var SVGPathSegCurvetoCubicSmoothRel: {
14139     prototype: SVGPathSegCurvetoCubicSmoothRel;
14140     new(): SVGPathSegCurvetoCubicSmoothRel;
14141 };
14142
14143 interface SVGPathSegCurvetoQuadraticAbs extends SVGPathSeg {
14144     x: number;
14145     x1: number;
14146     y: number;
14147     y1: number;
14148 }
14149
14150 declare var SVGPathSegCurvetoQuadraticAbs: {
14151     prototype: SVGPathSegCurvetoQuadraticAbs;
14152     new(): SVGPathSegCurvetoQuadraticAbs;
14153 };
14154
14155 interface SVGPathSegCurvetoQuadraticRel extends SVGPathSeg {
14156     x: number;
14157     x1: number;
14158     y: number;
14159     y1: number;
14160 }
14161
14162 declare var SVGPathSegCurvetoQuadraticRel: {
14163     prototype: SVGPathSegCurvetoQuadraticRel;
14164     new(): SVGPathSegCurvetoQuadraticRel;
14165 };
14166
14167 interface SVGPathSegCurvetoQuadraticSmoothAbs extends SVGPathSeg {
14168     x: number;
14169     y: number;
14170 }
14171
14172 declare var SVGPathSegCurvetoQuadraticSmoothAbs: {
14173     prototype: SVGPathSegCurvetoQuadraticSmoothAbs;
14174     new(): SVGPathSegCurvetoQuadraticSmoothAbs;
14175 };
14176
14177 interface SVGPathSegCurvetoQuadraticSmoothRel extends SVGPathSeg {
14178     x: number;
14179     y: number;
14180 }
14181
14182 declare var SVGPathSegCurvetoQuadraticSmoothRel: {
14183     prototype: SVGPathSegCurvetoQuadraticSmoothRel;
14184     new(): SVGPathSegCurvetoQuadraticSmoothRel;
14185 };
14186
14187 interface SVGPathSegLinetoAbs extends SVGPathSeg {
14188     x: number;
14189     y: number;
14190 }
14191
14192 declare var SVGPathSegLinetoAbs: {
14193     prototype: SVGPathSegLinetoAbs;
14194     new(): SVGPathSegLinetoAbs;
14195 };
14196
14197 interface SVGPathSegLinetoHorizontalAbs extends SVGPathSeg {
14198     x: number;
14199 }
14200
14201 declare var SVGPathSegLinetoHorizontalAbs: {
14202     prototype: SVGPathSegLinetoHorizontalAbs;
14203     new(): SVGPathSegLinetoHorizontalAbs;
14204 };
14205
14206 interface SVGPathSegLinetoHorizontalRel extends SVGPathSeg {
14207     x: number;
14208 }
14209
14210 declare var SVGPathSegLinetoHorizontalRel: {
14211     prototype: SVGPathSegLinetoHorizontalRel;
14212     new(): SVGPathSegLinetoHorizontalRel;
14213 };
14214
14215 interface SVGPathSegLinetoRel extends SVGPathSeg {
14216     x: number;
14217     y: number;
14218 }
14219
14220 declare var SVGPathSegLinetoRel: {
14221     prototype: SVGPathSegLinetoRel;
14222     new(): SVGPathSegLinetoRel;
14223 };
14224
14225 interface SVGPathSegLinetoVerticalAbs extends SVGPathSeg {
14226     y: number;
14227 }
14228
14229 declare var SVGPathSegLinetoVerticalAbs: {
14230     prototype: SVGPathSegLinetoVerticalAbs;
14231     new(): SVGPathSegLinetoVerticalAbs;
14232 };
14233
14234 interface SVGPathSegLinetoVerticalRel extends SVGPathSeg {
14235     y: number;
14236 }
14237
14238 declare var SVGPathSegLinetoVerticalRel: {
14239     prototype: SVGPathSegLinetoVerticalRel;
14240     new(): SVGPathSegLinetoVerticalRel;
14241 };
14242
14243 interface SVGPathSegList {
14244     readonly numberOfItems: number;
14245     appendItem(newItem: SVGPathSeg): SVGPathSeg;
14246     clear(): void;
14247     getItem(index: number): SVGPathSeg;
14248     initialize(newItem: SVGPathSeg): SVGPathSeg;
14249     insertItemBefore(newItem: SVGPathSeg, index: number): SVGPathSeg;
14250     removeItem(index: number): SVGPathSeg;
14251     replaceItem(newItem: SVGPathSeg, index: number): SVGPathSeg;
14252 }
14253
14254 declare var SVGPathSegList: {
14255     prototype: SVGPathSegList;
14256     new(): SVGPathSegList;
14257 };
14258
14259 interface SVGPathSegMovetoAbs extends SVGPathSeg {
14260     x: number;
14261     y: number;
14262 }
14263
14264 declare var SVGPathSegMovetoAbs: {
14265     prototype: SVGPathSegMovetoAbs;
14266     new(): SVGPathSegMovetoAbs;
14267 };
14268
14269 interface SVGPathSegMovetoRel extends SVGPathSeg {
14270     x: number;
14271     y: number;
14272 }
14273
14274 declare var SVGPathSegMovetoRel: {
14275     prototype: SVGPathSegMovetoRel;
14276     new(): SVGPathSegMovetoRel;
14277 };
14278
14279 /** Corresponds to the <pattern> element. */
14280 interface SVGPatternElement extends SVGElement, SVGFitToViewBox, SVGURIReference {
14281     readonly height: SVGAnimatedLength;
14282     readonly patternContentUnits: SVGAnimatedEnumeration;
14283     readonly patternTransform: SVGAnimatedTransformList;
14284     readonly patternUnits: SVGAnimatedEnumeration;
14285     readonly width: SVGAnimatedLength;
14286     readonly x: SVGAnimatedLength;
14287     readonly y: SVGAnimatedLength;
14288     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGPatternElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14289     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14290     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGPatternElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14291     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14292 }
14293
14294 declare var SVGPatternElement: {
14295     prototype: SVGPatternElement;
14296     new(): SVGPatternElement;
14297 };
14298
14299 interface SVGPointList {
14300     readonly length: number;
14301     readonly numberOfItems: number;
14302     appendItem(newItem: DOMPoint): DOMPoint;
14303     clear(): void;
14304     getItem(index: number): DOMPoint;
14305     initialize(newItem: DOMPoint): DOMPoint;
14306     insertItemBefore(newItem: DOMPoint, index: number): DOMPoint;
14307     removeItem(index: number): DOMPoint;
14308     replaceItem(newItem: DOMPoint, index: number): DOMPoint;
14309     [index: number]: DOMPoint;
14310 }
14311
14312 declare var SVGPointList: {
14313     prototype: SVGPointList;
14314     new(): SVGPointList;
14315 };
14316
14317 /** Provides access to the properties of <polygon> elements, as well as methods to manipulate them. */
14318 interface SVGPolygonElement extends SVGGeometryElement, SVGAnimatedPoints {
14319     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGPolygonElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14320     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14321     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGPolygonElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14322     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14323 }
14324
14325 declare var SVGPolygonElement: {
14326     prototype: SVGPolygonElement;
14327     new(): SVGPolygonElement;
14328 };
14329
14330 /** Provides access to the properties of <polyline> elements, as well as methods to manipulate them. */
14331 interface SVGPolylineElement extends SVGGeometryElement, SVGAnimatedPoints {
14332     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGPolylineElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14333     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14334     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGPolylineElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14335     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14336 }
14337
14338 declare var SVGPolylineElement: {
14339     prototype: SVGPolylineElement;
14340     new(): SVGPolylineElement;
14341 };
14342
14343 /** Corresponds to the preserveAspectRatio attribute, which is available for some of SVG's elements. */
14344 interface SVGPreserveAspectRatio {
14345     align: number;
14346     meetOrSlice: number;
14347     readonly SVG_MEETORSLICE_MEET: number;
14348     readonly SVG_MEETORSLICE_SLICE: number;
14349     readonly SVG_MEETORSLICE_UNKNOWN: number;
14350     readonly SVG_PRESERVEASPECTRATIO_NONE: number;
14351     readonly SVG_PRESERVEASPECTRATIO_UNKNOWN: number;
14352     readonly SVG_PRESERVEASPECTRATIO_XMAXYMAX: number;
14353     readonly SVG_PRESERVEASPECTRATIO_XMAXYMID: number;
14354     readonly SVG_PRESERVEASPECTRATIO_XMAXYMIN: number;
14355     readonly SVG_PRESERVEASPECTRATIO_XMIDYMAX: number;
14356     readonly SVG_PRESERVEASPECTRATIO_XMIDYMID: number;
14357     readonly SVG_PRESERVEASPECTRATIO_XMIDYMIN: number;
14358     readonly SVG_PRESERVEASPECTRATIO_XMINYMAX: number;
14359     readonly SVG_PRESERVEASPECTRATIO_XMINYMID: number;
14360     readonly SVG_PRESERVEASPECTRATIO_XMINYMIN: number;
14361 }
14362
14363 declare var SVGPreserveAspectRatio: {
14364     prototype: SVGPreserveAspectRatio;
14365     new(): SVGPreserveAspectRatio;
14366     readonly SVG_MEETORSLICE_MEET: number;
14367     readonly SVG_MEETORSLICE_SLICE: number;
14368     readonly SVG_MEETORSLICE_UNKNOWN: number;
14369     readonly SVG_PRESERVEASPECTRATIO_NONE: number;
14370     readonly SVG_PRESERVEASPECTRATIO_UNKNOWN: number;
14371     readonly SVG_PRESERVEASPECTRATIO_XMAXYMAX: number;
14372     readonly SVG_PRESERVEASPECTRATIO_XMAXYMID: number;
14373     readonly SVG_PRESERVEASPECTRATIO_XMAXYMIN: number;
14374     readonly SVG_PRESERVEASPECTRATIO_XMIDYMAX: number;
14375     readonly SVG_PRESERVEASPECTRATIO_XMIDYMID: number;
14376     readonly SVG_PRESERVEASPECTRATIO_XMIDYMIN: number;
14377     readonly SVG_PRESERVEASPECTRATIO_XMINYMAX: number;
14378     readonly SVG_PRESERVEASPECTRATIO_XMINYMID: number;
14379     readonly SVG_PRESERVEASPECTRATIO_XMINYMIN: number;
14380 };
14381
14382 /** Corresponds to the <RadialGradient> element. */
14383 interface SVGRadialGradientElement extends SVGGradientElement {
14384     readonly cx: SVGAnimatedLength;
14385     readonly cy: SVGAnimatedLength;
14386     readonly fr: SVGAnimatedLength;
14387     readonly fx: SVGAnimatedLength;
14388     readonly fy: SVGAnimatedLength;
14389     readonly r: SVGAnimatedLength;
14390     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGRadialGradientElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14391     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14392     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGRadialGradientElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14393     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14394 }
14395
14396 declare var SVGRadialGradientElement: {
14397     prototype: SVGRadialGradientElement;
14398     new(): SVGRadialGradientElement;
14399 };
14400
14401 /** Provides access to the properties of <rect> elements, as well as methods to manipulate them. */
14402 interface SVGRectElement extends SVGGeometryElement {
14403     readonly height: SVGAnimatedLength;
14404     readonly rx: SVGAnimatedLength;
14405     readonly ry: SVGAnimatedLength;
14406     readonly width: SVGAnimatedLength;
14407     readonly x: SVGAnimatedLength;
14408     readonly y: SVGAnimatedLength;
14409     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGRectElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14410     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14411     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGRectElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14412     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14413 }
14414
14415 declare var SVGRectElement: {
14416     prototype: SVGRectElement;
14417     new(): SVGRectElement;
14418 };
14419
14420 interface SVGSVGElementEventMap extends SVGElementEventMap {
14421     "SVGUnload": Event;
14422     "SVGZoom": SVGZoomEvent;
14423 }
14424
14425 /** Provides access to the properties of <svg> elements, as well as methods to manipulate them. This interface contains also various miscellaneous commonly-used utility methods, such as matrix operations and the ability to control the time of redraw on visual rendering devices. */
14426 interface SVGSVGElement extends SVGGraphicsElement, DocumentEvent, SVGFitToViewBox, SVGZoomAndPan {
14427     /** @deprecated */
14428     contentScriptType: string;
14429     /** @deprecated */
14430     contentStyleType: string;
14431     currentScale: number;
14432     readonly currentTranslate: SVGPoint;
14433     readonly height: SVGAnimatedLength;
14434     onunload: ((this: SVGSVGElement, ev: Event) => any) | null;
14435     onzoom: ((this: SVGSVGElement, ev: SVGZoomEvent) => any) | null;
14436     /** @deprecated */
14437     readonly pixelUnitToMillimeterX: number;
14438     /** @deprecated */
14439     readonly pixelUnitToMillimeterY: number;
14440     /** @deprecated */
14441     readonly screenPixelToMillimeterX: number;
14442     /** @deprecated */
14443     readonly screenPixelToMillimeterY: number;
14444     /** @deprecated */
14445     readonly viewport: SVGRect;
14446     readonly width: SVGAnimatedLength;
14447     readonly x: SVGAnimatedLength;
14448     readonly y: SVGAnimatedLength;
14449     animationsPaused(): boolean;
14450     checkEnclosure(element: SVGElement, rect: SVGRect): boolean;
14451     checkIntersection(element: SVGElement, rect: SVGRect): boolean;
14452     createSVGAngle(): SVGAngle;
14453     createSVGLength(): SVGLength;
14454     createSVGMatrix(): SVGMatrix;
14455     createSVGNumber(): SVGNumber;
14456     createSVGPoint(): SVGPoint;
14457     createSVGRect(): SVGRect;
14458     createSVGTransform(): SVGTransform;
14459     createSVGTransformFromMatrix(matrix: SVGMatrix): SVGTransform;
14460     deselectAll(): void;
14461     /** @deprecated */
14462     forceRedraw(): void;
14463     getComputedStyle(elt: Element, pseudoElt?: string | null): CSSStyleDeclaration;
14464     getCurrentTime(): number;
14465     getElementById(elementId: string): Element;
14466     getEnclosureList(rect: SVGRect, referenceElement: SVGElement | null): NodeListOf<SVGCircleElement | SVGEllipseElement | SVGImageElement | SVGLineElement | SVGPathElement | SVGPolygonElement | SVGPolylineElement | SVGRectElement | SVGTextElement | SVGUseElement>;
14467     getIntersectionList(rect: SVGRect, referenceElement: SVGElement | null): NodeListOf<SVGCircleElement | SVGEllipseElement | SVGImageElement | SVGLineElement | SVGPathElement | SVGPolygonElement | SVGPolylineElement | SVGRectElement | SVGTextElement | SVGUseElement>;
14468     pauseAnimations(): void;
14469     setCurrentTime(seconds: number): void;
14470     /** @deprecated */
14471     suspendRedraw(maxWaitMilliseconds: number): number;
14472     unpauseAnimations(): void;
14473     /** @deprecated */
14474     unsuspendRedraw(suspendHandleID: number): void;
14475     /** @deprecated */
14476     unsuspendRedrawAll(): void;
14477     addEventListener<K extends keyof SVGSVGElementEventMap>(type: K, listener: (this: SVGSVGElement, ev: SVGSVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14478     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14479     removeEventListener<K extends keyof SVGSVGElementEventMap>(type: K, listener: (this: SVGSVGElement, ev: SVGSVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14480     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14481 }
14482
14483 declare var SVGSVGElement: {
14484     prototype: SVGSVGElement;
14485     new(): SVGSVGElement;
14486     readonly SVG_ZOOMANDPAN_DISABLE: number;
14487     readonly SVG_ZOOMANDPAN_MAGNIFY: number;
14488     readonly SVG_ZOOMANDPAN_UNKNOWN: number;
14489 };
14490
14491 /** Corresponds to the SVG <script> element. */
14492 interface SVGScriptElement extends SVGElement, SVGURIReference {
14493     type: string;
14494     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGScriptElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14495     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14496     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGScriptElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14497     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14498 }
14499
14500 declare var SVGScriptElement: {
14501     prototype: SVGScriptElement;
14502     new(): SVGScriptElement;
14503 };
14504
14505 /** Corresponds to the <stop> element. */
14506 interface SVGStopElement extends SVGElement {
14507     readonly offset: SVGAnimatedNumber;
14508     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGStopElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14509     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14510     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGStopElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14511     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14512 }
14513
14514 declare var SVGStopElement: {
14515     prototype: SVGStopElement;
14516     new(): SVGStopElement;
14517 };
14518
14519 /** The SVGStringList defines a list of DOMString objects. */
14520 interface SVGStringList {
14521     readonly length: number;
14522     readonly numberOfItems: number;
14523     appendItem(newItem: string): string;
14524     clear(): void;
14525     getItem(index: number): string;
14526     initialize(newItem: string): string;
14527     insertItemBefore(newItem: string, index: number): string;
14528     removeItem(index: number): string;
14529     replaceItem(newItem: string, index: number): string;
14530     [index: number]: string;
14531 }
14532
14533 declare var SVGStringList: {
14534     prototype: SVGStringList;
14535     new(): SVGStringList;
14536 };
14537
14538 /** Corresponds to the SVG <style> element. */
14539 interface SVGStyleElement extends SVGElement, LinkStyle {
14540     disabled: boolean;
14541     media: string;
14542     title: string;
14543     type: string;
14544     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGStyleElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14545     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14546     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGStyleElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14547     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14548 }
14549
14550 declare var SVGStyleElement: {
14551     prototype: SVGStyleElement;
14552     new(): SVGStyleElement;
14553 };
14554
14555 /** Corresponds to the <switch> element. */
14556 interface SVGSwitchElement extends SVGGraphicsElement {
14557     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGSwitchElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14558     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14559     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGSwitchElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14560     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14561 }
14562
14563 declare var SVGSwitchElement: {
14564     prototype: SVGSwitchElement;
14565     new(): SVGSwitchElement;
14566 };
14567
14568 /** Corresponds to the <symbol> element. */
14569 interface SVGSymbolElement extends SVGElement, SVGFitToViewBox {
14570     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGSymbolElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14571     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14572     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGSymbolElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14573     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14574 }
14575
14576 declare var SVGSymbolElement: {
14577     prototype: SVGSymbolElement;
14578     new(): SVGSymbolElement;
14579 };
14580
14581 /** A <tspan> element. */
14582 interface SVGTSpanElement extends SVGTextPositioningElement {
14583     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTSpanElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14584     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14585     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTSpanElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14586     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14587 }
14588
14589 declare var SVGTSpanElement: {
14590     prototype: SVGTSpanElement;
14591     new(): SVGTSpanElement;
14592 };
14593
14594 interface SVGTests {
14595     readonly requiredExtensions: SVGStringList;
14596     readonly systemLanguage: SVGStringList;
14597 }
14598
14599 /** Implemented by elements that support rendering child text content. It is inherited by various text-related interfaces, such as SVGTextElement, SVGTSpanElement, SVGTRefElement, SVGAltGlyphElement and SVGTextPathElement. */
14600 interface SVGTextContentElement extends SVGGraphicsElement {
14601     readonly lengthAdjust: SVGAnimatedEnumeration;
14602     readonly textLength: SVGAnimatedLength;
14603     getCharNumAtPosition(point?: DOMPointInit): number;
14604     getComputedTextLength(): number;
14605     getEndPositionOfChar(charnum: number): DOMPoint;
14606     getExtentOfChar(charnum: number): DOMRect;
14607     getNumberOfChars(): number;
14608     getRotationOfChar(charnum: number): number;
14609     getStartPositionOfChar(charnum: number): DOMPoint;
14610     getSubStringLength(charnum: number, nchars: number): number;
14611     selectSubString(charnum: number, nchars: number): void;
14612     readonly LENGTHADJUST_SPACING: number;
14613     readonly LENGTHADJUST_SPACINGANDGLYPHS: number;
14614     readonly LENGTHADJUST_UNKNOWN: number;
14615     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTextContentElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14616     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14617     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTextContentElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14618     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14619 }
14620
14621 declare var SVGTextContentElement: {
14622     prototype: SVGTextContentElement;
14623     new(): SVGTextContentElement;
14624     readonly LENGTHADJUST_SPACING: number;
14625     readonly LENGTHADJUST_SPACINGANDGLYPHS: number;
14626     readonly LENGTHADJUST_UNKNOWN: number;
14627 };
14628
14629 /** Corresponds to the <text> elements. */
14630 interface SVGTextElement extends SVGTextPositioningElement {
14631     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTextElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14632     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14633     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTextElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14634     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14635 }
14636
14637 declare var SVGTextElement: {
14638     prototype: SVGTextElement;
14639     new(): SVGTextElement;
14640 };
14641
14642 /** Corresponds to the <textPath> element. */
14643 interface SVGTextPathElement extends SVGTextContentElement, SVGURIReference {
14644     readonly method: SVGAnimatedEnumeration;
14645     readonly spacing: SVGAnimatedEnumeration;
14646     readonly startOffset: SVGAnimatedLength;
14647     readonly TEXTPATH_METHODTYPE_ALIGN: number;
14648     readonly TEXTPATH_METHODTYPE_STRETCH: number;
14649     readonly TEXTPATH_METHODTYPE_UNKNOWN: number;
14650     readonly TEXTPATH_SPACINGTYPE_AUTO: number;
14651     readonly TEXTPATH_SPACINGTYPE_EXACT: number;
14652     readonly TEXTPATH_SPACINGTYPE_UNKNOWN: number;
14653     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTextPathElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14654     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14655     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTextPathElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14656     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14657 }
14658
14659 declare var SVGTextPathElement: {
14660     prototype: SVGTextPathElement;
14661     new(): SVGTextPathElement;
14662     readonly TEXTPATH_METHODTYPE_ALIGN: number;
14663     readonly TEXTPATH_METHODTYPE_STRETCH: number;
14664     readonly TEXTPATH_METHODTYPE_UNKNOWN: number;
14665     readonly TEXTPATH_SPACINGTYPE_AUTO: number;
14666     readonly TEXTPATH_SPACINGTYPE_EXACT: number;
14667     readonly TEXTPATH_SPACINGTYPE_UNKNOWN: number;
14668 };
14669
14670 /** Implemented by elements that support attributes that position individual text glyphs. It is inherited by SVGTextElement, SVGTSpanElement, SVGTRefElement and SVGAltGlyphElement. */
14671 interface SVGTextPositioningElement extends SVGTextContentElement {
14672     readonly dx: SVGAnimatedLengthList;
14673     readonly dy: SVGAnimatedLengthList;
14674     readonly rotate: SVGAnimatedNumberList;
14675     readonly x: SVGAnimatedLengthList;
14676     readonly y: SVGAnimatedLengthList;
14677     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTextPositioningElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14678     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14679     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTextPositioningElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14680     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14681 }
14682
14683 declare var SVGTextPositioningElement: {
14684     prototype: SVGTextPositioningElement;
14685     new(): SVGTextPositioningElement;
14686 };
14687
14688 /** Corresponds to the <title> element. */
14689 interface SVGTitleElement extends SVGElement {
14690     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTitleElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14691     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14692     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTitleElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14693     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14694 }
14695
14696 declare var SVGTitleElement: {
14697     prototype: SVGTitleElement;
14698     new(): SVGTitleElement;
14699 };
14700
14701 /** SVGTransform is the interface for one of the component transformations within an SVGTransformList; thus, an SVGTransform object corresponds to a single component (e.g., scale(…) or matrix(…)) within a transform attribute. */
14702 interface SVGTransform {
14703     readonly angle: number;
14704     readonly matrix: SVGMatrix;
14705     readonly type: number;
14706     setMatrix(matrix: SVGMatrix): void;
14707     setRotate(angle: number, cx: number, cy: number): void;
14708     setScale(sx: number, sy: number): void;
14709     setSkewX(angle: number): void;
14710     setSkewY(angle: number): void;
14711     setTranslate(tx: number, ty: number): void;
14712     readonly SVG_TRANSFORM_MATRIX: number;
14713     readonly SVG_TRANSFORM_ROTATE: number;
14714     readonly SVG_TRANSFORM_SCALE: number;
14715     readonly SVG_TRANSFORM_SKEWX: number;
14716     readonly SVG_TRANSFORM_SKEWY: number;
14717     readonly SVG_TRANSFORM_TRANSLATE: number;
14718     readonly SVG_TRANSFORM_UNKNOWN: number;
14719 }
14720
14721 declare var SVGTransform: {
14722     prototype: SVGTransform;
14723     new(): SVGTransform;
14724     readonly SVG_TRANSFORM_MATRIX: number;
14725     readonly SVG_TRANSFORM_ROTATE: number;
14726     readonly SVG_TRANSFORM_SCALE: number;
14727     readonly SVG_TRANSFORM_SKEWX: number;
14728     readonly SVG_TRANSFORM_SKEWY: number;
14729     readonly SVG_TRANSFORM_TRANSLATE: number;
14730     readonly SVG_TRANSFORM_UNKNOWN: number;
14731 };
14732
14733 /** The SVGTransformList defines a list of SVGTransform objects. */
14734 interface SVGTransformList {
14735     readonly numberOfItems: number;
14736     appendItem(newItem: SVGTransform): SVGTransform;
14737     clear(): void;
14738     consolidate(): SVGTransform;
14739     createSVGTransformFromMatrix(matrix: SVGMatrix): SVGTransform;
14740     getItem(index: number): SVGTransform;
14741     initialize(newItem: SVGTransform): SVGTransform;
14742     insertItemBefore(newItem: SVGTransform, index: number): SVGTransform;
14743     removeItem(index: number): SVGTransform;
14744     replaceItem(newItem: SVGTransform, index: number): SVGTransform;
14745 }
14746
14747 declare var SVGTransformList: {
14748     prototype: SVGTransformList;
14749     new(): SVGTransformList;
14750 };
14751
14752 interface SVGURIReference {
14753     readonly href: SVGAnimatedString;
14754 }
14755
14756 /** A commonly used set of constants used for reflecting gradientUnits, patternContentUnits and other similar attributes. */
14757 interface SVGUnitTypes {
14758     readonly SVG_UNIT_TYPE_OBJECTBOUNDINGBOX: number;
14759     readonly SVG_UNIT_TYPE_UNKNOWN: number;
14760     readonly SVG_UNIT_TYPE_USERSPACEONUSE: number;
14761 }
14762
14763 declare var SVGUnitTypes: {
14764     prototype: SVGUnitTypes;
14765     new(): SVGUnitTypes;
14766     readonly SVG_UNIT_TYPE_OBJECTBOUNDINGBOX: number;
14767     readonly SVG_UNIT_TYPE_UNKNOWN: number;
14768     readonly SVG_UNIT_TYPE_USERSPACEONUSE: number;
14769 };
14770
14771 /** Corresponds to the <use> element. */
14772 interface SVGUseElement extends SVGGraphicsElement, SVGURIReference {
14773     readonly animatedInstanceRoot: SVGElementInstance | null;
14774     readonly height: SVGAnimatedLength;
14775     readonly instanceRoot: SVGElementInstance | null;
14776     readonly width: SVGAnimatedLength;
14777     readonly x: SVGAnimatedLength;
14778     readonly y: SVGAnimatedLength;
14779     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGUseElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14780     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14781     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGUseElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14782     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14783 }
14784
14785 declare var SVGUseElement: {
14786     prototype: SVGUseElement;
14787     new(): SVGUseElement;
14788 };
14789
14790 /** Provides access to the properties of <view> elements, as well as methods to manipulate them. */
14791 interface SVGViewElement extends SVGElement, SVGFitToViewBox, SVGZoomAndPan {
14792     /** @deprecated */
14793     readonly viewTarget: SVGStringList;
14794     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGViewElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14795     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14796     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGViewElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14797     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14798 }
14799
14800 declare var SVGViewElement: {
14801     prototype: SVGViewElement;
14802     new(): SVGViewElement;
14803     readonly SVG_ZOOMANDPAN_DISABLE: number;
14804     readonly SVG_ZOOMANDPAN_MAGNIFY: number;
14805     readonly SVG_ZOOMANDPAN_UNKNOWN: number;
14806 };
14807
14808 /** Used to reflect the zoomAndPan attribute, and is mixed in to other interfaces for elements that support this attribute. */
14809 interface SVGZoomAndPan {
14810     readonly zoomAndPan: number;
14811 }
14812
14813 declare var SVGZoomAndPan: {
14814     readonly SVG_ZOOMANDPAN_DISABLE: number;
14815     readonly SVG_ZOOMANDPAN_MAGNIFY: number;
14816     readonly SVG_ZOOMANDPAN_UNKNOWN: number;
14817 };
14818
14819 interface SVGZoomEvent extends UIEvent {
14820     readonly newScale: number;
14821     readonly newTranslate: SVGPoint;
14822     readonly previousScale: number;
14823     readonly previousTranslate: SVGPoint;
14824     readonly zoomRectScreen: SVGRect;
14825 }
14826
14827 declare var SVGZoomEvent: {
14828     prototype: SVGZoomEvent;
14829     new(): SVGZoomEvent;
14830 };
14831
14832 interface ScopedCredential {
14833     readonly id: ArrayBuffer;
14834     readonly type: ScopedCredentialType;
14835 }
14836
14837 declare var ScopedCredential: {
14838     prototype: ScopedCredential;
14839     new(): ScopedCredential;
14840 };
14841
14842 interface ScopedCredentialInfo {
14843     readonly credential: ScopedCredential;
14844     readonly publicKey: CryptoKey;
14845 }
14846
14847 declare var ScopedCredentialInfo: {
14848     prototype: ScopedCredentialInfo;
14849     new(): ScopedCredentialInfo;
14850 };
14851
14852 /** A screen, usually the one on which the current window is being rendered, and is obtained using window.screen. */
14853 interface Screen {
14854     readonly availHeight: number;
14855     readonly availWidth: number;
14856     readonly colorDepth: number;
14857     readonly height: number;
14858     readonly orientation: ScreenOrientation;
14859     readonly pixelDepth: number;
14860     readonly width: number;
14861 }
14862
14863 declare var Screen: {
14864     prototype: Screen;
14865     new(): Screen;
14866 };
14867
14868 interface ScreenOrientationEventMap {
14869     "change": Event;
14870 }
14871
14872 interface ScreenOrientation extends EventTarget {
14873     readonly angle: number;
14874     onchange: ((this: ScreenOrientation, ev: Event) => any) | null;
14875     readonly type: OrientationType;
14876     lock(orientation: OrientationLockType): Promise<void>;
14877     unlock(): void;
14878     addEventListener<K extends keyof ScreenOrientationEventMap>(type: K, listener: (this: ScreenOrientation, ev: ScreenOrientationEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14879     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14880     removeEventListener<K extends keyof ScreenOrientationEventMap>(type: K, listener: (this: ScreenOrientation, ev: ScreenOrientationEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14881     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14882 }
14883
14884 declare var ScreenOrientation: {
14885     prototype: ScreenOrientation;
14886     new(): ScreenOrientation;
14887 };
14888
14889 interface ScriptProcessorNodeEventMap {
14890     "audioprocess": AudioProcessingEvent;
14891 }
14892
14893 /** Allows the generation, processing, or analyzing of audio using JavaScript.
14894  * @deprecated As of the August 29 2014 Web Audio API spec publication, this feature has been marked as deprecated, and was replaced by AudioWorklet (see AudioWorkletNode).
14895  */
14896 interface ScriptProcessorNode extends AudioNode {
14897     /** @deprecated */
14898     readonly bufferSize: number;
14899     /** @deprecated */
14900     onaudioprocess: ((this: ScriptProcessorNode, ev: AudioProcessingEvent) => any) | null;
14901     addEventListener<K extends keyof ScriptProcessorNodeEventMap>(type: K, listener: (this: ScriptProcessorNode, ev: ScriptProcessorNodeEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14902     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14903     removeEventListener<K extends keyof ScriptProcessorNodeEventMap>(type: K, listener: (this: ScriptProcessorNode, ev: ScriptProcessorNodeEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14904     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14905 }
14906
14907 declare var ScriptProcessorNode: {
14908     prototype: ScriptProcessorNode;
14909     new(): ScriptProcessorNode;
14910 };
14911
14912 /** Inherits from Event, and represents the event object of an event sent on a document or worker when its content security policy is violated. */
14913 interface SecurityPolicyViolationEvent extends Event {
14914     readonly blockedURI: string;
14915     readonly columnNumber: number;
14916     readonly documentURI: string;
14917     readonly effectiveDirective: string;
14918     readonly lineNumber: number;
14919     readonly originalPolicy: string;
14920     readonly referrer: string;
14921     readonly sourceFile: string;
14922     readonly statusCode: number;
14923     readonly violatedDirective: string;
14924 }
14925
14926 declare var SecurityPolicyViolationEvent: {
14927     prototype: SecurityPolicyViolationEvent;
14928     new(type: string, eventInitDict?: SecurityPolicyViolationEventInit): SecurityPolicyViolationEvent;
14929 };
14930
14931 /** A Selection object represents the range of text selected by the user or the current position of the caret. To obtain a Selection object for examination or modification, call Window.getSelection(). */
14932 interface Selection {
14933     readonly anchorNode: Node | null;
14934     readonly anchorOffset: number;
14935     readonly focusNode: Node | null;
14936     readonly focusOffset: number;
14937     readonly isCollapsed: boolean;
14938     readonly rangeCount: number;
14939     readonly type: string;
14940     addRange(range: Range): void;
14941     collapse(node: Node | null, offset?: number): void;
14942     collapseToEnd(): void;
14943     collapseToStart(): void;
14944     containsNode(node: Node, allowPartialContainment?: boolean): boolean;
14945     deleteFromDocument(): void;
14946     empty(): void;
14947     extend(node: Node, offset?: number): void;
14948     getRangeAt(index: number): Range;
14949     removeAllRanges(): void;
14950     removeRange(range: Range): void;
14951     selectAllChildren(node: Node): void;
14952     setBaseAndExtent(anchorNode: Node, anchorOffset: number, focusNode: Node, focusOffset: number): void;
14953     setPosition(node: Node | null, offset?: number): void;
14954     toString(): string;
14955 }
14956
14957 declare var Selection: {
14958     prototype: Selection;
14959     new(): Selection;
14960     toString(): string;
14961 };
14962
14963 interface ServiceUIFrameContext {
14964     getCachedFrameMessage(key: string): string;
14965     postFrameMessage(key: string, data: string): void;
14966 }
14967 declare var ServiceUIFrameContext: ServiceUIFrameContext;
14968
14969 interface ServiceWorkerEventMap extends AbstractWorkerEventMap {
14970     "statechange": Event;
14971 }
14972
14973 /** This ServiceWorker API interface provides a reference to a service worker. Multiple browsing contexts (e.g. pages, workers, etc.) can be associated with the same service worker, each through a unique ServiceWorker object. */
14974 interface ServiceWorker extends EventTarget, AbstractWorker {
14975     onstatechange: ((this: ServiceWorker, ev: Event) => any) | null;
14976     readonly scriptURL: string;
14977     readonly state: ServiceWorkerState;
14978     postMessage(message: any, transfer: Transferable[]): void;
14979     postMessage(message: any, options?: PostMessageOptions): void;
14980     addEventListener<K extends keyof ServiceWorkerEventMap>(type: K, listener: (this: ServiceWorker, ev: ServiceWorkerEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14981     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14982     removeEventListener<K extends keyof ServiceWorkerEventMap>(type: K, listener: (this: ServiceWorker, ev: ServiceWorkerEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14983     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14984 }
14985
14986 declare var ServiceWorker: {
14987     prototype: ServiceWorker;
14988     new(): ServiceWorker;
14989 };
14990
14991 interface ServiceWorkerContainerEventMap {
14992     "controllerchange": Event;
14993     "message": MessageEvent;
14994     "messageerror": MessageEvent;
14995 }
14996
14997 /** The ServiceWorkerContainer interface of the ServiceWorker API provides an object representing the service worker as an overall unit in the network ecosystem, including facilities to register, unregister and update service workers, and access the state of service workers and their registrations. */
14998 interface ServiceWorkerContainer extends EventTarget {
14999     readonly controller: ServiceWorker | null;
15000     oncontrollerchange: ((this: ServiceWorkerContainer, ev: Event) => any) | null;
15001     onmessage: ((this: ServiceWorkerContainer, ev: MessageEvent) => any) | null;
15002     onmessageerror: ((this: ServiceWorkerContainer, ev: MessageEvent) => any) | null;
15003     readonly ready: Promise<ServiceWorkerRegistration>;
15004     getRegistration(clientURL?: string): Promise<ServiceWorkerRegistration | undefined>;
15005     getRegistrations(): Promise<ReadonlyArray<ServiceWorkerRegistration>>;
15006     register(scriptURL: string | URL, options?: RegistrationOptions): Promise<ServiceWorkerRegistration>;
15007     startMessages(): void;
15008     addEventListener<K extends keyof ServiceWorkerContainerEventMap>(type: K, listener: (this: ServiceWorkerContainer, ev: ServiceWorkerContainerEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
15009     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
15010     removeEventListener<K extends keyof ServiceWorkerContainerEventMap>(type: K, listener: (this: ServiceWorkerContainer, ev: ServiceWorkerContainerEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
15011     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
15012 }
15013
15014 declare var ServiceWorkerContainer: {
15015     prototype: ServiceWorkerContainer;
15016     new(): ServiceWorkerContainer;
15017 };
15018
15019 /** This ServiceWorker API interface contains information about an event sent to a ServiceWorkerContainer target. This extends the default message event to allow setting a ServiceWorker object as the source of a message. The event object is accessed via the handler function of a message event, when fired by a message received from a service worker.
15020  * @deprecated In modern browsers, this interface has been deprecated. Service worker messages will now use the MessageEvent interface, for consistency with other web messaging features.
15021  */
15022 interface ServiceWorkerMessageEvent extends Event {
15023     readonly data: any;
15024     readonly lastEventId: string;
15025     readonly origin: string;
15026     readonly ports: ReadonlyArray<MessagePort> | null;
15027     readonly source: ServiceWorker | MessagePort | null;
15028 }
15029
15030 declare var ServiceWorkerMessageEvent: {
15031     prototype: ServiceWorkerMessageEvent;
15032     new(type: string, eventInitDict?: ServiceWorkerMessageEventInit): ServiceWorkerMessageEvent;
15033 };
15034
15035 interface ServiceWorkerRegistrationEventMap {
15036     "updatefound": Event;
15037 }
15038
15039 /** This ServiceWorker API interface represents the service worker registration. You register a service worker to control one or more pages that share the same origin. */
15040 interface ServiceWorkerRegistration extends EventTarget {
15041     readonly active: ServiceWorker | null;
15042     readonly installing: ServiceWorker | null;
15043     readonly navigationPreload: NavigationPreloadManager;
15044     onupdatefound: ((this: ServiceWorkerRegistration, ev: Event) => any) | null;
15045     readonly pushManager: PushManager;
15046     readonly scope: string;
15047     readonly sync: SyncManager;
15048     readonly updateViaCache: ServiceWorkerUpdateViaCache;
15049     readonly waiting: ServiceWorker | null;
15050     getNotifications(filter?: GetNotificationOptions): Promise<Notification[]>;
15051     showNotification(title: string, options?: NotificationOptions): Promise<void>;
15052     unregister(): Promise<boolean>;
15053     update(): Promise<void>;
15054     addEventListener<K extends keyof ServiceWorkerRegistrationEventMap>(type: K, listener: (this: ServiceWorkerRegistration, ev: ServiceWorkerRegistrationEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
15055     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
15056     removeEventListener<K extends keyof ServiceWorkerRegistrationEventMap>(type: K, listener: (this: ServiceWorkerRegistration, ev: ServiceWorkerRegistrationEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
15057     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
15058 }
15059
15060 declare var ServiceWorkerRegistration: {
15061     prototype: ServiceWorkerRegistration;
15062     new(): ServiceWorkerRegistration;
15063 };
15064
15065 interface ShadowRoot extends DocumentFragment, DocumentOrShadowRoot, InnerHTML {
15066     readonly host: Element;
15067     readonly mode: ShadowRootMode;
15068     /**
15069      * Throws a "NotSupportedError" DOMException if context object is a shadow root.
15070      */
15071 }
15072
15073 declare var ShadowRoot: {
15074     prototype: ShadowRoot;
15075     new(): ShadowRoot;
15076 };
15077
15078 interface SharedWorker extends EventTarget, AbstractWorker {
15079     /**
15080      * Returns sharedWorker's MessagePort object which can be used to communicate with the global environment.
15081      */
15082     readonly port: MessagePort;
15083     addEventListener<K extends keyof AbstractWorkerEventMap>(type: K, listener: (this: SharedWorker, ev: AbstractWorkerEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
15084     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
15085     removeEventListener<K extends keyof AbstractWorkerEventMap>(type: K, listener: (this: SharedWorker, ev: AbstractWorkerEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
15086     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
15087 }
15088
15089 declare var SharedWorker: {
15090     prototype: SharedWorker;
15091     new(scriptURL: string, options?: string | WorkerOptions): SharedWorker;
15092 };
15093
15094 interface Slottable {
15095     readonly assignedSlot: HTMLSlotElement | null;
15096 }
15097
15098 interface SourceBufferEventMap {
15099     "abort": Event;
15100     "error": Event;
15101     "update": Event;
15102     "updateend": Event;
15103     "updatestart": Event;
15104 }
15105
15106 /** A chunk of media to be passed into an HTMLMediaElement and played, via a MediaSource object. This can be made up of one or several media segments. */
15107 interface SourceBuffer extends EventTarget {
15108     appendWindowEnd: number;
15109     appendWindowStart: number;
15110     readonly buffered: TimeRanges;
15111     mode: AppendMode;
15112     onabort: ((this: SourceBuffer, ev: Event) => any) | null;
15113     onerror: ((this: SourceBuffer, ev: Event) => any) | null;
15114     onupdate: ((this: SourceBuffer, ev: Event) => any) | null;
15115     onupdateend: ((this: SourceBuffer, ev: Event) => any) | null;
15116     onupdatestart: ((this: SourceBuffer, ev: Event) => any) | null;
15117     timestampOffset: number;
15118     readonly updating: boolean;
15119     abort(): void;
15120     appendBuffer(data: BufferSource): void;
15121     remove(start: number, end: number): void;
15122     addEventListener<K extends keyof SourceBufferEventMap>(type: K, listener: (this: SourceBuffer, ev: SourceBufferEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
15123     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
15124     removeEventListener<K extends keyof SourceBufferEventMap>(type: K, listener: (this: SourceBuffer, ev: SourceBufferEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
15125     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
15126 }
15127
15128 declare var SourceBuffer: {
15129     prototype: SourceBuffer;
15130     new(): SourceBuffer;
15131 };
15132
15133 interface SourceBufferListEventMap {
15134     "addsourcebuffer": Event;
15135     "removesourcebuffer": Event;
15136 }
15137
15138 /** A simple container list for multiple SourceBuffer objects. */
15139 interface SourceBufferList extends EventTarget {
15140     readonly length: number;
15141     onaddsourcebuffer: ((this: SourceBufferList, ev: Event) => any) | null;
15142     onremovesourcebuffer: ((this: SourceBufferList, ev: Event) => any) | null;
15143     addEventListener<K extends keyof SourceBufferListEventMap>(type: K, listener: (this: SourceBufferList, ev: SourceBufferListEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
15144     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
15145     removeEventListener<K extends keyof SourceBufferListEventMap>(type: K, listener: (this: SourceBufferList, ev: SourceBufferListEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
15146     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
15147     [index: number]: SourceBuffer;
15148 }
15149
15150 declare var SourceBufferList: {
15151     prototype: SourceBufferList;
15152     new(): SourceBufferList;
15153 };
15154
15155 interface SpeechGrammar {
15156     src: string;
15157     weight: number;
15158 }
15159
15160 declare var SpeechGrammar: {
15161     prototype: SpeechGrammar;
15162     new(): SpeechGrammar;
15163 };
15164
15165 interface SpeechGrammarList {
15166     readonly length: number;
15167     addFromString(string: string, weight?: number): void;
15168     addFromURI(src: string, weight?: number): void;
15169     item(index: number): SpeechGrammar;
15170     [index: number]: SpeechGrammar;
15171 }
15172
15173 declare var SpeechGrammarList: {
15174     prototype: SpeechGrammarList;
15175     new(): SpeechGrammarList;
15176 };
15177
15178 interface SpeechRecognitionEventMap {
15179     "audioend": Event;
15180     "audiostart": Event;
15181     "end": Event;
15182     "error": SpeechRecognitionErrorEvent;
15183     "nomatch": SpeechRecognitionEvent;
15184     "result": SpeechRecognitionEvent;
15185     "soundend": Event;
15186     "soundstart": Event;
15187     "speechend": Event;
15188     "speechstart": Event;
15189     "start": Event;
15190 }
15191
15192 interface SpeechRecognition extends EventTarget {
15193     continuous: boolean;
15194     grammars: SpeechGrammarList;
15195     interimResults: boolean;
15196     lang: string;
15197     maxAlternatives: number;
15198     onaudioend: ((this: SpeechRecognition, ev: Event) => any) | null;
15199     onaudiostart: ((this: SpeechRecognition, ev: Event) => any) | null;
15200     onend: ((this: SpeechRecognition, ev: Event) => any) | null;
15201     onerror: ((this: SpeechRecognition, ev: SpeechRecognitionErrorEvent) => any) | null;
15202     onnomatch: ((this: SpeechRecognition, ev: SpeechRecognitionEvent) => any) | null;
15203     onresult: ((this: SpeechRecognition, ev: SpeechRecognitionEvent) => any) | null;
15204     onsoundend: ((this: SpeechRecognition, ev: Event) => any) | null;
15205     onsoundstart: ((this: SpeechRecognition, ev: Event) => any) | null;
15206     onspeechend: ((this: SpeechRecognition, ev: Event) => any) | null;
15207     onspeechstart: ((this: SpeechRecognition, ev: Event) => any) | null;
15208     onstart: ((this: SpeechRecognition, ev: Event) => any) | null;
15209     abort(): void;
15210     start(): void;
15211     stop(): void;
15212     addEventListener<K extends keyof SpeechRecognitionEventMap>(type: K, listener: (this: SpeechRecognition, ev: SpeechRecognitionEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
15213     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
15214     removeEventListener<K extends keyof SpeechRecognitionEventMap>(type: K, listener: (this: SpeechRecognition, ev: SpeechRecognitionEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
15215     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
15216 }
15217
15218 declare var SpeechRecognition: {
15219     prototype: SpeechRecognition;
15220     new(): SpeechRecognition;
15221 };
15222
15223 interface SpeechRecognitionAlternative {
15224     readonly confidence: number;
15225     readonly transcript: string;
15226 }
15227
15228 declare var SpeechRecognitionAlternative: {
15229     prototype: SpeechRecognitionAlternative;
15230     new(): SpeechRecognitionAlternative;
15231 };
15232
15233 interface SpeechRecognitionErrorEvent extends Event {
15234     readonly error: SpeechRecognitionErrorCode;
15235     readonly message: string;
15236 }
15237
15238 declare var SpeechRecognitionErrorEvent: {
15239     prototype: SpeechRecognitionErrorEvent;
15240     new(type: string, eventInitDict: SpeechRecognitionErrorEventInit): SpeechRecognitionErrorEvent;
15241 };
15242
15243 interface SpeechRecognitionEvent extends Event {
15244     readonly resultIndex: number;
15245     readonly results: SpeechRecognitionResultList;
15246 }
15247
15248 declare var SpeechRecognitionEvent: {
15249     prototype: SpeechRecognitionEvent;
15250     new(type: string, eventInitDict: SpeechRecognitionEventInit): SpeechRecognitionEvent;
15251 };
15252
15253 interface SpeechRecognitionResult {
15254     readonly isFinal: boolean;
15255     readonly length: number;
15256     item(index: number): SpeechRecognitionAlternative;
15257     [index: number]: SpeechRecognitionAlternative;
15258 }
15259
15260 declare var SpeechRecognitionResult: {
15261     prototype: SpeechRecognitionResult;
15262     new(): SpeechRecognitionResult;
15263 };
15264
15265 interface SpeechRecognitionResultList {
15266     readonly length: number;
15267     item(index: number): SpeechRecognitionResult;
15268     [index: number]: SpeechRecognitionResult;
15269 }
15270
15271 declare var SpeechRecognitionResultList: {
15272     prototype: SpeechRecognitionResultList;
15273     new(): SpeechRecognitionResultList;
15274 };
15275
15276 interface SpeechSynthesisEventMap {
15277     "voiceschanged": Event;
15278 }
15279
15280 /** This Web Speech API interface is the controller interface for the speech service; this can be used to retrieve information about the synthesis voices available on the device, start and pause speech, and other commands besides. */
15281 interface SpeechSynthesis extends EventTarget {
15282     onvoiceschanged: ((this: SpeechSynthesis, ev: Event) => any) | null;
15283     readonly paused: boolean;
15284     readonly pending: boolean;
15285     readonly speaking: boolean;
15286     cancel(): void;
15287     getVoices(): SpeechSynthesisVoice[];
15288     pause(): void;
15289     resume(): void;
15290     speak(utterance: SpeechSynthesisUtterance): void;
15291     addEventListener<K extends keyof SpeechSynthesisEventMap>(type: K, listener: (this: SpeechSynthesis, ev: SpeechSynthesisEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
15292     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
15293     removeEventListener<K extends keyof SpeechSynthesisEventMap>(type: K, listener: (this: SpeechSynthesis, ev: SpeechSynthesisEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
15294     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
15295 }
15296
15297 declare var SpeechSynthesis: {
15298     prototype: SpeechSynthesis;
15299     new(): SpeechSynthesis;
15300 };
15301
15302 interface SpeechSynthesisErrorEvent extends SpeechSynthesisEvent {
15303     readonly error: SpeechSynthesisErrorCode;
15304 }
15305
15306 declare var SpeechSynthesisErrorEvent: {
15307     prototype: SpeechSynthesisErrorEvent;
15308     new(type: string, eventInitDict: SpeechSynthesisErrorEventInit): SpeechSynthesisErrorEvent;
15309 };
15310
15311 /** This Web Speech API interface contains information about the current state of SpeechSynthesisUtterance objects that have been processed in the speech service. */
15312 interface SpeechSynthesisEvent extends Event {
15313     readonly charIndex: number;
15314     readonly charLength: number;
15315     readonly elapsedTime: number;
15316     readonly name: string;
15317     readonly utterance: SpeechSynthesisUtterance;
15318 }
15319
15320 declare var SpeechSynthesisEvent: {
15321     prototype: SpeechSynthesisEvent;
15322     new(type: string, eventInitDict: SpeechSynthesisEventInit): SpeechSynthesisEvent;
15323 };
15324
15325 interface SpeechSynthesisUtteranceEventMap {
15326     "boundary": SpeechSynthesisEvent;
15327     "end": SpeechSynthesisEvent;
15328     "error": SpeechSynthesisErrorEvent;
15329     "mark": SpeechSynthesisEvent;
15330     "pause": SpeechSynthesisEvent;
15331     "resume": SpeechSynthesisEvent;
15332     "start": SpeechSynthesisEvent;
15333 }
15334
15335 /** This Web Speech API interface represents a speech request. It contains the content the speech service should read and information about how to read it (e.g. language, pitch and volume.) */
15336 interface SpeechSynthesisUtterance extends EventTarget {
15337     lang: string;
15338     onboundary: ((this: SpeechSynthesisUtterance, ev: SpeechSynthesisEvent) => any) | null;
15339     onend: ((this: SpeechSynthesisUtterance, ev: SpeechSynthesisEvent) => any) | null;
15340     onerror: ((this: SpeechSynthesisUtterance, ev: SpeechSynthesisErrorEvent) => any) | null;
15341     onmark: ((this: SpeechSynthesisUtterance, ev: SpeechSynthesisEvent) => any) | null;
15342     onpause: ((this: SpeechSynthesisUtterance, ev: SpeechSynthesisEvent) => any) | null;
15343     onresume: ((this: SpeechSynthesisUtterance, ev: SpeechSynthesisEvent) => any) | null;
15344     onstart: ((this: SpeechSynthesisUtterance, ev: SpeechSynthesisEvent) => any) | null;
15345     pitch: number;
15346     rate: number;
15347     text: string;
15348     voice: SpeechSynthesisVoice | null;
15349     volume: number;
15350     addEventListener<K extends keyof SpeechSynthesisUtteranceEventMap>(type: K, listener: (this: SpeechSynthesisUtterance, ev: SpeechSynthesisUtteranceEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
15351     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
15352     removeEventListener<K extends keyof SpeechSynthesisUtteranceEventMap>(type: K, listener: (this: SpeechSynthesisUtterance, ev: SpeechSynthesisUtteranceEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
15353     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
15354 }
15355
15356 declare var SpeechSynthesisUtterance: {
15357     prototype: SpeechSynthesisUtterance;
15358     new(text?: string): SpeechSynthesisUtterance;
15359 };
15360
15361 /** This Web Speech API interface represents a voice that the system supports. Every SpeechSynthesisVoice has its own relative speech service including information about language, name and URI. */
15362 interface SpeechSynthesisVoice {
15363     readonly default: boolean;
15364     readonly lang: string;
15365     readonly localService: boolean;
15366     readonly name: string;
15367     readonly voiceURI: string;
15368 }
15369
15370 declare var SpeechSynthesisVoice: {
15371     prototype: SpeechSynthesisVoice;
15372     new(): SpeechSynthesisVoice;
15373 };
15374
15375 interface StaticRange extends AbstractRange {
15376 }
15377
15378 declare var StaticRange: {
15379     prototype: StaticRange;
15380     new(init: StaticRangeInit): StaticRange;
15381 };
15382
15383 /** The pan property takes a unitless value between -1 (full left pan) and 1 (full right pan). This interface was introduced as a much simpler way to apply a simple panning effect than having to use a full PannerNode. */
15384 interface StereoPannerNode extends AudioNode {
15385     readonly pan: AudioParam;
15386 }
15387
15388 declare var StereoPannerNode: {
15389     prototype: StereoPannerNode;
15390     new(context: BaseAudioContext, options?: StereoPannerOptions): StereoPannerNode;
15391 };
15392
15393 /** This Web Storage API interface provides access to a particular domain's session or local storage. It allows, for example, the addition, modification, or deletion of stored data items. */
15394 interface Storage {
15395     /**
15396      * Returns the number of key/value pairs currently present in the list associated with the object.
15397      */
15398     readonly length: number;
15399     /**
15400      * Empties the list associated with the object of all key/value pairs, if there are any.
15401      */
15402     clear(): void;
15403     /**
15404      * Returns the current value associated with the given key, or null if the given key does not exist in the list associated with the object.
15405      */
15406     getItem(key: string): string | null;
15407     /**
15408      * Returns the name of the nth key in the list, or null if n is greater than or equal to the number of key/value pairs in the object.
15409      */
15410     key(index: number): string | null;
15411     /**
15412      * Removes the key/value pair with the given key from the list associated with the object, if a key/value pair with the given key exists.
15413      */
15414     removeItem(key: string): void;
15415     /**
15416      * Sets the value of the pair identified by key to value, creating a new key/value pair if none existed for key previously.
15417      *
15418      * Throws a "QuotaExceededError" DOMException exception if the new value couldn't be set. (Setting could fail if, e.g., the user has disabled storage for the site, or if the quota has been exceeded.)
15419      */
15420     setItem(key: string, value: string): void;
15421     [name: string]: any;
15422 }
15423
15424 declare var Storage: {
15425     prototype: Storage;
15426     new(): Storage;
15427 };
15428
15429 /** A StorageEvent is sent to a window when a storage area it has access to is changed within the context of another document. */
15430 interface StorageEvent extends Event {
15431     /**
15432      * Returns the key of the storage item being changed.
15433      */
15434     readonly key: string | null;
15435     /**
15436      * Returns the new value of the key of the storage item whose value is being changed.
15437      */
15438     readonly newValue: string | null;
15439     /**
15440      * Returns the old value of the key of the storage item whose value is being changed.
15441      */
15442     readonly oldValue: string | null;
15443     /**
15444      * Returns the Storage object that was affected.
15445      */
15446     readonly storageArea: Storage | null;
15447     /**
15448      * Returns the URL of the document whose storage item changed.
15449      */
15450     readonly url: string;
15451 }
15452
15453 declare var StorageEvent: {
15454     prototype: StorageEvent;
15455     new(type: string, eventInitDict?: StorageEventInit): StorageEvent;
15456 };
15457
15458 interface StorageManager {
15459     estimate(): Promise<StorageEstimate>;
15460     persist(): Promise<boolean>;
15461     persisted(): Promise<boolean>;
15462 }
15463
15464 declare var StorageManager: {
15465     prototype: StorageManager;
15466     new(): StorageManager;
15467 };
15468
15469 interface StyleMedia {
15470     readonly type: string;
15471     matchMedium(mediaquery: string): boolean;
15472 }
15473
15474 declare var StyleMedia: {
15475     prototype: StyleMedia;
15476     new(): StyleMedia;
15477 };
15478
15479 /** A single style sheet. CSS style sheets will further implement the more specialized CSSStyleSheet interface. */
15480 interface StyleSheet {
15481     disabled: boolean;
15482     readonly href: string | null;
15483     readonly media: MediaList;
15484     readonly ownerNode: Element | ProcessingInstruction | null;
15485     readonly parentStyleSheet: CSSStyleSheet | null;
15486     readonly title: string | null;
15487     readonly type: string;
15488 }
15489
15490 declare var StyleSheet: {
15491     prototype: StyleSheet;
15492     new(): StyleSheet;
15493 };
15494
15495 /** A list of StyleSheet. */
15496 interface StyleSheetList {
15497     readonly length: number;
15498     item(index: number): CSSStyleSheet | null;
15499     [index: number]: CSSStyleSheet;
15500 }
15501
15502 declare var StyleSheetList: {
15503     prototype: StyleSheetList;
15504     new(): StyleSheetList;
15505 };
15506
15507 /** This Web Crypto API interface provides a number of low-level cryptographic functions. It is accessed via the Crypto.subtle properties available in a window context (via Window.crypto). */
15508 interface SubtleCrypto {
15509     decrypt(algorithm: AlgorithmIdentifier | RsaOaepParams | AesCtrParams | AesCbcParams | AesCmacParams | AesGcmParams | AesCfbParams, key: CryptoKey, data: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer): Promise<ArrayBuffer>;
15510     deriveBits(algorithm: AlgorithmIdentifier | EcdhKeyDeriveParams | DhKeyDeriveParams | ConcatParams | HkdfParams | Pbkdf2Params, baseKey: CryptoKey, length: number): Promise<ArrayBuffer>;
15511     deriveKey(algorithm: AlgorithmIdentifier | EcdhKeyDeriveParams | DhKeyDeriveParams | ConcatParams | HkdfParams | Pbkdf2Params, baseKey: CryptoKey, derivedKeyType: string | AesDerivedKeyParams | HmacImportParams | ConcatParams | HkdfParams | Pbkdf2Params, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey>;
15512     digest(algorithm: AlgorithmIdentifier, data: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer): Promise<ArrayBuffer>;
15513     encrypt(algorithm: AlgorithmIdentifier | RsaOaepParams | AesCtrParams | AesCbcParams | AesCmacParams | AesGcmParams | AesCfbParams, key: CryptoKey, data: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer): Promise<ArrayBuffer>;
15514     exportKey(format: "jwk", key: CryptoKey): Promise<JsonWebKey>;
15515     exportKey(format: "raw" | "pkcs8" | "spki", key: CryptoKey): Promise<ArrayBuffer>;
15516     exportKey(format: string, key: CryptoKey): Promise<JsonWebKey | ArrayBuffer>;
15517     generateKey(algorithm: RsaHashedKeyGenParams | EcKeyGenParams | DhKeyGenParams, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKeyPair>;
15518     generateKey(algorithm: AesKeyGenParams | HmacKeyGenParams | Pbkdf2Params, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey>;
15519     generateKey(algorithm: AlgorithmIdentifier, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKeyPair | CryptoKey>;
15520     importKey(format: "jwk", keyData: JsonWebKey, algorithm: AlgorithmIdentifier | RsaHashedImportParams | EcKeyImportParams | HmacImportParams | DhImportKeyParams | AesKeyAlgorithm, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey>;
15521     importKey(format: "raw" | "pkcs8" | "spki", keyData: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer, algorithm: AlgorithmIdentifier | RsaHashedImportParams | EcKeyImportParams | HmacImportParams | DhImportKeyParams | AesKeyAlgorithm, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey>;
15522     importKey(format: string, keyData: JsonWebKey | Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer, algorithm: AlgorithmIdentifier | RsaHashedImportParams | EcKeyImportParams | HmacImportParams | DhImportKeyParams | AesKeyAlgorithm, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey>;
15523     sign(algorithm: AlgorithmIdentifier | RsaPssParams | EcdsaParams | AesCmacParams, key: CryptoKey, data: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer): Promise<ArrayBuffer>;
15524     unwrapKey(format: "raw" | "pkcs8" | "spki" | "jwk" | string, wrappedKey: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer, unwrappingKey: CryptoKey, unwrapAlgorithm: AlgorithmIdentifier | RsaOaepParams | AesCtrParams | AesCbcParams | AesCmacParams | AesGcmParams | AesCfbParams, unwrappedKeyAlgorithm: AlgorithmIdentifier | RsaHashedImportParams | EcKeyImportParams | HmacImportParams | DhImportKeyParams | AesKeyAlgorithm, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey>;
15525     verify(algorithm: AlgorithmIdentifier | RsaPssParams | EcdsaParams | AesCmacParams, key: CryptoKey, signature: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer, data: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer): Promise<boolean>;
15526     wrapKey(format: "raw" | "pkcs8" | "spki" | "jwk" | string, key: CryptoKey, wrappingKey: CryptoKey, wrapAlgorithm: AlgorithmIdentifier | RsaOaepParams | AesCtrParams | AesCbcParams | AesCmacParams | AesGcmParams | AesCfbParams): Promise<ArrayBuffer>;
15527 }
15528
15529 declare var SubtleCrypto: {
15530     prototype: SubtleCrypto;
15531     new(): SubtleCrypto;
15532 };
15533
15534 /** This ServiceWorker API interface provides an interface for registering and listing sync registrations. */
15535 interface SyncManager {
15536     getTags(): Promise<string[]>;
15537     register(tag: string): Promise<void>;
15538 }
15539
15540 declare var SyncManager: {
15541     prototype: SyncManager;
15542     new(): SyncManager;
15543 };
15544
15545 /** The textual content of Element or Attr. If an element has no markup within its content, it has a single child implementing Text that contains the element's text. However, if the element contains markup, it is parsed into information items and Text nodes that form its children. */
15546 interface Text extends CharacterData, Slottable {
15547     readonly assignedSlot: HTMLSlotElement | null;
15548     /**
15549      * Returns the combined data of all direct Text node siblings.
15550      */
15551     readonly wholeText: string;
15552     /**
15553      * Splits data at the given offset and returns the remainder as Text node.
15554      */
15555     splitText(offset: number): Text;
15556 }
15557
15558 declare var Text: {
15559     prototype: Text;
15560     new(data?: string): Text;
15561 };
15562
15563 /** A decoder for a specific method, that is a specific character encoding, like utf-8, iso-8859-2, koi8, cp1261, gbk, etc. A decoder takes a stream of bytes as input and emits a stream of code points. For a more scalable, non-native library, see StringView – a C-like representation of strings based on typed arrays. */
15564 interface TextDecoder extends TextDecoderCommon {
15565     /**
15566      * Returns the result of running encoding's decoder. The method can be invoked zero or more times with options's stream set to true, and then once without options's stream (or set to false), to process a fragmented input. If the invocation without options's stream (or set to false) has no input, it's clearest to omit both arguments.
15567      *
15568      * ```
15569      * var string = "", decoder = new TextDecoder(encoding), buffer;
15570      * while(buffer = next_chunk()) {
15571      *   string += decoder.decode(buffer, {stream:true});
15572      * }
15573      * string += decoder.decode(); // end-of-queue
15574      * ```
15575      *
15576      * If the error mode is "fatal" and encoding's decoder returns error, throws a TypeError.
15577      */
15578     decode(input?: BufferSource, options?: TextDecodeOptions): string;
15579 }
15580
15581 declare var TextDecoder: {
15582     prototype: TextDecoder;
15583     new(label?: string, options?: TextDecoderOptions): TextDecoder;
15584 };
15585
15586 interface TextDecoderCommon {
15587     /**
15588      * Returns encoding's name, lowercased.
15589      */
15590     readonly encoding: string;
15591     /**
15592      * Returns true if error mode is "fatal", otherwise false.
15593      */
15594     readonly fatal: boolean;
15595     /**
15596      * Returns the value of ignore BOM.
15597      */
15598     readonly ignoreBOM: boolean;
15599 }
15600
15601 interface TextDecoderStream extends GenericTransformStream, TextDecoderCommon {
15602     readonly readable: ReadableStream<string>;
15603     readonly writable: WritableStream<BufferSource>;
15604 }
15605
15606 declare var TextDecoderStream: {
15607     prototype: TextDecoderStream;
15608     new(label?: string, options?: TextDecoderOptions): TextDecoderStream;
15609 };
15610
15611 /** TextEncoder takes a stream of code points as input and emits a stream of bytes. For a more scalable, non-native library, see StringView – a C-like representation of strings based on typed arrays. */
15612 interface TextEncoder extends TextEncoderCommon {
15613     /**
15614      * Returns the result of running UTF-8's encoder.
15615      */
15616     encode(input?: string): Uint8Array;
15617     /**
15618      * Runs the UTF-8 encoder on source, stores the result of that operation into destination, and returns the progress made as an object wherein read is the number of converted code units of source and written is the number of bytes modified in destination.
15619      */
15620     encodeInto(source: string, destination: Uint8Array): TextEncoderEncodeIntoResult;
15621 }
15622
15623 declare var TextEncoder: {
15624     prototype: TextEncoder;
15625     new(): TextEncoder;
15626 };
15627
15628 interface TextEncoderCommon {
15629     /**
15630      * Returns "utf-8".
15631      */
15632     readonly encoding: string;
15633 }
15634
15635 interface TextEncoderStream extends GenericTransformStream, TextEncoderCommon {
15636     readonly readable: ReadableStream<Uint8Array>;
15637     readonly writable: WritableStream<string>;
15638 }
15639
15640 declare var TextEncoderStream: {
15641     prototype: TextEncoderStream;
15642     new(): TextEncoderStream;
15643 };
15644
15645 interface TextEvent extends UIEvent {
15646     readonly data: string;
15647     initTextEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, viewArg: Window, dataArg: string, inputMethod: number, locale: string): void;
15648     readonly DOM_INPUT_METHOD_DROP: number;
15649     readonly DOM_INPUT_METHOD_HANDWRITING: number;
15650     readonly DOM_INPUT_METHOD_IME: number;
15651     readonly DOM_INPUT_METHOD_KEYBOARD: number;
15652     readonly DOM_INPUT_METHOD_MULTIMODAL: number;
15653     readonly DOM_INPUT_METHOD_OPTION: number;
15654     readonly DOM_INPUT_METHOD_PASTE: number;
15655     readonly DOM_INPUT_METHOD_SCRIPT: number;
15656     readonly DOM_INPUT_METHOD_UNKNOWN: number;
15657     readonly DOM_INPUT_METHOD_VOICE: number;
15658 }
15659
15660 declare var TextEvent: {
15661     prototype: TextEvent;
15662     new(): TextEvent;
15663     readonly DOM_INPUT_METHOD_DROP: number;
15664     readonly DOM_INPUT_METHOD_HANDWRITING: number;
15665     readonly DOM_INPUT_METHOD_IME: number;
15666     readonly DOM_INPUT_METHOD_KEYBOARD: number;
15667     readonly DOM_INPUT_METHOD_MULTIMODAL: number;
15668     readonly DOM_INPUT_METHOD_OPTION: number;
15669     readonly DOM_INPUT_METHOD_PASTE: number;
15670     readonly DOM_INPUT_METHOD_SCRIPT: number;
15671     readonly DOM_INPUT_METHOD_UNKNOWN: number;
15672     readonly DOM_INPUT_METHOD_VOICE: number;
15673 };
15674
15675 /** The dimensions of a piece of text in the canvas, as created by the CanvasRenderingContext2D.measureText() method. */
15676 interface TextMetrics {
15677     /**
15678      * Returns the measurement described below.
15679      */
15680     readonly actualBoundingBoxAscent: number;
15681     /**
15682      * Returns the measurement described below.
15683      */
15684     readonly actualBoundingBoxDescent: number;
15685     /**
15686      * Returns the measurement described below.
15687      */
15688     readonly actualBoundingBoxLeft: number;
15689     /**
15690      * Returns the measurement described below.
15691      */
15692     readonly actualBoundingBoxRight: number;
15693     /**
15694      * Returns the measurement described below.
15695      */
15696     readonly alphabeticBaseline: number;
15697     /**
15698      * Returns the measurement described below.
15699      */
15700     readonly emHeightAscent: number;
15701     /**
15702      * Returns the measurement described below.
15703      */
15704     readonly emHeightDescent: number;
15705     /**
15706      * Returns the measurement described below.
15707      */
15708     readonly fontBoundingBoxAscent: number;
15709     /**
15710      * Returns the measurement described below.
15711      */
15712     readonly fontBoundingBoxDescent: number;
15713     /**
15714      * Returns the measurement described below.
15715      */
15716     readonly hangingBaseline: number;
15717     /**
15718      * Returns the measurement described below.
15719      */
15720     readonly ideographicBaseline: number;
15721     /**
15722      * Returns the measurement described below.
15723      */
15724     readonly width: number;
15725 }
15726
15727 declare var TextMetrics: {
15728     prototype: TextMetrics;
15729     new(): TextMetrics;
15730 };
15731
15732 interface TextTrackEventMap {
15733     "cuechange": Event;
15734 }
15735
15736 /** This interface also inherits properties from EventTarget. */
15737 interface TextTrack extends EventTarget {
15738     /**
15739      * Returns the text track cues from the text track list of cues that are currently active (i.e. that start before the current playback position and end after it), as a TextTrackCueList object.
15740      */
15741     readonly activeCues: TextTrackCueList | null;
15742     /**
15743      * Returns the text track list of cues, as a TextTrackCueList object.
15744      */
15745     readonly cues: TextTrackCueList | null;
15746     /**
15747      * Returns the ID of the given track.
15748      *
15749      * For in-band tracks, this is the ID that can be used with a fragment if the format supports media fragment syntax, and that can be used with the getTrackById() method.
15750      *
15751      * For TextTrack objects corresponding to track elements, this is the ID of the track element.
15752      */
15753     readonly id: string;
15754     /**
15755      * Returns the text track in-band metadata track dispatch type string.
15756      */
15757     readonly inBandMetadataTrackDispatchType: string;
15758     /**
15759      * Returns the text track kind string.
15760      */
15761     readonly kind: TextTrackKind;
15762     /**
15763      * Returns the text track label, if there is one, or the empty string otherwise (indicating that a custom label probably needs to be generated from the other attributes of the object if the object is exposed to the user).
15764      */
15765     readonly label: string;
15766     /**
15767      * Returns the text track language string.
15768      */
15769     readonly language: string;
15770     /**
15771      * Returns the text track mode, represented by a string from the following list:
15772      *
15773      * Can be set, to change the mode.
15774      */
15775     mode: TextTrackMode;
15776     oncuechange: ((this: TextTrack, ev: Event) => any) | null;
15777     readonly sourceBuffer: SourceBuffer | null;
15778     /**
15779      * Adds the given cue to textTrack's text track list of cues.
15780      */
15781     addCue(cue: TextTrackCue): void;
15782     /**
15783      * Removes the given cue from textTrack's text track list of cues.
15784      */
15785     removeCue(cue: TextTrackCue): void;
15786     addEventListener<K extends keyof TextTrackEventMap>(type: K, listener: (this: TextTrack, ev: TextTrackEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
15787     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
15788     removeEventListener<K extends keyof TextTrackEventMap>(type: K, listener: (this: TextTrack, ev: TextTrackEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
15789     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
15790 }
15791
15792 declare var TextTrack: {
15793     prototype: TextTrack;
15794     new(): TextTrack;
15795 };
15796
15797 interface TextTrackCueEventMap {
15798     "enter": Event;
15799     "exit": Event;
15800 }
15801
15802 /** TextTrackCues represent a string of text that will be displayed for some duration of time on a TextTrack. This includes the start and end times that the cue will be displayed. A TextTrackCue cannot be used directly, instead one of the derived types (e.g. VTTCue) must be used. */
15803 interface TextTrackCue extends EventTarget {
15804     /**
15805      * Returns the text track cue end time, in seconds.
15806      *
15807      * Can be set.
15808      */
15809     endTime: number;
15810     /**
15811      * Returns the text track cue identifier.
15812      *
15813      * Can be set.
15814      */
15815     id: string;
15816     onenter: ((this: TextTrackCue, ev: Event) => any) | null;
15817     onexit: ((this: TextTrackCue, ev: Event) => any) | null;
15818     /**
15819      * Returns true if the text track cue pause-on-exit flag is set, false otherwise.
15820      *
15821      * Can be set.
15822      */
15823     pauseOnExit: boolean;
15824     /**
15825      * Returns the text track cue start time, in seconds.
15826      *
15827      * Can be set.
15828      */
15829     startTime: number;
15830     /**
15831      * Returns the TextTrack object to which this text track cue belongs, if any, or null otherwise.
15832      */
15833     readonly track: TextTrack | null;
15834     addEventListener<K extends keyof TextTrackCueEventMap>(type: K, listener: (this: TextTrackCue, ev: TextTrackCueEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
15835     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
15836     removeEventListener<K extends keyof TextTrackCueEventMap>(type: K, listener: (this: TextTrackCue, ev: TextTrackCueEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
15837     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
15838 }
15839
15840 declare var TextTrackCue: {
15841     prototype: TextTrackCue;
15842     new(): TextTrackCue;
15843 };
15844
15845 interface TextTrackCueList {
15846     /**
15847      * Returns the number of cues in the list.
15848      */
15849     readonly length: number;
15850     /**
15851      * Returns the first text track cue (in text track cue order) with text track cue identifier id.
15852      *
15853      * Returns null if none of the cues have the given identifier or if the argument is the empty string.
15854      */
15855     getCueById(id: string): TextTrackCue | null;
15856     [index: number]: TextTrackCue;
15857 }
15858
15859 declare var TextTrackCueList: {
15860     prototype: TextTrackCueList;
15861     new(): TextTrackCueList;
15862 };
15863
15864 interface TextTrackListEventMap {
15865     "addtrack": TrackEvent;
15866     "change": Event;
15867     "removetrack": TrackEvent;
15868 }
15869
15870 interface TextTrackList extends EventTarget {
15871     readonly length: number;
15872     onaddtrack: ((this: TextTrackList, ev: TrackEvent) => any) | null;
15873     onchange: ((this: TextTrackList, ev: Event) => any) | null;
15874     onremovetrack: ((this: TextTrackList, ev: TrackEvent) => any) | null;
15875     getTrackById(id: string): TextTrack | null;
15876     addEventListener<K extends keyof TextTrackListEventMap>(type: K, listener: (this: TextTrackList, ev: TextTrackListEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
15877     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
15878     removeEventListener<K extends keyof TextTrackListEventMap>(type: K, listener: (this: TextTrackList, ev: TextTrackListEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
15879     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
15880     [index: number]: TextTrack;
15881 }
15882
15883 declare var TextTrackList: {
15884     prototype: TextTrackList;
15885     new(): TextTrackList;
15886 };
15887
15888 /** Used to represent a set of time ranges, primarily for the purpose of tracking which portions of media have been buffered when loading it for use by the <audio> and <video> elements. */
15889 interface TimeRanges {
15890     /**
15891      * Returns the number of ranges in the object.
15892      */
15893     readonly length: number;
15894     /**
15895      * Returns the time for the end of the range with the given index.
15896      *
15897      * Throws an "IndexSizeError" DOMException if the index is out of range.
15898      */
15899     end(index: number): number;
15900     /**
15901      * Returns the time for the start of the range with the given index.
15902      *
15903      * Throws an "IndexSizeError" DOMException if the index is out of range.
15904      */
15905     start(index: number): number;
15906 }
15907
15908 declare var TimeRanges: {
15909     prototype: TimeRanges;
15910     new(): TimeRanges;
15911 };
15912
15913 /** A single contact point on a touch-sensitive device. The contact point is commonly a finger or stylus and the device may be a touchscreen or trackpad. */
15914 interface Touch {
15915     readonly altitudeAngle: number;
15916     readonly azimuthAngle: number;
15917     readonly clientX: number;
15918     readonly clientY: number;
15919     readonly force: number;
15920     readonly identifier: number;
15921     readonly pageX: number;
15922     readonly pageY: number;
15923     readonly radiusX: number;
15924     readonly radiusY: number;
15925     readonly rotationAngle: number;
15926     readonly screenX: number;
15927     readonly screenY: number;
15928     readonly target: EventTarget;
15929     readonly touchType: TouchType;
15930 }
15931
15932 declare var Touch: {
15933     prototype: Touch;
15934     new(touchInitDict: TouchInit): Touch;
15935 };
15936
15937 /** An event sent when the state of contacts with a touch-sensitive surface changes. This surface can be a touch screen or trackpad, for example. The event can describe one or more points of contact with the screen and includes support for detecting movement, addition and removal of contact points, and so forth. */
15938 interface TouchEvent extends UIEvent {
15939     readonly altKey: boolean;
15940     readonly changedTouches: TouchList;
15941     readonly ctrlKey: boolean;
15942     readonly metaKey: boolean;
15943     readonly shiftKey: boolean;
15944     readonly targetTouches: TouchList;
15945     readonly touches: TouchList;
15946 }
15947
15948 declare var TouchEvent: {
15949     prototype: TouchEvent;
15950     new(type: string, eventInitDict?: TouchEventInit): TouchEvent;
15951 };
15952
15953 /** A list of contact points on a touch surface. For example, if the user has three fingers on the touch surface (such as a screen or trackpad), the corresponding TouchList object would have one Touch object for each finger, for a total of three entries. */
15954 interface TouchList {
15955     readonly length: number;
15956     item(index: number): Touch | null;
15957     [index: number]: Touch;
15958 }
15959
15960 declare var TouchList: {
15961     prototype: TouchList;
15962     new(): TouchList;
15963 };
15964
15965 /** The TrackEvent interface, part of the HTML DOM specification, is used for events which represent changes to the set of available tracks on an HTML media element; these events are addtrack and removetrack. */
15966 interface TrackEvent extends Event {
15967     /**
15968      * Returns the track object (TextTrack, AudioTrack, or VideoTrack) to which the event relates.
15969      */
15970     readonly track: TextTrack | null;
15971 }
15972
15973 declare var TrackEvent: {
15974     prototype: TrackEvent;
15975     new(type: string, eventInitDict?: TrackEventInit): TrackEvent;
15976 };
15977
15978 interface TransformStream<I = any, O = any> {
15979     readonly readable: ReadableStream<O>;
15980     readonly writable: WritableStream<I>;
15981 }
15982
15983 declare var TransformStream: {
15984     prototype: TransformStream;
15985     new<I = any, O = any>(transformer?: Transformer<I, O>, writableStrategy?: QueuingStrategy<I>, readableStrategy?: QueuingStrategy<O>): TransformStream<I, O>;
15986 };
15987
15988 interface TransformStreamDefaultController<O = any> {
15989     readonly desiredSize: number | null;
15990     enqueue(chunk: O): void;
15991     error(reason?: any): void;
15992     terminate(): void;
15993 }
15994
15995 declare var TransformStreamDefaultController: {
15996     prototype: TransformStreamDefaultController;
15997     new(): TransformStreamDefaultController;
15998 };
15999
16000 /** Events providing information related to transitions. */
16001 interface TransitionEvent extends Event {
16002     readonly elapsedTime: number;
16003     readonly propertyName: string;
16004     readonly pseudoElement: string;
16005 }
16006
16007 declare var TransitionEvent: {
16008     prototype: TransitionEvent;
16009     new(type: string, transitionEventInitDict?: TransitionEventInit): TransitionEvent;
16010 };
16011
16012 /** The nodes of a document subtree and a position within them. */
16013 interface TreeWalker {
16014     currentNode: Node;
16015     readonly filter: NodeFilter | null;
16016     readonly root: Node;
16017     readonly whatToShow: number;
16018     firstChild(): Node | null;
16019     lastChild(): Node | null;
16020     nextNode(): Node | null;
16021     nextSibling(): Node | null;
16022     parentNode(): Node | null;
16023     previousNode(): Node | null;
16024     previousSibling(): Node | null;
16025 }
16026
16027 declare var TreeWalker: {
16028     prototype: TreeWalker;
16029     new(): TreeWalker;
16030 };
16031
16032 /** Simple user interface events. */
16033 interface UIEvent extends Event {
16034     readonly detail: number;
16035     readonly view: Window | null;
16036     /** @deprecated */
16037     readonly which: number;
16038 }
16039
16040 declare var UIEvent: {
16041     prototype: UIEvent;
16042     new(type: string, eventInitDict?: UIEventInit): UIEvent;
16043 };
16044
16045 /** The URL interface represents an object providing static methods used for creating object URLs. */
16046 interface URL {
16047     hash: string;
16048     host: string;
16049     hostname: string;
16050     href: string;
16051     toString(): string;
16052     readonly origin: string;
16053     password: string;
16054     pathname: string;
16055     port: string;
16056     protocol: string;
16057     search: string;
16058     readonly searchParams: URLSearchParams;
16059     username: string;
16060     toJSON(): string;
16061 }
16062
16063 declare var URL: {
16064     prototype: URL;
16065     new(url: string, base?: string | URL): URL;
16066     createObjectURL(object: any): string;
16067     revokeObjectURL(url: string): void;
16068 };
16069
16070 type webkitURL = URL;
16071 declare var webkitURL: typeof URL;
16072
16073 interface URLSearchParams {
16074     /**
16075      * Appends a specified key/value pair as a new search parameter.
16076      */
16077     append(name: string, value: string): void;
16078     /**
16079      * Deletes the given search parameter, and its associated value, from the list of all search parameters.
16080      */
16081     delete(name: string): void;
16082     /**
16083      * Returns the first value associated to the given search parameter.
16084      */
16085     get(name: string): string | null;
16086     /**
16087      * Returns all the values association with a given search parameter.
16088      */
16089     getAll(name: string): string[];
16090     /**
16091      * Returns a Boolean indicating if such a search parameter exists.
16092      */
16093     has(name: string): boolean;
16094     /**
16095      * Sets the value associated to a given search parameter to the given value. If there were several values, delete the others.
16096      */
16097     set(name: string, value: string): void;
16098     sort(): void;
16099     /**
16100      * Returns a string containing a query string suitable for use in a URL. Does not include the question mark.
16101      */
16102     toString(): string;
16103     forEach(callbackfn: (value: string, key: string, parent: URLSearchParams) => void, thisArg?: any): void;
16104 }
16105
16106 declare var URLSearchParams: {
16107     prototype: URLSearchParams;
16108     new(init?: string[][] | Record<string, string> | string | URLSearchParams): URLSearchParams;
16109     toString(): string;
16110 };
16111
16112 /** This WebVR API interface represents any VR device supported by this API. It includes generic information such as device IDs and descriptions, as well as methods for starting to present a VR scene, retrieving eye parameters and display capabilities, and other important functionality. */
16113 interface VRDisplay extends EventTarget {
16114     readonly capabilities: VRDisplayCapabilities;
16115     depthFar: number;
16116     depthNear: number;
16117     readonly displayId: number;
16118     readonly displayName: string;
16119     readonly isConnected: boolean;
16120     readonly isPresenting: boolean;
16121     readonly stageParameters: VRStageParameters | null;
16122     cancelAnimationFrame(handle: number): void;
16123     exitPresent(): Promise<void>;
16124     getEyeParameters(whichEye: string): VREyeParameters;
16125     getFrameData(frameData: VRFrameData): boolean;
16126     getLayers(): VRLayer[];
16127     /** @deprecated */
16128     getPose(): VRPose;
16129     requestAnimationFrame(callback: FrameRequestCallback): number;
16130     requestPresent(layers: VRLayer[]): Promise<void>;
16131     resetPose(): void;
16132     submitFrame(pose?: VRPose): void;
16133 }
16134
16135 declare var VRDisplay: {
16136     prototype: VRDisplay;
16137     new(): VRDisplay;
16138 };
16139
16140 /** This WebVR API interface describes the capabilities of a VRDisplay — its features can be used to perform VR device capability tests, for example can it return position information. */
16141 interface VRDisplayCapabilities {
16142     readonly canPresent: boolean;
16143     readonly hasExternalDisplay: boolean;
16144     readonly hasOrientation: boolean;
16145     readonly hasPosition: boolean;
16146     readonly maxLayers: number;
16147 }
16148
16149 declare var VRDisplayCapabilities: {
16150     prototype: VRDisplayCapabilities;
16151     new(): VRDisplayCapabilities;
16152 };
16153
16154 /** This WebVR API interface represents represents the event object of WebVR-related events (see the list of WebVR window extensions). */
16155 interface VRDisplayEvent extends Event {
16156     readonly display: VRDisplay;
16157     readonly reason: VRDisplayEventReason | null;
16158 }
16159
16160 declare var VRDisplayEvent: {
16161     prototype: VRDisplayEvent;
16162     new(type: string, eventInitDict: VRDisplayEventInit): VRDisplayEvent;
16163 };
16164
16165 /** This WebVR API interface represents all the information required to correctly render a scene for a given eye, including field of view information. */
16166 interface VREyeParameters {
16167     /** @deprecated */
16168     readonly fieldOfView: VRFieldOfView;
16169     readonly offset: Float32Array;
16170     readonly renderHeight: number;
16171     readonly renderWidth: number;
16172 }
16173
16174 declare var VREyeParameters: {
16175     prototype: VREyeParameters;
16176     new(): VREyeParameters;
16177 };
16178
16179 /** This WebVR API interface represents a field of view defined by 4 different degree values describing the view from a center point. */
16180 interface VRFieldOfView {
16181     readonly downDegrees: number;
16182     readonly leftDegrees: number;
16183     readonly rightDegrees: number;
16184     readonly upDegrees: number;
16185 }
16186
16187 declare var VRFieldOfView: {
16188     prototype: VRFieldOfView;
16189     new(): VRFieldOfView;
16190 };
16191
16192 /** This WebVR API interface represents all the information needed to render a single frame of a VR scene; constructed by VRDisplay.getFrameData(). */
16193 interface VRFrameData {
16194     readonly leftProjectionMatrix: Float32Array;
16195     readonly leftViewMatrix: Float32Array;
16196     readonly pose: VRPose;
16197     readonly rightProjectionMatrix: Float32Array;
16198     readonly rightViewMatrix: Float32Array;
16199     readonly timestamp: number;
16200 }
16201
16202 declare var VRFrameData: {
16203     prototype: VRFrameData;
16204     new(): VRFrameData;
16205 };
16206
16207 /** This WebVR API interface represents the state of a VR sensor at a given timestamp (which includes orientation, position, velocity, and acceleration information.) */
16208 interface VRPose {
16209     readonly angularAcceleration: Float32Array | null;
16210     readonly angularVelocity: Float32Array | null;
16211     readonly linearAcceleration: Float32Array | null;
16212     readonly linearVelocity: Float32Array | null;
16213     readonly orientation: Float32Array | null;
16214     readonly position: Float32Array | null;
16215     readonly timestamp: number;
16216 }
16217
16218 declare var VRPose: {
16219     prototype: VRPose;
16220     new(): VRPose;
16221 };
16222
16223 interface VTTCue extends TextTrackCue {
16224     align: AlignSetting;
16225     line: LineAndPositionSetting;
16226     lineAlign: LineAlignSetting;
16227     position: LineAndPositionSetting;
16228     positionAlign: PositionAlignSetting;
16229     region: VTTRegion | null;
16230     size: number;
16231     snapToLines: boolean;
16232     text: string;
16233     vertical: DirectionSetting;
16234     getCueAsHTML(): DocumentFragment;
16235     addEventListener<K extends keyof TextTrackCueEventMap>(type: K, listener: (this: VTTCue, ev: TextTrackCueEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
16236     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
16237     removeEventListener<K extends keyof TextTrackCueEventMap>(type: K, listener: (this: VTTCue, ev: TextTrackCueEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
16238     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
16239 }
16240
16241 declare var VTTCue: {
16242     prototype: VTTCue;
16243     new(startTime: number, endTime: number, text: string): VTTCue;
16244 };
16245
16246 interface VTTRegion {
16247     id: string;
16248     lines: number;
16249     regionAnchorX: number;
16250     regionAnchorY: number;
16251     scroll: ScrollSetting;
16252     viewportAnchorX: number;
16253     viewportAnchorY: number;
16254     width: number;
16255 }
16256
16257 declare var VTTRegion: {
16258     prototype: VTTRegion;
16259     new(): VTTRegion;
16260 };
16261
16262 /** The validity states that an element can be in, with respect to constraint validation. Together, they help explain why an element's value fails to validate, if it's not valid. */
16263 interface ValidityState {
16264     readonly badInput: boolean;
16265     readonly customError: boolean;
16266     readonly patternMismatch: boolean;
16267     readonly rangeOverflow: boolean;
16268     readonly rangeUnderflow: boolean;
16269     readonly stepMismatch: boolean;
16270     readonly tooLong: boolean;
16271     readonly tooShort: boolean;
16272     readonly typeMismatch: boolean;
16273     readonly valid: boolean;
16274     readonly valueMissing: boolean;
16275 }
16276
16277 declare var ValidityState: {
16278     prototype: ValidityState;
16279     new(): ValidityState;
16280 };
16281
16282 /** Returned by the HTMLVideoElement.getVideoPlaybackQuality() method and contains metrics that can be used to determine the playback quality of a video. */
16283 interface VideoPlaybackQuality {
16284     readonly creationTime: number;
16285     readonly droppedVideoFrames: number;
16286     readonly totalVideoFrames: number;
16287 }
16288
16289 declare var VideoPlaybackQuality: {
16290     prototype: VideoPlaybackQuality;
16291     new(): VideoPlaybackQuality;
16292 };
16293
16294 interface VisualViewportEventMap {
16295     "resize": UIEvent;
16296     "scroll": Event;
16297 }
16298
16299 interface VisualViewport extends EventTarget {
16300     readonly height: number;
16301     readonly offsetLeft: number;
16302     readonly offsetTop: number;
16303     onresize: ((this: VisualViewport, ev: UIEvent) => any) | null;
16304     onscroll: ((this: VisualViewport, ev: Event) => any) | null;
16305     readonly pageLeft: number;
16306     readonly pageTop: number;
16307     readonly scale: number;
16308     readonly width: number;
16309     addEventListener<K extends keyof VisualViewportEventMap>(type: K, listener: (this: VisualViewport, ev: VisualViewportEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
16310     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
16311     removeEventListener<K extends keyof VisualViewportEventMap>(type: K, listener: (this: VisualViewport, ev: VisualViewportEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
16312     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
16313 }
16314
16315 declare var VisualViewport: {
16316     prototype: VisualViewport;
16317     new(): VisualViewport;
16318 };
16319
16320 interface WEBGL_color_buffer_float {
16321     readonly FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE_EXT: GLenum;
16322     readonly RGBA32F_EXT: GLenum;
16323     readonly UNSIGNED_NORMALIZED_EXT: GLenum;
16324 }
16325
16326 interface WEBGL_compressed_texture_astc {
16327     getSupportedProfiles(): string[];
16328     readonly COMPRESSED_RGBA_ASTC_10x10_KHR: GLenum;
16329     readonly COMPRESSED_RGBA_ASTC_10x5_KHR: GLenum;
16330     readonly COMPRESSED_RGBA_ASTC_10x6_KHR: GLenum;
16331     readonly COMPRESSED_RGBA_ASTC_10x8_KHR: GLenum;
16332     readonly COMPRESSED_RGBA_ASTC_12x10_KHR: GLenum;
16333     readonly COMPRESSED_RGBA_ASTC_12x12_KHR: GLenum;
16334     readonly COMPRESSED_RGBA_ASTC_4x4_KHR: GLenum;
16335     readonly COMPRESSED_RGBA_ASTC_5x4_KHR: GLenum;
16336     readonly COMPRESSED_RGBA_ASTC_5x5_KHR: GLenum;
16337     readonly COMPRESSED_RGBA_ASTC_6x5_KHR: GLenum;
16338     readonly COMPRESSED_RGBA_ASTC_6x6_KHR: GLenum;
16339     readonly COMPRESSED_RGBA_ASTC_8x5_KHR: GLenum;
16340     readonly COMPRESSED_RGBA_ASTC_8x6_KHR: GLenum;
16341     readonly COMPRESSED_RGBA_ASTC_8x8_KHR: GLenum;
16342     readonly COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR: GLenum;
16343     readonly COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR: GLenum;
16344     readonly COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR: GLenum;
16345     readonly COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR: GLenum;
16346     readonly COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR: GLenum;
16347     readonly COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR: GLenum;
16348     readonly COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR: GLenum;
16349     readonly COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR: GLenum;
16350     readonly COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR: GLenum;
16351     readonly COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR: GLenum;
16352     readonly COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR: GLenum;
16353     readonly COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR: GLenum;
16354     readonly COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR: GLenum;
16355     readonly COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR: GLenum;
16356 }
16357
16358 /** The WEBGL_compressed_texture_s3tc extension is part of the WebGL API and exposes four S3TC compressed texture formats. */
16359 interface WEBGL_compressed_texture_s3tc {
16360     readonly COMPRESSED_RGBA_S3TC_DXT1_EXT: GLenum;
16361     readonly COMPRESSED_RGBA_S3TC_DXT3_EXT: GLenum;
16362     readonly COMPRESSED_RGBA_S3TC_DXT5_EXT: GLenum;
16363     readonly COMPRESSED_RGB_S3TC_DXT1_EXT: GLenum;
16364 }
16365
16366 interface WEBGL_compressed_texture_s3tc_srgb {
16367     readonly COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT: GLenum;
16368     readonly COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT: GLenum;
16369     readonly COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT: GLenum;
16370     readonly COMPRESSED_SRGB_S3TC_DXT1_EXT: GLenum;
16371 }
16372
16373 /** The WEBGL_debug_renderer_info extension is part of the WebGL API and exposes two constants with information about the graphics driver for debugging purposes. */
16374 interface WEBGL_debug_renderer_info {
16375     readonly UNMASKED_RENDERER_WEBGL: GLenum;
16376     readonly UNMASKED_VENDOR_WEBGL: GLenum;
16377 }
16378
16379 interface WEBGL_debug_shaders {
16380     getTranslatedShaderSource(shader: WebGLShader): string;
16381 }
16382
16383 /** The WEBGL_depth_texture extension is part of the WebGL API and defines 2D depth and depth-stencil textures. */
16384 interface WEBGL_depth_texture {
16385     readonly UNSIGNED_INT_24_8_WEBGL: GLenum;
16386 }
16387
16388 interface WEBGL_draw_buffers {
16389     drawBuffersWEBGL(buffers: GLenum[]): void;
16390     readonly COLOR_ATTACHMENT0_WEBGL: GLenum;
16391     readonly COLOR_ATTACHMENT10_WEBGL: GLenum;
16392     readonly COLOR_ATTACHMENT11_WEBGL: GLenum;
16393     readonly COLOR_ATTACHMENT12_WEBGL: GLenum;
16394     readonly COLOR_ATTACHMENT13_WEBGL: GLenum;
16395     readonly COLOR_ATTACHMENT14_WEBGL: GLenum;
16396     readonly COLOR_ATTACHMENT15_WEBGL: GLenum;
16397     readonly COLOR_ATTACHMENT1_WEBGL: GLenum;
16398     readonly COLOR_ATTACHMENT2_WEBGL: GLenum;
16399     readonly COLOR_ATTACHMENT3_WEBGL: GLenum;
16400     readonly COLOR_ATTACHMENT4_WEBGL: GLenum;
16401     readonly COLOR_ATTACHMENT5_WEBGL: GLenum;
16402     readonly COLOR_ATTACHMENT6_WEBGL: GLenum;
16403     readonly COLOR_ATTACHMENT7_WEBGL: GLenum;
16404     readonly COLOR_ATTACHMENT8_WEBGL: GLenum;
16405     readonly COLOR_ATTACHMENT9_WEBGL: GLenum;
16406     readonly DRAW_BUFFER0_WEBGL: GLenum;
16407     readonly DRAW_BUFFER10_WEBGL: GLenum;
16408     readonly DRAW_BUFFER11_WEBGL: GLenum;
16409     readonly DRAW_BUFFER12_WEBGL: GLenum;
16410     readonly DRAW_BUFFER13_WEBGL: GLenum;
16411     readonly DRAW_BUFFER14_WEBGL: GLenum;
16412     readonly DRAW_BUFFER15_WEBGL: GLenum;
16413     readonly DRAW_BUFFER1_WEBGL: GLenum;
16414     readonly DRAW_BUFFER2_WEBGL: GLenum;
16415     readonly DRAW_BUFFER3_WEBGL: GLenum;
16416     readonly DRAW_BUFFER4_WEBGL: GLenum;
16417     readonly DRAW_BUFFER5_WEBGL: GLenum;
16418     readonly DRAW_BUFFER6_WEBGL: GLenum;
16419     readonly DRAW_BUFFER7_WEBGL: GLenum;
16420     readonly DRAW_BUFFER8_WEBGL: GLenum;
16421     readonly DRAW_BUFFER9_WEBGL: GLenum;
16422     readonly MAX_COLOR_ATTACHMENTS_WEBGL: GLenum;
16423     readonly MAX_DRAW_BUFFERS_WEBGL: GLenum;
16424 }
16425
16426 interface WEBGL_lose_context {
16427     loseContext(): void;
16428     restoreContext(): void;
16429 }
16430
16431 /** A WaveShaperNode always has exactly one input and one output. */
16432 interface WaveShaperNode extends AudioNode {
16433     curve: Float32Array | null;
16434     oversample: OverSampleType;
16435 }
16436
16437 declare var WaveShaperNode: {
16438     prototype: WaveShaperNode;
16439     new(context: BaseAudioContext, options?: WaveShaperOptions): WaveShaperNode;
16440 };
16441
16442 interface WebAuthentication {
16443     getAssertion(assertionChallenge: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer | null, options?: AssertionOptions): Promise<WebAuthnAssertion>;
16444     makeCredential(accountInformation: Account, cryptoParameters: ScopedCredentialParameters[], attestationChallenge: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer | null, options?: ScopedCredentialOptions): Promise<ScopedCredentialInfo>;
16445 }
16446
16447 declare var WebAuthentication: {
16448     prototype: WebAuthentication;
16449     new(): WebAuthentication;
16450 };
16451
16452 interface WebAuthnAssertion {
16453     readonly authenticatorData: ArrayBuffer;
16454     readonly clientData: ArrayBuffer;
16455     readonly credential: ScopedCredential;
16456     readonly signature: ArrayBuffer;
16457 }
16458
16459 declare var WebAuthnAssertion: {
16460     prototype: WebAuthnAssertion;
16461     new(): WebAuthnAssertion;
16462 };
16463
16464 interface WebGL2RenderingContext extends WebGL2RenderingContextBase, WebGL2RenderingContextOverloads, WebGLRenderingContextBase {
16465 }
16466
16467 declare var WebGL2RenderingContext: {
16468     prototype: WebGL2RenderingContext;
16469     new(): WebGL2RenderingContext;
16470     readonly ACTIVE_ATTRIBUTES: GLenum;
16471     readonly ACTIVE_TEXTURE: GLenum;
16472     readonly ACTIVE_UNIFORMS: GLenum;
16473     readonly ALIASED_LINE_WIDTH_RANGE: GLenum;
16474     readonly ALIASED_POINT_SIZE_RANGE: GLenum;
16475     readonly ALPHA: GLenum;
16476     readonly ALPHA_BITS: GLenum;
16477     readonly ALWAYS: GLenum;
16478     readonly ARRAY_BUFFER: GLenum;
16479     readonly ARRAY_BUFFER_BINDING: GLenum;
16480     readonly ATTACHED_SHADERS: GLenum;
16481     readonly BACK: GLenum;
16482     readonly BLEND: GLenum;
16483     readonly BLEND_COLOR: GLenum;
16484     readonly BLEND_DST_ALPHA: GLenum;
16485     readonly BLEND_DST_RGB: GLenum;
16486     readonly BLEND_EQUATION: GLenum;
16487     readonly BLEND_EQUATION_ALPHA: GLenum;
16488     readonly BLEND_EQUATION_RGB: GLenum;
16489     readonly BLEND_SRC_ALPHA: GLenum;
16490     readonly BLEND_SRC_RGB: GLenum;
16491     readonly BLUE_BITS: GLenum;
16492     readonly BOOL: GLenum;
16493     readonly BOOL_VEC2: GLenum;
16494     readonly BOOL_VEC3: GLenum;
16495     readonly BOOL_VEC4: GLenum;
16496     readonly BROWSER_DEFAULT_WEBGL: GLenum;
16497     readonly BUFFER_SIZE: GLenum;
16498     readonly BUFFER_USAGE: GLenum;
16499     readonly BYTE: GLenum;
16500     readonly CCW: GLenum;
16501     readonly CLAMP_TO_EDGE: GLenum;
16502     readonly COLOR_ATTACHMENT0: GLenum;
16503     readonly COLOR_BUFFER_BIT: GLenum;
16504     readonly COLOR_CLEAR_VALUE: GLenum;
16505     readonly COLOR_WRITEMASK: GLenum;
16506     readonly COMPILE_STATUS: GLenum;
16507     readonly COMPRESSED_TEXTURE_FORMATS: GLenum;
16508     readonly CONSTANT_ALPHA: GLenum;
16509     readonly CONSTANT_COLOR: GLenum;
16510     readonly CONTEXT_LOST_WEBGL: GLenum;
16511     readonly CULL_FACE: GLenum;
16512     readonly CULL_FACE_MODE: GLenum;
16513     readonly CURRENT_PROGRAM: GLenum;
16514     readonly CURRENT_VERTEX_ATTRIB: GLenum;
16515     readonly CW: GLenum;
16516     readonly DECR: GLenum;
16517     readonly DECR_WRAP: GLenum;
16518     readonly DELETE_STATUS: GLenum;
16519     readonly DEPTH_ATTACHMENT: GLenum;
16520     readonly DEPTH_BITS: GLenum;
16521     readonly DEPTH_BUFFER_BIT: GLenum;
16522     readonly DEPTH_CLEAR_VALUE: GLenum;
16523     readonly DEPTH_COMPONENT: GLenum;
16524     readonly DEPTH_COMPONENT16: GLenum;
16525     readonly DEPTH_FUNC: GLenum;
16526     readonly DEPTH_RANGE: GLenum;
16527     readonly DEPTH_STENCIL: GLenum;
16528     readonly DEPTH_STENCIL_ATTACHMENT: GLenum;
16529     readonly DEPTH_TEST: GLenum;
16530     readonly DEPTH_WRITEMASK: GLenum;
16531     readonly DITHER: GLenum;
16532     readonly DONT_CARE: GLenum;
16533     readonly DST_ALPHA: GLenum;
16534     readonly DST_COLOR: GLenum;
16535     readonly DYNAMIC_DRAW: GLenum;
16536     readonly ELEMENT_ARRAY_BUFFER: GLenum;
16537     readonly ELEMENT_ARRAY_BUFFER_BINDING: GLenum;
16538     readonly EQUAL: GLenum;
16539     readonly FASTEST: GLenum;
16540     readonly FLOAT: GLenum;
16541     readonly FLOAT_MAT2: GLenum;
16542     readonly FLOAT_MAT3: GLenum;
16543     readonly FLOAT_MAT4: GLenum;
16544     readonly FLOAT_VEC2: GLenum;
16545     readonly FLOAT_VEC3: GLenum;
16546     readonly FLOAT_VEC4: GLenum;
16547     readonly FRAGMENT_SHADER: GLenum;
16548     readonly FRAMEBUFFER: GLenum;
16549     readonly FRAMEBUFFER_ATTACHMENT_OBJECT_NAME: GLenum;
16550     readonly FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE: GLenum;
16551     readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE: GLenum;
16552     readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL: GLenum;
16553     readonly FRAMEBUFFER_BINDING: GLenum;
16554     readonly FRAMEBUFFER_COMPLETE: GLenum;
16555     readonly FRAMEBUFFER_INCOMPLETE_ATTACHMENT: GLenum;
16556     readonly FRAMEBUFFER_INCOMPLETE_DIMENSIONS: GLenum;
16557     readonly FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: GLenum;
16558     readonly FRAMEBUFFER_UNSUPPORTED: GLenum;
16559     readonly FRONT: GLenum;
16560     readonly FRONT_AND_BACK: GLenum;
16561     readonly FRONT_FACE: GLenum;
16562     readonly FUNC_ADD: GLenum;
16563     readonly FUNC_REVERSE_SUBTRACT: GLenum;
16564     readonly FUNC_SUBTRACT: GLenum;
16565     readonly GENERATE_MIPMAP_HINT: GLenum;
16566     readonly GEQUAL: GLenum;
16567     readonly GREATER: GLenum;
16568     readonly GREEN_BITS: GLenum;
16569     readonly HIGH_FLOAT: GLenum;
16570     readonly HIGH_INT: GLenum;
16571     readonly IMPLEMENTATION_COLOR_READ_FORMAT: GLenum;
16572     readonly IMPLEMENTATION_COLOR_READ_TYPE: GLenum;
16573     readonly INCR: GLenum;
16574     readonly INCR_WRAP: GLenum;
16575     readonly INT: GLenum;
16576     readonly INT_VEC2: GLenum;
16577     readonly INT_VEC3: GLenum;
16578     readonly INT_VEC4: GLenum;
16579     readonly INVALID_ENUM: GLenum;
16580     readonly INVALID_FRAMEBUFFER_OPERATION: GLenum;
16581     readonly INVALID_OPERATION: GLenum;
16582     readonly INVALID_VALUE: GLenum;
16583     readonly INVERT: GLenum;
16584     readonly KEEP: GLenum;
16585     readonly LEQUAL: GLenum;
16586     readonly LESS: GLenum;
16587     readonly LINEAR: GLenum;
16588     readonly LINEAR_MIPMAP_LINEAR: GLenum;
16589     readonly LINEAR_MIPMAP_NEAREST: GLenum;
16590     readonly LINES: GLenum;
16591     readonly LINE_LOOP: GLenum;
16592     readonly LINE_STRIP: GLenum;
16593     readonly LINE_WIDTH: GLenum;
16594     readonly LINK_STATUS: GLenum;
16595     readonly LOW_FLOAT: GLenum;
16596     readonly LOW_INT: GLenum;
16597     readonly LUMINANCE: GLenum;
16598     readonly LUMINANCE_ALPHA: GLenum;
16599     readonly MAX_COMBINED_TEXTURE_IMAGE_UNITS: GLenum;
16600     readonly MAX_CUBE_MAP_TEXTURE_SIZE: GLenum;
16601     readonly MAX_FRAGMENT_UNIFORM_VECTORS: GLenum;
16602     readonly MAX_RENDERBUFFER_SIZE: GLenum;
16603     readonly MAX_TEXTURE_IMAGE_UNITS: GLenum;
16604     readonly MAX_TEXTURE_SIZE: GLenum;
16605     readonly MAX_VARYING_VECTORS: GLenum;
16606     readonly MAX_VERTEX_ATTRIBS: GLenum;
16607     readonly MAX_VERTEX_TEXTURE_IMAGE_UNITS: GLenum;
16608     readonly MAX_VERTEX_UNIFORM_VECTORS: GLenum;
16609     readonly MAX_VIEWPORT_DIMS: GLenum;
16610     readonly MEDIUM_FLOAT: GLenum;
16611     readonly MEDIUM_INT: GLenum;
16612     readonly MIRRORED_REPEAT: GLenum;
16613     readonly NEAREST: GLenum;
16614     readonly NEAREST_MIPMAP_LINEAR: GLenum;
16615     readonly NEAREST_MIPMAP_NEAREST: GLenum;
16616     readonly NEVER: GLenum;
16617     readonly NICEST: GLenum;
16618     readonly NONE: GLenum;
16619     readonly NOTEQUAL: GLenum;
16620     readonly NO_ERROR: GLenum;
16621     readonly ONE: GLenum;
16622     readonly ONE_MINUS_CONSTANT_ALPHA: GLenum;
16623     readonly ONE_MINUS_CONSTANT_COLOR: GLenum;
16624     readonly ONE_MINUS_DST_ALPHA: GLenum;
16625     readonly ONE_MINUS_DST_COLOR: GLenum;
16626     readonly ONE_MINUS_SRC_ALPHA: GLenum;
16627     readonly ONE_MINUS_SRC_COLOR: GLenum;
16628     readonly OUT_OF_MEMORY: GLenum;
16629     readonly PACK_ALIGNMENT: GLenum;
16630     readonly POINTS: GLenum;
16631     readonly POLYGON_OFFSET_FACTOR: GLenum;
16632     readonly POLYGON_OFFSET_FILL: GLenum;
16633     readonly POLYGON_OFFSET_UNITS: GLenum;
16634     readonly RED_BITS: GLenum;
16635     readonly RENDERBUFFER: GLenum;
16636     readonly RENDERBUFFER_ALPHA_SIZE: GLenum;
16637     readonly RENDERBUFFER_BINDING: GLenum;
16638     readonly RENDERBUFFER_BLUE_SIZE: GLenum;
16639     readonly RENDERBUFFER_DEPTH_SIZE: GLenum;
16640     readonly RENDERBUFFER_GREEN_SIZE: GLenum;
16641     readonly RENDERBUFFER_HEIGHT: GLenum;
16642     readonly RENDERBUFFER_INTERNAL_FORMAT: GLenum;
16643     readonly RENDERBUFFER_RED_SIZE: GLenum;
16644     readonly RENDERBUFFER_STENCIL_SIZE: GLenum;
16645     readonly RENDERBUFFER_WIDTH: GLenum;
16646     readonly RENDERER: GLenum;
16647     readonly REPEAT: GLenum;
16648     readonly REPLACE: GLenum;
16649     readonly RGB: GLenum;
16650     readonly RGB565: GLenum;
16651     readonly RGB5_A1: GLenum;
16652     readonly RGBA: GLenum;
16653     readonly RGBA4: GLenum;
16654     readonly SAMPLER_2D: GLenum;
16655     readonly SAMPLER_CUBE: GLenum;
16656     readonly SAMPLES: GLenum;
16657     readonly SAMPLE_ALPHA_TO_COVERAGE: GLenum;
16658     readonly SAMPLE_BUFFERS: GLenum;
16659     readonly SAMPLE_COVERAGE: GLenum;
16660     readonly SAMPLE_COVERAGE_INVERT: GLenum;
16661     readonly SAMPLE_COVERAGE_VALUE: GLenum;
16662     readonly SCISSOR_BOX: GLenum;
16663     readonly SCISSOR_TEST: GLenum;
16664     readonly SHADER_TYPE: GLenum;
16665     readonly SHADING_LANGUAGE_VERSION: GLenum;
16666     readonly SHORT: GLenum;
16667     readonly SRC_ALPHA: GLenum;
16668     readonly SRC_ALPHA_SATURATE: GLenum;
16669     readonly SRC_COLOR: GLenum;
16670     readonly STATIC_DRAW: GLenum;
16671     readonly STENCIL_ATTACHMENT: GLenum;
16672     readonly STENCIL_BACK_FAIL: GLenum;
16673     readonly STENCIL_BACK_FUNC: GLenum;
16674     readonly STENCIL_BACK_PASS_DEPTH_FAIL: GLenum;
16675     readonly STENCIL_BACK_PASS_DEPTH_PASS: GLenum;
16676     readonly STENCIL_BACK_REF: GLenum;
16677     readonly STENCIL_BACK_VALUE_MASK: GLenum;
16678     readonly STENCIL_BACK_WRITEMASK: GLenum;
16679     readonly STENCIL_BITS: GLenum;
16680     readonly STENCIL_BUFFER_BIT: GLenum;
16681     readonly STENCIL_CLEAR_VALUE: GLenum;
16682     readonly STENCIL_FAIL: GLenum;
16683     readonly STENCIL_FUNC: GLenum;
16684     readonly STENCIL_INDEX8: GLenum;
16685     readonly STENCIL_PASS_DEPTH_FAIL: GLenum;
16686     readonly STENCIL_PASS_DEPTH_PASS: GLenum;
16687     readonly STENCIL_REF: GLenum;
16688     readonly STENCIL_TEST: GLenum;
16689     readonly STENCIL_VALUE_MASK: GLenum;
16690     readonly STENCIL_WRITEMASK: GLenum;
16691     readonly STREAM_DRAW: GLenum;
16692     readonly SUBPIXEL_BITS: GLenum;
16693     readonly TEXTURE: GLenum;
16694     readonly TEXTURE0: GLenum;
16695     readonly TEXTURE1: GLenum;
16696     readonly TEXTURE10: GLenum;
16697     readonly TEXTURE11: GLenum;
16698     readonly TEXTURE12: GLenum;
16699     readonly TEXTURE13: GLenum;
16700     readonly TEXTURE14: GLenum;
16701     readonly TEXTURE15: GLenum;
16702     readonly TEXTURE16: GLenum;
16703     readonly TEXTURE17: GLenum;
16704     readonly TEXTURE18: GLenum;
16705     readonly TEXTURE19: GLenum;
16706     readonly TEXTURE2: GLenum;
16707     readonly TEXTURE20: GLenum;
16708     readonly TEXTURE21: GLenum;
16709     readonly TEXTURE22: GLenum;
16710     readonly TEXTURE23: GLenum;
16711     readonly TEXTURE24: GLenum;
16712     readonly TEXTURE25: GLenum;
16713     readonly TEXTURE26: GLenum;
16714     readonly TEXTURE27: GLenum;
16715     readonly TEXTURE28: GLenum;
16716     readonly TEXTURE29: GLenum;
16717     readonly TEXTURE3: GLenum;
16718     readonly TEXTURE30: GLenum;
16719     readonly TEXTURE31: GLenum;
16720     readonly TEXTURE4: GLenum;
16721     readonly TEXTURE5: GLenum;
16722     readonly TEXTURE6: GLenum;
16723     readonly TEXTURE7: GLenum;
16724     readonly TEXTURE8: GLenum;
16725     readonly TEXTURE9: GLenum;
16726     readonly TEXTURE_2D: GLenum;
16727     readonly TEXTURE_BINDING_2D: GLenum;
16728     readonly TEXTURE_BINDING_CUBE_MAP: GLenum;
16729     readonly TEXTURE_CUBE_MAP: GLenum;
16730     readonly TEXTURE_CUBE_MAP_NEGATIVE_X: GLenum;
16731     readonly TEXTURE_CUBE_MAP_NEGATIVE_Y: GLenum;
16732     readonly TEXTURE_CUBE_MAP_NEGATIVE_Z: GLenum;
16733     readonly TEXTURE_CUBE_MAP_POSITIVE_X: GLenum;
16734     readonly TEXTURE_CUBE_MAP_POSITIVE_Y: GLenum;
16735     readonly TEXTURE_CUBE_MAP_POSITIVE_Z: GLenum;
16736     readonly TEXTURE_MAG_FILTER: GLenum;
16737     readonly TEXTURE_MIN_FILTER: GLenum;
16738     readonly TEXTURE_WRAP_S: GLenum;
16739     readonly TEXTURE_WRAP_T: GLenum;
16740     readonly TRIANGLES: GLenum;
16741     readonly TRIANGLE_FAN: GLenum;
16742     readonly TRIANGLE_STRIP: GLenum;
16743     readonly UNPACK_ALIGNMENT: GLenum;
16744     readonly UNPACK_COLORSPACE_CONVERSION_WEBGL: GLenum;
16745     readonly UNPACK_FLIP_Y_WEBGL: GLenum;
16746     readonly UNPACK_PREMULTIPLY_ALPHA_WEBGL: GLenum;
16747     readonly UNSIGNED_BYTE: GLenum;
16748     readonly UNSIGNED_INT: GLenum;
16749     readonly UNSIGNED_SHORT: GLenum;
16750     readonly UNSIGNED_SHORT_4_4_4_4: GLenum;
16751     readonly UNSIGNED_SHORT_5_5_5_1: GLenum;
16752     readonly UNSIGNED_SHORT_5_6_5: GLenum;
16753     readonly VALIDATE_STATUS: GLenum;
16754     readonly VENDOR: GLenum;
16755     readonly VERSION: GLenum;
16756     readonly VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: GLenum;
16757     readonly VERTEX_ATTRIB_ARRAY_ENABLED: GLenum;
16758     readonly VERTEX_ATTRIB_ARRAY_NORMALIZED: GLenum;
16759     readonly VERTEX_ATTRIB_ARRAY_POINTER: GLenum;
16760     readonly VERTEX_ATTRIB_ARRAY_SIZE: GLenum;
16761     readonly VERTEX_ATTRIB_ARRAY_STRIDE: GLenum;
16762     readonly VERTEX_ATTRIB_ARRAY_TYPE: GLenum;
16763     readonly VERTEX_SHADER: GLenum;
16764     readonly VIEWPORT: GLenum;
16765     readonly ZERO: GLenum;
16766     readonly ACTIVE_UNIFORM_BLOCKS: GLenum;
16767     readonly ALREADY_SIGNALED: GLenum;
16768     readonly ANY_SAMPLES_PASSED: GLenum;
16769     readonly ANY_SAMPLES_PASSED_CONSERVATIVE: GLenum;
16770     readonly COLOR: GLenum;
16771     readonly COLOR_ATTACHMENT1: GLenum;
16772     readonly COLOR_ATTACHMENT10: GLenum;
16773     readonly COLOR_ATTACHMENT11: GLenum;
16774     readonly COLOR_ATTACHMENT12: GLenum;
16775     readonly COLOR_ATTACHMENT13: GLenum;
16776     readonly COLOR_ATTACHMENT14: GLenum;
16777     readonly COLOR_ATTACHMENT15: GLenum;
16778     readonly COLOR_ATTACHMENT2: GLenum;
16779     readonly COLOR_ATTACHMENT3: GLenum;
16780     readonly COLOR_ATTACHMENT4: GLenum;
16781     readonly COLOR_ATTACHMENT5: GLenum;
16782     readonly COLOR_ATTACHMENT6: GLenum;
16783     readonly COLOR_ATTACHMENT7: GLenum;
16784     readonly COLOR_ATTACHMENT8: GLenum;
16785     readonly COLOR_ATTACHMENT9: GLenum;
16786     readonly COMPARE_REF_TO_TEXTURE: GLenum;
16787     readonly CONDITION_SATISFIED: GLenum;
16788     readonly COPY_READ_BUFFER: GLenum;
16789     readonly COPY_READ_BUFFER_BINDING: GLenum;
16790     readonly COPY_WRITE_BUFFER: GLenum;
16791     readonly COPY_WRITE_BUFFER_BINDING: GLenum;
16792     readonly CURRENT_QUERY: GLenum;
16793     readonly DEPTH: GLenum;
16794     readonly DEPTH24_STENCIL8: GLenum;
16795     readonly DEPTH32F_STENCIL8: GLenum;
16796     readonly DEPTH_COMPONENT24: GLenum;
16797     readonly DEPTH_COMPONENT32F: GLenum;
16798     readonly DRAW_BUFFER0: GLenum;
16799     readonly DRAW_BUFFER1: GLenum;
16800     readonly DRAW_BUFFER10: GLenum;
16801     readonly DRAW_BUFFER11: GLenum;
16802     readonly DRAW_BUFFER12: GLenum;
16803     readonly DRAW_BUFFER13: GLenum;
16804     readonly DRAW_BUFFER14: GLenum;
16805     readonly DRAW_BUFFER15: GLenum;
16806     readonly DRAW_BUFFER2: GLenum;
16807     readonly DRAW_BUFFER3: GLenum;
16808     readonly DRAW_BUFFER4: GLenum;
16809     readonly DRAW_BUFFER5: GLenum;
16810     readonly DRAW_BUFFER6: GLenum;
16811     readonly DRAW_BUFFER7: GLenum;
16812     readonly DRAW_BUFFER8: GLenum;
16813     readonly DRAW_BUFFER9: GLenum;
16814     readonly DRAW_FRAMEBUFFER: GLenum;
16815     readonly DRAW_FRAMEBUFFER_BINDING: GLenum;
16816     readonly DYNAMIC_COPY: GLenum;
16817     readonly DYNAMIC_READ: GLenum;
16818     readonly FLOAT_32_UNSIGNED_INT_24_8_REV: GLenum;
16819     readonly FLOAT_MAT2x3: GLenum;
16820     readonly FLOAT_MAT2x4: GLenum;
16821     readonly FLOAT_MAT3x2: GLenum;
16822     readonly FLOAT_MAT3x4: GLenum;
16823     readonly FLOAT_MAT4x2: GLenum;
16824     readonly FLOAT_MAT4x3: GLenum;
16825     readonly FRAGMENT_SHADER_DERIVATIVE_HINT: GLenum;
16826     readonly FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE: GLenum;
16827     readonly FRAMEBUFFER_ATTACHMENT_BLUE_SIZE: GLenum;
16828     readonly FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING: GLenum;
16829     readonly FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE: GLenum;
16830     readonly FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE: GLenum;
16831     readonly FRAMEBUFFER_ATTACHMENT_GREEN_SIZE: GLenum;
16832     readonly FRAMEBUFFER_ATTACHMENT_RED_SIZE: GLenum;
16833     readonly FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE: GLenum;
16834     readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER: GLenum;
16835     readonly FRAMEBUFFER_DEFAULT: GLenum;
16836     readonly FRAMEBUFFER_INCOMPLETE_MULTISAMPLE: GLenum;
16837     readonly HALF_FLOAT: GLenum;
16838     readonly INTERLEAVED_ATTRIBS: GLenum;
16839     readonly INT_2_10_10_10_REV: GLenum;
16840     readonly INT_SAMPLER_2D: GLenum;
16841     readonly INT_SAMPLER_2D_ARRAY: GLenum;
16842     readonly INT_SAMPLER_3D: GLenum;
16843     readonly INT_SAMPLER_CUBE: GLenum;
16844     readonly INVALID_INDEX: GLenum;
16845     readonly MAX: GLenum;
16846     readonly MAX_3D_TEXTURE_SIZE: GLenum;
16847     readonly MAX_ARRAY_TEXTURE_LAYERS: GLenum;
16848     readonly MAX_CLIENT_WAIT_TIMEOUT_WEBGL: GLenum;
16849     readonly MAX_COLOR_ATTACHMENTS: GLenum;
16850     readonly MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS: GLenum;
16851     readonly MAX_COMBINED_UNIFORM_BLOCKS: GLenum;
16852     readonly MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS: GLenum;
16853     readonly MAX_DRAW_BUFFERS: GLenum;
16854     readonly MAX_ELEMENTS_INDICES: GLenum;
16855     readonly MAX_ELEMENTS_VERTICES: GLenum;
16856     readonly MAX_ELEMENT_INDEX: GLenum;
16857     readonly MAX_FRAGMENT_INPUT_COMPONENTS: GLenum;
16858     readonly MAX_FRAGMENT_UNIFORM_BLOCKS: GLenum;
16859     readonly MAX_FRAGMENT_UNIFORM_COMPONENTS: GLenum;
16860     readonly MAX_PROGRAM_TEXEL_OFFSET: GLenum;
16861     readonly MAX_SAMPLES: GLenum;
16862     readonly MAX_SERVER_WAIT_TIMEOUT: GLenum;
16863     readonly MAX_TEXTURE_LOD_BIAS: GLenum;
16864     readonly MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS: GLenum;
16865     readonly MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS: GLenum;
16866     readonly MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS: GLenum;
16867     readonly MAX_UNIFORM_BLOCK_SIZE: GLenum;
16868     readonly MAX_UNIFORM_BUFFER_BINDINGS: GLenum;
16869     readonly MAX_VARYING_COMPONENTS: GLenum;
16870     readonly MAX_VERTEX_OUTPUT_COMPONENTS: GLenum;
16871     readonly MAX_VERTEX_UNIFORM_BLOCKS: GLenum;
16872     readonly MAX_VERTEX_UNIFORM_COMPONENTS: GLenum;
16873     readonly MIN: GLenum;
16874     readonly MIN_PROGRAM_TEXEL_OFFSET: GLenum;
16875     readonly OBJECT_TYPE: GLenum;
16876     readonly PACK_ROW_LENGTH: GLenum;
16877     readonly PACK_SKIP_PIXELS: GLenum;
16878     readonly PACK_SKIP_ROWS: GLenum;
16879     readonly PIXEL_PACK_BUFFER: GLenum;
16880     readonly PIXEL_PACK_BUFFER_BINDING: GLenum;
16881     readonly PIXEL_UNPACK_BUFFER: GLenum;
16882     readonly PIXEL_UNPACK_BUFFER_BINDING: GLenum;
16883     readonly QUERY_RESULT: GLenum;
16884     readonly QUERY_RESULT_AVAILABLE: GLenum;
16885     readonly R11F_G11F_B10F: GLenum;
16886     readonly R16F: GLenum;
16887     readonly R16I: GLenum;
16888     readonly R16UI: GLenum;
16889     readonly R32F: GLenum;
16890     readonly R32I: GLenum;
16891     readonly R32UI: GLenum;
16892     readonly R8: GLenum;
16893     readonly R8I: GLenum;
16894     readonly R8UI: GLenum;
16895     readonly R8_SNORM: GLenum;
16896     readonly RASTERIZER_DISCARD: GLenum;
16897     readonly READ_BUFFER: GLenum;
16898     readonly READ_FRAMEBUFFER: GLenum;
16899     readonly READ_FRAMEBUFFER_BINDING: GLenum;
16900     readonly RED: GLenum;
16901     readonly RED_INTEGER: GLenum;
16902     readonly RENDERBUFFER_SAMPLES: GLenum;
16903     readonly RG: GLenum;
16904     readonly RG16F: GLenum;
16905     readonly RG16I: GLenum;
16906     readonly RG16UI: GLenum;
16907     readonly RG32F: GLenum;
16908     readonly RG32I: GLenum;
16909     readonly RG32UI: GLenum;
16910     readonly RG8: GLenum;
16911     readonly RG8I: GLenum;
16912     readonly RG8UI: GLenum;
16913     readonly RG8_SNORM: GLenum;
16914     readonly RGB10_A2: GLenum;
16915     readonly RGB10_A2UI: GLenum;
16916     readonly RGB16F: GLenum;
16917     readonly RGB16I: GLenum;
16918     readonly RGB16UI: GLenum;
16919     readonly RGB32F: GLenum;
16920     readonly RGB32I: GLenum;
16921     readonly RGB32UI: GLenum;
16922     readonly RGB8: GLenum;
16923     readonly RGB8I: GLenum;
16924     readonly RGB8UI: GLenum;
16925     readonly RGB8_SNORM: GLenum;
16926     readonly RGB9_E5: GLenum;
16927     readonly RGBA16F: GLenum;
16928     readonly RGBA16I: GLenum;
16929     readonly RGBA16UI: GLenum;
16930     readonly RGBA32F: GLenum;
16931     readonly RGBA32I: GLenum;
16932     readonly RGBA32UI: GLenum;
16933     readonly RGBA8: GLenum;
16934     readonly RGBA8I: GLenum;
16935     readonly RGBA8UI: GLenum;
16936     readonly RGBA8_SNORM: GLenum;
16937     readonly RGBA_INTEGER: GLenum;
16938     readonly RGB_INTEGER: GLenum;
16939     readonly RG_INTEGER: GLenum;
16940     readonly SAMPLER_2D_ARRAY: GLenum;
16941     readonly SAMPLER_2D_ARRAY_SHADOW: GLenum;
16942     readonly SAMPLER_2D_SHADOW: GLenum;
16943     readonly SAMPLER_3D: GLenum;
16944     readonly SAMPLER_BINDING: GLenum;
16945     readonly SAMPLER_CUBE_SHADOW: GLenum;
16946     readonly SEPARATE_ATTRIBS: GLenum;
16947     readonly SIGNALED: GLenum;
16948     readonly SIGNED_NORMALIZED: GLenum;
16949     readonly SRGB: GLenum;
16950     readonly SRGB8: GLenum;
16951     readonly SRGB8_ALPHA8: GLenum;
16952     readonly STATIC_COPY: GLenum;
16953     readonly STATIC_READ: GLenum;
16954     readonly STENCIL: GLenum;
16955     readonly STREAM_COPY: GLenum;
16956     readonly STREAM_READ: GLenum;
16957     readonly SYNC_CONDITION: GLenum;
16958     readonly SYNC_FENCE: GLenum;
16959     readonly SYNC_FLAGS: GLenum;
16960     readonly SYNC_FLUSH_COMMANDS_BIT: GLenum;
16961     readonly SYNC_GPU_COMMANDS_COMPLETE: GLenum;
16962     readonly SYNC_STATUS: GLenum;
16963     readonly TEXTURE_2D_ARRAY: GLenum;
16964     readonly TEXTURE_3D: GLenum;
16965     readonly TEXTURE_BASE_LEVEL: GLenum;
16966     readonly TEXTURE_BINDING_2D_ARRAY: GLenum;
16967     readonly TEXTURE_BINDING_3D: GLenum;
16968     readonly TEXTURE_COMPARE_FUNC: GLenum;
16969     readonly TEXTURE_COMPARE_MODE: GLenum;
16970     readonly TEXTURE_IMMUTABLE_FORMAT: GLenum;
16971     readonly TEXTURE_IMMUTABLE_LEVELS: GLenum;
16972     readonly TEXTURE_MAX_LEVEL: GLenum;
16973     readonly TEXTURE_MAX_LOD: GLenum;
16974     readonly TEXTURE_MIN_LOD: GLenum;
16975     readonly TEXTURE_WRAP_R: GLenum;
16976     readonly TIMEOUT_EXPIRED: GLenum;
16977     readonly TIMEOUT_IGNORED: GLint64;
16978     readonly TRANSFORM_FEEDBACK: GLenum;
16979     readonly TRANSFORM_FEEDBACK_ACTIVE: GLenum;
16980     readonly TRANSFORM_FEEDBACK_BINDING: GLenum;
16981     readonly TRANSFORM_FEEDBACK_BUFFER: GLenum;
16982     readonly TRANSFORM_FEEDBACK_BUFFER_BINDING: GLenum;
16983     readonly TRANSFORM_FEEDBACK_BUFFER_MODE: GLenum;
16984     readonly TRANSFORM_FEEDBACK_BUFFER_SIZE: GLenum;
16985     readonly TRANSFORM_FEEDBACK_BUFFER_START: GLenum;
16986     readonly TRANSFORM_FEEDBACK_PAUSED: GLenum;
16987     readonly TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN: GLenum;
16988     readonly TRANSFORM_FEEDBACK_VARYINGS: GLenum;
16989     readonly UNIFORM_ARRAY_STRIDE: GLenum;
16990     readonly UNIFORM_BLOCK_ACTIVE_UNIFORMS: GLenum;
16991     readonly UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES: GLenum;
16992     readonly UNIFORM_BLOCK_BINDING: GLenum;
16993     readonly UNIFORM_BLOCK_DATA_SIZE: GLenum;
16994     readonly UNIFORM_BLOCK_INDEX: GLenum;
16995     readonly UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER: GLenum;
16996     readonly UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER: GLenum;
16997     readonly UNIFORM_BUFFER: GLenum;
16998     readonly UNIFORM_BUFFER_BINDING: GLenum;
16999     readonly UNIFORM_BUFFER_OFFSET_ALIGNMENT: GLenum;
17000     readonly UNIFORM_BUFFER_SIZE: GLenum;
17001     readonly UNIFORM_BUFFER_START: GLenum;
17002     readonly UNIFORM_IS_ROW_MAJOR: GLenum;
17003     readonly UNIFORM_MATRIX_STRIDE: GLenum;
17004     readonly UNIFORM_OFFSET: GLenum;
17005     readonly UNIFORM_SIZE: GLenum;
17006     readonly UNIFORM_TYPE: GLenum;
17007     readonly UNPACK_IMAGE_HEIGHT: GLenum;
17008     readonly UNPACK_ROW_LENGTH: GLenum;
17009     readonly UNPACK_SKIP_IMAGES: GLenum;
17010     readonly UNPACK_SKIP_PIXELS: GLenum;
17011     readonly UNPACK_SKIP_ROWS: GLenum;
17012     readonly UNSIGNALED: GLenum;
17013     readonly UNSIGNED_INT_10F_11F_11F_REV: GLenum;
17014     readonly UNSIGNED_INT_24_8: GLenum;
17015     readonly UNSIGNED_INT_2_10_10_10_REV: GLenum;
17016     readonly UNSIGNED_INT_5_9_9_9_REV: GLenum;
17017     readonly UNSIGNED_INT_SAMPLER_2D: GLenum;
17018     readonly UNSIGNED_INT_SAMPLER_2D_ARRAY: GLenum;
17019     readonly UNSIGNED_INT_SAMPLER_3D: GLenum;
17020     readonly UNSIGNED_INT_SAMPLER_CUBE: GLenum;
17021     readonly UNSIGNED_INT_VEC2: GLenum;
17022     readonly UNSIGNED_INT_VEC3: GLenum;
17023     readonly UNSIGNED_INT_VEC4: GLenum;
17024     readonly UNSIGNED_NORMALIZED: GLenum;
17025     readonly VERTEX_ARRAY_BINDING: GLenum;
17026     readonly VERTEX_ATTRIB_ARRAY_DIVISOR: GLenum;
17027     readonly VERTEX_ATTRIB_ARRAY_INTEGER: GLenum;
17028     readonly WAIT_FAILED: GLenum;
17029 };
17030
17031 interface WebGL2RenderingContextBase {
17032     beginQuery(target: GLenum, query: WebGLQuery): void;
17033     beginTransformFeedback(primitiveMode: GLenum): void;
17034     bindBufferBase(target: GLenum, index: GLuint, buffer: WebGLBuffer | null): void;
17035     bindBufferRange(target: GLenum, index: GLuint, buffer: WebGLBuffer | null, offset: GLintptr, size: GLsizeiptr): void;
17036     bindSampler(unit: GLuint, sampler: WebGLSampler | null): void;
17037     bindTransformFeedback(target: GLenum, tf: WebGLTransformFeedback | null): void;
17038     bindVertexArray(array: WebGLVertexArrayObject | null): void;
17039     blitFramebuffer(srcX0: GLint, srcY0: GLint, srcX1: GLint, srcY1: GLint, dstX0: GLint, dstY0: GLint, dstX1: GLint, dstY1: GLint, mask: GLbitfield, filter: GLenum): void;
17040     clearBufferfi(buffer: GLenum, drawbuffer: GLint, depth: GLfloat, stencil: GLint): void;
17041     clearBufferfv(buffer: GLenum, drawbuffer: GLint, values: Float32List, srcOffset?: GLuint): void;
17042     clearBufferiv(buffer: GLenum, drawbuffer: GLint, values: Int32List, srcOffset?: GLuint): void;
17043     clearBufferuiv(buffer: GLenum, drawbuffer: GLint, values: Uint32List, srcOffset?: GLuint): void;
17044     clientWaitSync(sync: WebGLSync, flags: GLbitfield, timeout: GLuint64): GLenum;
17045     compressedTexImage3D(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, imageSize: GLsizei, offset: GLintptr): void;
17046     compressedTexImage3D(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, srcData: ArrayBufferView, srcOffset?: GLuint, srcLengthOverride?: GLuint): void;
17047     compressedTexSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, imageSize: GLsizei, offset: GLintptr): void;
17048     compressedTexSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, srcData: ArrayBufferView, srcOffset?: GLuint, srcLengthOverride?: GLuint): void;
17049     copyBufferSubData(readTarget: GLenum, writeTarget: GLenum, readOffset: GLintptr, writeOffset: GLintptr, size: GLsizeiptr): void;
17050     copyTexSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, x: GLint, y: GLint, width: GLsizei, height: GLsizei): void;
17051     createQuery(): WebGLQuery | null;
17052     createSampler(): WebGLSampler | null;
17053     createTransformFeedback(): WebGLTransformFeedback | null;
17054     createVertexArray(): WebGLVertexArrayObject | null;
17055     deleteQuery(query: WebGLQuery | null): void;
17056     deleteSampler(sampler: WebGLSampler | null): void;
17057     deleteSync(sync: WebGLSync | null): void;
17058     deleteTransformFeedback(tf: WebGLTransformFeedback | null): void;
17059     deleteVertexArray(vertexArray: WebGLVertexArrayObject | null): void;
17060     drawArraysInstanced(mode: GLenum, first: GLint, count: GLsizei, instanceCount: GLsizei): void;
17061     drawBuffers(buffers: GLenum[]): void;
17062     drawElementsInstanced(mode: GLenum, count: GLsizei, type: GLenum, offset: GLintptr, instanceCount: GLsizei): void;
17063     drawRangeElements(mode: GLenum, start: GLuint, end: GLuint, count: GLsizei, type: GLenum, offset: GLintptr): void;
17064     endQuery(target: GLenum): void;
17065     endTransformFeedback(): void;
17066     fenceSync(condition: GLenum, flags: GLbitfield): WebGLSync | null;
17067     framebufferTextureLayer(target: GLenum, attachment: GLenum, texture: WebGLTexture | null, level: GLint, layer: GLint): void;
17068     getActiveUniformBlockName(program: WebGLProgram, uniformBlockIndex: GLuint): string | null;
17069     getActiveUniformBlockParameter(program: WebGLProgram, uniformBlockIndex: GLuint, pname: GLenum): any;
17070     getActiveUniforms(program: WebGLProgram, uniformIndices: GLuint[], pname: GLenum): any;
17071     getBufferSubData(target: GLenum, srcByteOffset: GLintptr, dstBuffer: ArrayBufferView, dstOffset?: GLuint, length?: GLuint): void;
17072     getFragDataLocation(program: WebGLProgram, name: string): GLint;
17073     getIndexedParameter(target: GLenum, index: GLuint): any;
17074     getInternalformatParameter(target: GLenum, internalformat: GLenum, pname: GLenum): any;
17075     getQuery(target: GLenum, pname: GLenum): WebGLQuery | null;
17076     getQueryParameter(query: WebGLQuery, pname: GLenum): any;
17077     getSamplerParameter(sampler: WebGLSampler, pname: GLenum): any;
17078     getSyncParameter(sync: WebGLSync, pname: GLenum): any;
17079     getTransformFeedbackVarying(program: WebGLProgram, index: GLuint): WebGLActiveInfo | null;
17080     getUniformBlockIndex(program: WebGLProgram, uniformBlockName: string): GLuint;
17081     getUniformIndices(program: WebGLProgram, uniformNames: string[]): GLuint[] | null;
17082     invalidateFramebuffer(target: GLenum, attachments: GLenum[]): void;
17083     invalidateSubFramebuffer(target: GLenum, attachments: GLenum[], x: GLint, y: GLint, width: GLsizei, height: GLsizei): void;
17084     isQuery(query: WebGLQuery | null): GLboolean;
17085     isSampler(sampler: WebGLSampler | null): GLboolean;
17086     isSync(sync: WebGLSync | null): GLboolean;
17087     isTransformFeedback(tf: WebGLTransformFeedback | null): GLboolean;
17088     isVertexArray(vertexArray: WebGLVertexArrayObject | null): GLboolean;
17089     pauseTransformFeedback(): void;
17090     readBuffer(src: GLenum): void;
17091     renderbufferStorageMultisample(target: GLenum, samples: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei): void;
17092     resumeTransformFeedback(): void;
17093     samplerParameterf(sampler: WebGLSampler, pname: GLenum, param: GLfloat): void;
17094     samplerParameteri(sampler: WebGLSampler, pname: GLenum, param: GLint): void;
17095     texImage3D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, format: GLenum, type: GLenum, pboOffset: GLintptr): void;
17096     texImage3D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, format: GLenum, type: GLenum, source: TexImageSource): void;
17097     texImage3D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, format: GLenum, type: GLenum, srcData: ArrayBufferView | null): void;
17098     texImage3D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, format: GLenum, type: GLenum, srcData: ArrayBufferView, srcOffset: GLuint): void;
17099     texStorage2D(target: GLenum, levels: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei): void;
17100     texStorage3D(target: GLenum, levels: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei): void;
17101     texSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, type: GLenum, pboOffset: GLintptr): void;
17102     texSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, type: GLenum, source: TexImageSource): void;
17103     texSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, type: GLenum, srcData: ArrayBufferView | null, srcOffset?: GLuint): void;
17104     transformFeedbackVaryings(program: WebGLProgram, varyings: string[], bufferMode: GLenum): void;
17105     uniform1ui(location: WebGLUniformLocation | null, v0: GLuint): void;
17106     uniform1uiv(location: WebGLUniformLocation | null, data: Uint32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17107     uniform2ui(location: WebGLUniformLocation | null, v0: GLuint, v1: GLuint): void;
17108     uniform2uiv(location: WebGLUniformLocation | null, data: Uint32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17109     uniform3ui(location: WebGLUniformLocation | null, v0: GLuint, v1: GLuint, v2: GLuint): void;
17110     uniform3uiv(location: WebGLUniformLocation | null, data: Uint32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17111     uniform4ui(location: WebGLUniformLocation | null, v0: GLuint, v1: GLuint, v2: GLuint, v3: GLuint): void;
17112     uniform4uiv(location: WebGLUniformLocation | null, data: Uint32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17113     uniformBlockBinding(program: WebGLProgram, uniformBlockIndex: GLuint, uniformBlockBinding: GLuint): void;
17114     uniformMatrix2x3fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17115     uniformMatrix2x4fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17116     uniformMatrix3x2fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17117     uniformMatrix3x4fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17118     uniformMatrix4x2fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17119     uniformMatrix4x3fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17120     vertexAttribDivisor(index: GLuint, divisor: GLuint): void;
17121     vertexAttribI4i(index: GLuint, x: GLint, y: GLint, z: GLint, w: GLint): void;
17122     vertexAttribI4iv(index: GLuint, values: Int32List): void;
17123     vertexAttribI4ui(index: GLuint, x: GLuint, y: GLuint, z: GLuint, w: GLuint): void;
17124     vertexAttribI4uiv(index: GLuint, values: Uint32List): void;
17125     vertexAttribIPointer(index: GLuint, size: GLint, type: GLenum, stride: GLsizei, offset: GLintptr): void;
17126     waitSync(sync: WebGLSync, flags: GLbitfield, timeout: GLint64): void;
17127     readonly ACTIVE_UNIFORM_BLOCKS: GLenum;
17128     readonly ALREADY_SIGNALED: GLenum;
17129     readonly ANY_SAMPLES_PASSED: GLenum;
17130     readonly ANY_SAMPLES_PASSED_CONSERVATIVE: GLenum;
17131     readonly COLOR: GLenum;
17132     readonly COLOR_ATTACHMENT1: GLenum;
17133     readonly COLOR_ATTACHMENT10: GLenum;
17134     readonly COLOR_ATTACHMENT11: GLenum;
17135     readonly COLOR_ATTACHMENT12: GLenum;
17136     readonly COLOR_ATTACHMENT13: GLenum;
17137     readonly COLOR_ATTACHMENT14: GLenum;
17138     readonly COLOR_ATTACHMENT15: GLenum;
17139     readonly COLOR_ATTACHMENT2: GLenum;
17140     readonly COLOR_ATTACHMENT3: GLenum;
17141     readonly COLOR_ATTACHMENT4: GLenum;
17142     readonly COLOR_ATTACHMENT5: GLenum;
17143     readonly COLOR_ATTACHMENT6: GLenum;
17144     readonly COLOR_ATTACHMENT7: GLenum;
17145     readonly COLOR_ATTACHMENT8: GLenum;
17146     readonly COLOR_ATTACHMENT9: GLenum;
17147     readonly COMPARE_REF_TO_TEXTURE: GLenum;
17148     readonly CONDITION_SATISFIED: GLenum;
17149     readonly COPY_READ_BUFFER: GLenum;
17150     readonly COPY_READ_BUFFER_BINDING: GLenum;
17151     readonly COPY_WRITE_BUFFER: GLenum;
17152     readonly COPY_WRITE_BUFFER_BINDING: GLenum;
17153     readonly CURRENT_QUERY: GLenum;
17154     readonly DEPTH: GLenum;
17155     readonly DEPTH24_STENCIL8: GLenum;
17156     readonly DEPTH32F_STENCIL8: GLenum;
17157     readonly DEPTH_COMPONENT24: GLenum;
17158     readonly DEPTH_COMPONENT32F: GLenum;
17159     readonly DRAW_BUFFER0: GLenum;
17160     readonly DRAW_BUFFER1: GLenum;
17161     readonly DRAW_BUFFER10: GLenum;
17162     readonly DRAW_BUFFER11: GLenum;
17163     readonly DRAW_BUFFER12: GLenum;
17164     readonly DRAW_BUFFER13: GLenum;
17165     readonly DRAW_BUFFER14: GLenum;
17166     readonly DRAW_BUFFER15: GLenum;
17167     readonly DRAW_BUFFER2: GLenum;
17168     readonly DRAW_BUFFER3: GLenum;
17169     readonly DRAW_BUFFER4: GLenum;
17170     readonly DRAW_BUFFER5: GLenum;
17171     readonly DRAW_BUFFER6: GLenum;
17172     readonly DRAW_BUFFER7: GLenum;
17173     readonly DRAW_BUFFER8: GLenum;
17174     readonly DRAW_BUFFER9: GLenum;
17175     readonly DRAW_FRAMEBUFFER: GLenum;
17176     readonly DRAW_FRAMEBUFFER_BINDING: GLenum;
17177     readonly DYNAMIC_COPY: GLenum;
17178     readonly DYNAMIC_READ: GLenum;
17179     readonly FLOAT_32_UNSIGNED_INT_24_8_REV: GLenum;
17180     readonly FLOAT_MAT2x3: GLenum;
17181     readonly FLOAT_MAT2x4: GLenum;
17182     readonly FLOAT_MAT3x2: GLenum;
17183     readonly FLOAT_MAT3x4: GLenum;
17184     readonly FLOAT_MAT4x2: GLenum;
17185     readonly FLOAT_MAT4x3: GLenum;
17186     readonly FRAGMENT_SHADER_DERIVATIVE_HINT: GLenum;
17187     readonly FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE: GLenum;
17188     readonly FRAMEBUFFER_ATTACHMENT_BLUE_SIZE: GLenum;
17189     readonly FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING: GLenum;
17190     readonly FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE: GLenum;
17191     readonly FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE: GLenum;
17192     readonly FRAMEBUFFER_ATTACHMENT_GREEN_SIZE: GLenum;
17193     readonly FRAMEBUFFER_ATTACHMENT_RED_SIZE: GLenum;
17194     readonly FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE: GLenum;
17195     readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER: GLenum;
17196     readonly FRAMEBUFFER_DEFAULT: GLenum;
17197     readonly FRAMEBUFFER_INCOMPLETE_MULTISAMPLE: GLenum;
17198     readonly HALF_FLOAT: GLenum;
17199     readonly INTERLEAVED_ATTRIBS: GLenum;
17200     readonly INT_2_10_10_10_REV: GLenum;
17201     readonly INT_SAMPLER_2D: GLenum;
17202     readonly INT_SAMPLER_2D_ARRAY: GLenum;
17203     readonly INT_SAMPLER_3D: GLenum;
17204     readonly INT_SAMPLER_CUBE: GLenum;
17205     readonly INVALID_INDEX: GLenum;
17206     readonly MAX: GLenum;
17207     readonly MAX_3D_TEXTURE_SIZE: GLenum;
17208     readonly MAX_ARRAY_TEXTURE_LAYERS: GLenum;
17209     readonly MAX_CLIENT_WAIT_TIMEOUT_WEBGL: GLenum;
17210     readonly MAX_COLOR_ATTACHMENTS: GLenum;
17211     readonly MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS: GLenum;
17212     readonly MAX_COMBINED_UNIFORM_BLOCKS: GLenum;
17213     readonly MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS: GLenum;
17214     readonly MAX_DRAW_BUFFERS: GLenum;
17215     readonly MAX_ELEMENTS_INDICES: GLenum;
17216     readonly MAX_ELEMENTS_VERTICES: GLenum;
17217     readonly MAX_ELEMENT_INDEX: GLenum;
17218     readonly MAX_FRAGMENT_INPUT_COMPONENTS: GLenum;
17219     readonly MAX_FRAGMENT_UNIFORM_BLOCKS: GLenum;
17220     readonly MAX_FRAGMENT_UNIFORM_COMPONENTS: GLenum;
17221     readonly MAX_PROGRAM_TEXEL_OFFSET: GLenum;
17222     readonly MAX_SAMPLES: GLenum;
17223     readonly MAX_SERVER_WAIT_TIMEOUT: GLenum;
17224     readonly MAX_TEXTURE_LOD_BIAS: GLenum;
17225     readonly MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS: GLenum;
17226     readonly MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS: GLenum;
17227     readonly MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS: GLenum;
17228     readonly MAX_UNIFORM_BLOCK_SIZE: GLenum;
17229     readonly MAX_UNIFORM_BUFFER_BINDINGS: GLenum;
17230     readonly MAX_VARYING_COMPONENTS: GLenum;
17231     readonly MAX_VERTEX_OUTPUT_COMPONENTS: GLenum;
17232     readonly MAX_VERTEX_UNIFORM_BLOCKS: GLenum;
17233     readonly MAX_VERTEX_UNIFORM_COMPONENTS: GLenum;
17234     readonly MIN: GLenum;
17235     readonly MIN_PROGRAM_TEXEL_OFFSET: GLenum;
17236     readonly OBJECT_TYPE: GLenum;
17237     readonly PACK_ROW_LENGTH: GLenum;
17238     readonly PACK_SKIP_PIXELS: GLenum;
17239     readonly PACK_SKIP_ROWS: GLenum;
17240     readonly PIXEL_PACK_BUFFER: GLenum;
17241     readonly PIXEL_PACK_BUFFER_BINDING: GLenum;
17242     readonly PIXEL_UNPACK_BUFFER: GLenum;
17243     readonly PIXEL_UNPACK_BUFFER_BINDING: GLenum;
17244     readonly QUERY_RESULT: GLenum;
17245     readonly QUERY_RESULT_AVAILABLE: GLenum;
17246     readonly R11F_G11F_B10F: GLenum;
17247     readonly R16F: GLenum;
17248     readonly R16I: GLenum;
17249     readonly R16UI: GLenum;
17250     readonly R32F: GLenum;
17251     readonly R32I: GLenum;
17252     readonly R32UI: GLenum;
17253     readonly R8: GLenum;
17254     readonly R8I: GLenum;
17255     readonly R8UI: GLenum;
17256     readonly R8_SNORM: GLenum;
17257     readonly RASTERIZER_DISCARD: GLenum;
17258     readonly READ_BUFFER: GLenum;
17259     readonly READ_FRAMEBUFFER: GLenum;
17260     readonly READ_FRAMEBUFFER_BINDING: GLenum;
17261     readonly RED: GLenum;
17262     readonly RED_INTEGER: GLenum;
17263     readonly RENDERBUFFER_SAMPLES: GLenum;
17264     readonly RG: GLenum;
17265     readonly RG16F: GLenum;
17266     readonly RG16I: GLenum;
17267     readonly RG16UI: GLenum;
17268     readonly RG32F: GLenum;
17269     readonly RG32I: GLenum;
17270     readonly RG32UI: GLenum;
17271     readonly RG8: GLenum;
17272     readonly RG8I: GLenum;
17273     readonly RG8UI: GLenum;
17274     readonly RG8_SNORM: GLenum;
17275     readonly RGB10_A2: GLenum;
17276     readonly RGB10_A2UI: GLenum;
17277     readonly RGB16F: GLenum;
17278     readonly RGB16I: GLenum;
17279     readonly RGB16UI: GLenum;
17280     readonly RGB32F: GLenum;
17281     readonly RGB32I: GLenum;
17282     readonly RGB32UI: GLenum;
17283     readonly RGB8: GLenum;
17284     readonly RGB8I: GLenum;
17285     readonly RGB8UI: GLenum;
17286     readonly RGB8_SNORM: GLenum;
17287     readonly RGB9_E5: GLenum;
17288     readonly RGBA16F: GLenum;
17289     readonly RGBA16I: GLenum;
17290     readonly RGBA16UI: GLenum;
17291     readonly RGBA32F: GLenum;
17292     readonly RGBA32I: GLenum;
17293     readonly RGBA32UI: GLenum;
17294     readonly RGBA8: GLenum;
17295     readonly RGBA8I: GLenum;
17296     readonly RGBA8UI: GLenum;
17297     readonly RGBA8_SNORM: GLenum;
17298     readonly RGBA_INTEGER: GLenum;
17299     readonly RGB_INTEGER: GLenum;
17300     readonly RG_INTEGER: GLenum;
17301     readonly SAMPLER_2D_ARRAY: GLenum;
17302     readonly SAMPLER_2D_ARRAY_SHADOW: GLenum;
17303     readonly SAMPLER_2D_SHADOW: GLenum;
17304     readonly SAMPLER_3D: GLenum;
17305     readonly SAMPLER_BINDING: GLenum;
17306     readonly SAMPLER_CUBE_SHADOW: GLenum;
17307     readonly SEPARATE_ATTRIBS: GLenum;
17308     readonly SIGNALED: GLenum;
17309     readonly SIGNED_NORMALIZED: GLenum;
17310     readonly SRGB: GLenum;
17311     readonly SRGB8: GLenum;
17312     readonly SRGB8_ALPHA8: GLenum;
17313     readonly STATIC_COPY: GLenum;
17314     readonly STATIC_READ: GLenum;
17315     readonly STENCIL: GLenum;
17316     readonly STREAM_COPY: GLenum;
17317     readonly STREAM_READ: GLenum;
17318     readonly SYNC_CONDITION: GLenum;
17319     readonly SYNC_FENCE: GLenum;
17320     readonly SYNC_FLAGS: GLenum;
17321     readonly SYNC_FLUSH_COMMANDS_BIT: GLenum;
17322     readonly SYNC_GPU_COMMANDS_COMPLETE: GLenum;
17323     readonly SYNC_STATUS: GLenum;
17324     readonly TEXTURE_2D_ARRAY: GLenum;
17325     readonly TEXTURE_3D: GLenum;
17326     readonly TEXTURE_BASE_LEVEL: GLenum;
17327     readonly TEXTURE_BINDING_2D_ARRAY: GLenum;
17328     readonly TEXTURE_BINDING_3D: GLenum;
17329     readonly TEXTURE_COMPARE_FUNC: GLenum;
17330     readonly TEXTURE_COMPARE_MODE: GLenum;
17331     readonly TEXTURE_IMMUTABLE_FORMAT: GLenum;
17332     readonly TEXTURE_IMMUTABLE_LEVELS: GLenum;
17333     readonly TEXTURE_MAX_LEVEL: GLenum;
17334     readonly TEXTURE_MAX_LOD: GLenum;
17335     readonly TEXTURE_MIN_LOD: GLenum;
17336     readonly TEXTURE_WRAP_R: GLenum;
17337     readonly TIMEOUT_EXPIRED: GLenum;
17338     readonly TIMEOUT_IGNORED: GLint64;
17339     readonly TRANSFORM_FEEDBACK: GLenum;
17340     readonly TRANSFORM_FEEDBACK_ACTIVE: GLenum;
17341     readonly TRANSFORM_FEEDBACK_BINDING: GLenum;
17342     readonly TRANSFORM_FEEDBACK_BUFFER: GLenum;
17343     readonly TRANSFORM_FEEDBACK_BUFFER_BINDING: GLenum;
17344     readonly TRANSFORM_FEEDBACK_BUFFER_MODE: GLenum;
17345     readonly TRANSFORM_FEEDBACK_BUFFER_SIZE: GLenum;
17346     readonly TRANSFORM_FEEDBACK_BUFFER_START: GLenum;
17347     readonly TRANSFORM_FEEDBACK_PAUSED: GLenum;
17348     readonly TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN: GLenum;
17349     readonly TRANSFORM_FEEDBACK_VARYINGS: GLenum;
17350     readonly UNIFORM_ARRAY_STRIDE: GLenum;
17351     readonly UNIFORM_BLOCK_ACTIVE_UNIFORMS: GLenum;
17352     readonly UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES: GLenum;
17353     readonly UNIFORM_BLOCK_BINDING: GLenum;
17354     readonly UNIFORM_BLOCK_DATA_SIZE: GLenum;
17355     readonly UNIFORM_BLOCK_INDEX: GLenum;
17356     readonly UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER: GLenum;
17357     readonly UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER: GLenum;
17358     readonly UNIFORM_BUFFER: GLenum;
17359     readonly UNIFORM_BUFFER_BINDING: GLenum;
17360     readonly UNIFORM_BUFFER_OFFSET_ALIGNMENT: GLenum;
17361     readonly UNIFORM_BUFFER_SIZE: GLenum;
17362     readonly UNIFORM_BUFFER_START: GLenum;
17363     readonly UNIFORM_IS_ROW_MAJOR: GLenum;
17364     readonly UNIFORM_MATRIX_STRIDE: GLenum;
17365     readonly UNIFORM_OFFSET: GLenum;
17366     readonly UNIFORM_SIZE: GLenum;
17367     readonly UNIFORM_TYPE: GLenum;
17368     readonly UNPACK_IMAGE_HEIGHT: GLenum;
17369     readonly UNPACK_ROW_LENGTH: GLenum;
17370     readonly UNPACK_SKIP_IMAGES: GLenum;
17371     readonly UNPACK_SKIP_PIXELS: GLenum;
17372     readonly UNPACK_SKIP_ROWS: GLenum;
17373     readonly UNSIGNALED: GLenum;
17374     readonly UNSIGNED_INT_10F_11F_11F_REV: GLenum;
17375     readonly UNSIGNED_INT_24_8: GLenum;
17376     readonly UNSIGNED_INT_2_10_10_10_REV: GLenum;
17377     readonly UNSIGNED_INT_5_9_9_9_REV: GLenum;
17378     readonly UNSIGNED_INT_SAMPLER_2D: GLenum;
17379     readonly UNSIGNED_INT_SAMPLER_2D_ARRAY: GLenum;
17380     readonly UNSIGNED_INT_SAMPLER_3D: GLenum;
17381     readonly UNSIGNED_INT_SAMPLER_CUBE: GLenum;
17382     readonly UNSIGNED_INT_VEC2: GLenum;
17383     readonly UNSIGNED_INT_VEC3: GLenum;
17384     readonly UNSIGNED_INT_VEC4: GLenum;
17385     readonly UNSIGNED_NORMALIZED: GLenum;
17386     readonly VERTEX_ARRAY_BINDING: GLenum;
17387     readonly VERTEX_ATTRIB_ARRAY_DIVISOR: GLenum;
17388     readonly VERTEX_ATTRIB_ARRAY_INTEGER: GLenum;
17389     readonly WAIT_FAILED: GLenum;
17390 }
17391
17392 interface WebGL2RenderingContextOverloads {
17393     bufferData(target: GLenum, size: GLsizeiptr, usage: GLenum): void;
17394     bufferData(target: GLenum, srcData: BufferSource | null, usage: GLenum): void;
17395     bufferData(target: GLenum, srcData: ArrayBufferView, usage: GLenum, srcOffset: GLuint, length?: GLuint): void;
17396     bufferSubData(target: GLenum, dstByteOffset: GLintptr, srcData: BufferSource): void;
17397     bufferSubData(target: GLenum, dstByteOffset: GLintptr, srcData: ArrayBufferView, srcOffset: GLuint, length?: GLuint): void;
17398     compressedTexImage2D(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, border: GLint, imageSize: GLsizei, offset: GLintptr): void;
17399     compressedTexImage2D(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, border: GLint, srcData: ArrayBufferView, srcOffset?: GLuint, srcLengthOverride?: GLuint): void;
17400     compressedTexSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, imageSize: GLsizei, offset: GLintptr): void;
17401     compressedTexSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, srcData: ArrayBufferView, srcOffset?: GLuint, srcLengthOverride?: GLuint): void;
17402     readPixels(x: GLint, y: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, dstData: ArrayBufferView | null): void;
17403     readPixels(x: GLint, y: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, offset: GLintptr): void;
17404     readPixels(x: GLint, y: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, dstData: ArrayBufferView, dstOffset: GLuint): void;
17405     texImage2D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, border: GLint, format: GLenum, type: GLenum, pixels: ArrayBufferView | null): void;
17406     texImage2D(target: GLenum, level: GLint, internalformat: GLint, format: GLenum, type: GLenum, source: TexImageSource): void;
17407     texImage2D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, border: GLint, format: GLenum, type: GLenum, pboOffset: GLintptr): void;
17408     texImage2D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, border: GLint, format: GLenum, type: GLenum, source: TexImageSource): void;
17409     texImage2D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, border: GLint, format: GLenum, type: GLenum, srcData: ArrayBufferView, srcOffset: GLuint): void;
17410     texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, pixels: ArrayBufferView | null): void;
17411     texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, format: GLenum, type: GLenum, source: TexImageSource): void;
17412     texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, pboOffset: GLintptr): void;
17413     texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, source: TexImageSource): void;
17414     texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, srcData: ArrayBufferView, srcOffset: GLuint): void;
17415     uniform1fv(location: WebGLUniformLocation | null, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17416     uniform1iv(location: WebGLUniformLocation | null, data: Int32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17417     uniform2fv(location: WebGLUniformLocation | null, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17418     uniform2iv(location: WebGLUniformLocation | null, data: Int32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17419     uniform3fv(location: WebGLUniformLocation | null, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17420     uniform3iv(location: WebGLUniformLocation | null, data: Int32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17421     uniform4fv(location: WebGLUniformLocation | null, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17422     uniform4iv(location: WebGLUniformLocation | null, data: Int32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17423     uniformMatrix2fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17424     uniformMatrix3fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17425     uniformMatrix4fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17426 }
17427
17428 /** Part of the WebGL API and represents the information returned by calling the WebGLRenderingContext.getActiveAttrib() and WebGLRenderingContext.getActiveUniform() methods. */
17429 interface WebGLActiveInfo {
17430     readonly name: string;
17431     readonly size: GLint;
17432     readonly type: GLenum;
17433 }
17434
17435 declare var WebGLActiveInfo: {
17436     prototype: WebGLActiveInfo;
17437     new(): WebGLActiveInfo;
17438 };
17439
17440 /** Part of the WebGL API and represents an opaque buffer object storing data such as vertices or colors. */
17441 interface WebGLBuffer extends WebGLObject {
17442 }
17443
17444 declare var WebGLBuffer: {
17445     prototype: WebGLBuffer;
17446     new(): WebGLBuffer;
17447 };
17448
17449 /** The WebContextEvent interface is part of the WebGL API and is an interface for an event that is generated in response to a status change to the WebGL rendering context. */
17450 interface WebGLContextEvent extends Event {
17451     readonly statusMessage: string;
17452 }
17453
17454 declare var WebGLContextEvent: {
17455     prototype: WebGLContextEvent;
17456     new(type: string, eventInit?: WebGLContextEventInit): WebGLContextEvent;
17457 };
17458
17459 /** Part of the WebGL API and represents a collection of buffers that serve as a rendering destination. */
17460 interface WebGLFramebuffer extends WebGLObject {
17461 }
17462
17463 declare var WebGLFramebuffer: {
17464     prototype: WebGLFramebuffer;
17465     new(): WebGLFramebuffer;
17466 };
17467
17468 interface WebGLObject {
17469 }
17470
17471 declare var WebGLObject: {
17472     prototype: WebGLObject;
17473     new(): WebGLObject;
17474 };
17475
17476 /** The WebGLProgram is part of the WebGL API and is a combination of two compiled WebGLShaders consisting of a vertex shader and a fragment shader (both written in GLSL). */
17477 interface WebGLProgram extends WebGLObject {
17478 }
17479
17480 declare var WebGLProgram: {
17481     prototype: WebGLProgram;
17482     new(): WebGLProgram;
17483 };
17484
17485 interface WebGLQuery extends WebGLObject {
17486 }
17487
17488 declare var WebGLQuery: {
17489     prototype: WebGLQuery;
17490     new(): WebGLQuery;
17491 };
17492
17493 /** Part of the WebGL API and represents a buffer that can contain an image, or can be source or target of an rendering operation. */
17494 interface WebGLRenderbuffer extends WebGLObject {
17495 }
17496
17497 declare var WebGLRenderbuffer: {
17498     prototype: WebGLRenderbuffer;
17499     new(): WebGLRenderbuffer;
17500 };
17501
17502 /** Provides an interface to the OpenGL ES 2.0 graphics rendering context for the drawing surface of an HTML <canvas> element. */
17503 interface WebGLRenderingContext extends WebGLRenderingContextBase, WebGLRenderingContextOverloads {
17504 }
17505
17506 declare var WebGLRenderingContext: {
17507     prototype: WebGLRenderingContext;
17508     new(): WebGLRenderingContext;
17509     readonly ACTIVE_ATTRIBUTES: GLenum;
17510     readonly ACTIVE_TEXTURE: GLenum;
17511     readonly ACTIVE_UNIFORMS: GLenum;
17512     readonly ALIASED_LINE_WIDTH_RANGE: GLenum;
17513     readonly ALIASED_POINT_SIZE_RANGE: GLenum;
17514     readonly ALPHA: GLenum;
17515     readonly ALPHA_BITS: GLenum;
17516     readonly ALWAYS: GLenum;
17517     readonly ARRAY_BUFFER: GLenum;
17518     readonly ARRAY_BUFFER_BINDING: GLenum;
17519     readonly ATTACHED_SHADERS: GLenum;
17520     readonly BACK: GLenum;
17521     readonly BLEND: GLenum;
17522     readonly BLEND_COLOR: GLenum;
17523     readonly BLEND_DST_ALPHA: GLenum;
17524     readonly BLEND_DST_RGB: GLenum;
17525     readonly BLEND_EQUATION: GLenum;
17526     readonly BLEND_EQUATION_ALPHA: GLenum;
17527     readonly BLEND_EQUATION_RGB: GLenum;
17528     readonly BLEND_SRC_ALPHA: GLenum;
17529     readonly BLEND_SRC_RGB: GLenum;
17530     readonly BLUE_BITS: GLenum;
17531     readonly BOOL: GLenum;
17532     readonly BOOL_VEC2: GLenum;
17533     readonly BOOL_VEC3: GLenum;
17534     readonly BOOL_VEC4: GLenum;
17535     readonly BROWSER_DEFAULT_WEBGL: GLenum;
17536     readonly BUFFER_SIZE: GLenum;
17537     readonly BUFFER_USAGE: GLenum;
17538     readonly BYTE: GLenum;
17539     readonly CCW: GLenum;
17540     readonly CLAMP_TO_EDGE: GLenum;
17541     readonly COLOR_ATTACHMENT0: GLenum;
17542     readonly COLOR_BUFFER_BIT: GLenum;
17543     readonly COLOR_CLEAR_VALUE: GLenum;
17544     readonly COLOR_WRITEMASK: GLenum;
17545     readonly COMPILE_STATUS: GLenum;
17546     readonly COMPRESSED_TEXTURE_FORMATS: GLenum;
17547     readonly CONSTANT_ALPHA: GLenum;
17548     readonly CONSTANT_COLOR: GLenum;
17549     readonly CONTEXT_LOST_WEBGL: GLenum;
17550     readonly CULL_FACE: GLenum;
17551     readonly CULL_FACE_MODE: GLenum;
17552     readonly CURRENT_PROGRAM: GLenum;
17553     readonly CURRENT_VERTEX_ATTRIB: GLenum;
17554     readonly CW: GLenum;
17555     readonly DECR: GLenum;
17556     readonly DECR_WRAP: GLenum;
17557     readonly DELETE_STATUS: GLenum;
17558     readonly DEPTH_ATTACHMENT: GLenum;
17559     readonly DEPTH_BITS: GLenum;
17560     readonly DEPTH_BUFFER_BIT: GLenum;
17561     readonly DEPTH_CLEAR_VALUE: GLenum;
17562     readonly DEPTH_COMPONENT: GLenum;
17563     readonly DEPTH_COMPONENT16: GLenum;
17564     readonly DEPTH_FUNC: GLenum;
17565     readonly DEPTH_RANGE: GLenum;
17566     readonly DEPTH_STENCIL: GLenum;
17567     readonly DEPTH_STENCIL_ATTACHMENT: GLenum;
17568     readonly DEPTH_TEST: GLenum;
17569     readonly DEPTH_WRITEMASK: GLenum;
17570     readonly DITHER: GLenum;
17571     readonly DONT_CARE: GLenum;
17572     readonly DST_ALPHA: GLenum;
17573     readonly DST_COLOR: GLenum;
17574     readonly DYNAMIC_DRAW: GLenum;
17575     readonly ELEMENT_ARRAY_BUFFER: GLenum;
17576     readonly ELEMENT_ARRAY_BUFFER_BINDING: GLenum;
17577     readonly EQUAL: GLenum;
17578     readonly FASTEST: GLenum;
17579     readonly FLOAT: GLenum;
17580     readonly FLOAT_MAT2: GLenum;
17581     readonly FLOAT_MAT3: GLenum;
17582     readonly FLOAT_MAT4: GLenum;
17583     readonly FLOAT_VEC2: GLenum;
17584     readonly FLOAT_VEC3: GLenum;
17585     readonly FLOAT_VEC4: GLenum;
17586     readonly FRAGMENT_SHADER: GLenum;
17587     readonly FRAMEBUFFER: GLenum;
17588     readonly FRAMEBUFFER_ATTACHMENT_OBJECT_NAME: GLenum;
17589     readonly FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE: GLenum;
17590     readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE: GLenum;
17591     readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL: GLenum;
17592     readonly FRAMEBUFFER_BINDING: GLenum;
17593     readonly FRAMEBUFFER_COMPLETE: GLenum;
17594     readonly FRAMEBUFFER_INCOMPLETE_ATTACHMENT: GLenum;
17595     readonly FRAMEBUFFER_INCOMPLETE_DIMENSIONS: GLenum;
17596     readonly FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: GLenum;
17597     readonly FRAMEBUFFER_UNSUPPORTED: GLenum;
17598     readonly FRONT: GLenum;
17599     readonly FRONT_AND_BACK: GLenum;
17600     readonly FRONT_FACE: GLenum;
17601     readonly FUNC_ADD: GLenum;
17602     readonly FUNC_REVERSE_SUBTRACT: GLenum;
17603     readonly FUNC_SUBTRACT: GLenum;
17604     readonly GENERATE_MIPMAP_HINT: GLenum;
17605     readonly GEQUAL: GLenum;
17606     readonly GREATER: GLenum;
17607     readonly GREEN_BITS: GLenum;
17608     readonly HIGH_FLOAT: GLenum;
17609     readonly HIGH_INT: GLenum;
17610     readonly IMPLEMENTATION_COLOR_READ_FORMAT: GLenum;
17611     readonly IMPLEMENTATION_COLOR_READ_TYPE: GLenum;
17612     readonly INCR: GLenum;
17613     readonly INCR_WRAP: GLenum;
17614     readonly INT: GLenum;
17615     readonly INT_VEC2: GLenum;
17616     readonly INT_VEC3: GLenum;
17617     readonly INT_VEC4: GLenum;
17618     readonly INVALID_ENUM: GLenum;
17619     readonly INVALID_FRAMEBUFFER_OPERATION: GLenum;
17620     readonly INVALID_OPERATION: GLenum;
17621     readonly INVALID_VALUE: GLenum;
17622     readonly INVERT: GLenum;
17623     readonly KEEP: GLenum;
17624     readonly LEQUAL: GLenum;
17625     readonly LESS: GLenum;
17626     readonly LINEAR: GLenum;
17627     readonly LINEAR_MIPMAP_LINEAR: GLenum;
17628     readonly LINEAR_MIPMAP_NEAREST: GLenum;
17629     readonly LINES: GLenum;
17630     readonly LINE_LOOP: GLenum;
17631     readonly LINE_STRIP: GLenum;
17632     readonly LINE_WIDTH: GLenum;
17633     readonly LINK_STATUS: GLenum;
17634     readonly LOW_FLOAT: GLenum;
17635     readonly LOW_INT: GLenum;
17636     readonly LUMINANCE: GLenum;
17637     readonly LUMINANCE_ALPHA: GLenum;
17638     readonly MAX_COMBINED_TEXTURE_IMAGE_UNITS: GLenum;
17639     readonly MAX_CUBE_MAP_TEXTURE_SIZE: GLenum;
17640     readonly MAX_FRAGMENT_UNIFORM_VECTORS: GLenum;
17641     readonly MAX_RENDERBUFFER_SIZE: GLenum;
17642     readonly MAX_TEXTURE_IMAGE_UNITS: GLenum;
17643     readonly MAX_TEXTURE_SIZE: GLenum;
17644     readonly MAX_VARYING_VECTORS: GLenum;
17645     readonly MAX_VERTEX_ATTRIBS: GLenum;
17646     readonly MAX_VERTEX_TEXTURE_IMAGE_UNITS: GLenum;
17647     readonly MAX_VERTEX_UNIFORM_VECTORS: GLenum;
17648     readonly MAX_VIEWPORT_DIMS: GLenum;
17649     readonly MEDIUM_FLOAT: GLenum;
17650     readonly MEDIUM_INT: GLenum;
17651     readonly MIRRORED_REPEAT: GLenum;
17652     readonly NEAREST: GLenum;
17653     readonly NEAREST_MIPMAP_LINEAR: GLenum;
17654     readonly NEAREST_MIPMAP_NEAREST: GLenum;
17655     readonly NEVER: GLenum;
17656     readonly NICEST: GLenum;
17657     readonly NONE: GLenum;
17658     readonly NOTEQUAL: GLenum;
17659     readonly NO_ERROR: GLenum;
17660     readonly ONE: GLenum;
17661     readonly ONE_MINUS_CONSTANT_ALPHA: GLenum;
17662     readonly ONE_MINUS_CONSTANT_COLOR: GLenum;
17663     readonly ONE_MINUS_DST_ALPHA: GLenum;
17664     readonly ONE_MINUS_DST_COLOR: GLenum;
17665     readonly ONE_MINUS_SRC_ALPHA: GLenum;
17666     readonly ONE_MINUS_SRC_COLOR: GLenum;
17667     readonly OUT_OF_MEMORY: GLenum;
17668     readonly PACK_ALIGNMENT: GLenum;
17669     readonly POINTS: GLenum;
17670     readonly POLYGON_OFFSET_FACTOR: GLenum;
17671     readonly POLYGON_OFFSET_FILL: GLenum;
17672     readonly POLYGON_OFFSET_UNITS: GLenum;
17673     readonly RED_BITS: GLenum;
17674     readonly RENDERBUFFER: GLenum;
17675     readonly RENDERBUFFER_ALPHA_SIZE: GLenum;
17676     readonly RENDERBUFFER_BINDING: GLenum;
17677     readonly RENDERBUFFER_BLUE_SIZE: GLenum;
17678     readonly RENDERBUFFER_DEPTH_SIZE: GLenum;
17679     readonly RENDERBUFFER_GREEN_SIZE: GLenum;
17680     readonly RENDERBUFFER_HEIGHT: GLenum;
17681     readonly RENDERBUFFER_INTERNAL_FORMAT: GLenum;
17682     readonly RENDERBUFFER_RED_SIZE: GLenum;
17683     readonly RENDERBUFFER_STENCIL_SIZE: GLenum;
17684     readonly RENDERBUFFER_WIDTH: GLenum;
17685     readonly RENDERER: GLenum;
17686     readonly REPEAT: GLenum;
17687     readonly REPLACE: GLenum;
17688     readonly RGB: GLenum;
17689     readonly RGB565: GLenum;
17690     readonly RGB5_A1: GLenum;
17691     readonly RGBA: GLenum;
17692     readonly RGBA4: GLenum;
17693     readonly SAMPLER_2D: GLenum;
17694     readonly SAMPLER_CUBE: GLenum;
17695     readonly SAMPLES: GLenum;
17696     readonly SAMPLE_ALPHA_TO_COVERAGE: GLenum;
17697     readonly SAMPLE_BUFFERS: GLenum;
17698     readonly SAMPLE_COVERAGE: GLenum;
17699     readonly SAMPLE_COVERAGE_INVERT: GLenum;
17700     readonly SAMPLE_COVERAGE_VALUE: GLenum;
17701     readonly SCISSOR_BOX: GLenum;
17702     readonly SCISSOR_TEST: GLenum;
17703     readonly SHADER_TYPE: GLenum;
17704     readonly SHADING_LANGUAGE_VERSION: GLenum;
17705     readonly SHORT: GLenum;
17706     readonly SRC_ALPHA: GLenum;
17707     readonly SRC_ALPHA_SATURATE: GLenum;
17708     readonly SRC_COLOR: GLenum;
17709     readonly STATIC_DRAW: GLenum;
17710     readonly STENCIL_ATTACHMENT: GLenum;
17711     readonly STENCIL_BACK_FAIL: GLenum;
17712     readonly STENCIL_BACK_FUNC: GLenum;
17713     readonly STENCIL_BACK_PASS_DEPTH_FAIL: GLenum;
17714     readonly STENCIL_BACK_PASS_DEPTH_PASS: GLenum;
17715     readonly STENCIL_BACK_REF: GLenum;
17716     readonly STENCIL_BACK_VALUE_MASK: GLenum;
17717     readonly STENCIL_BACK_WRITEMASK: GLenum;
17718     readonly STENCIL_BITS: GLenum;
17719     readonly STENCIL_BUFFER_BIT: GLenum;
17720     readonly STENCIL_CLEAR_VALUE: GLenum;
17721     readonly STENCIL_FAIL: GLenum;
17722     readonly STENCIL_FUNC: GLenum;
17723     readonly STENCIL_INDEX8: GLenum;
17724     readonly STENCIL_PASS_DEPTH_FAIL: GLenum;
17725     readonly STENCIL_PASS_DEPTH_PASS: GLenum;
17726     readonly STENCIL_REF: GLenum;
17727     readonly STENCIL_TEST: GLenum;
17728     readonly STENCIL_VALUE_MASK: GLenum;
17729     readonly STENCIL_WRITEMASK: GLenum;
17730     readonly STREAM_DRAW: GLenum;
17731     readonly SUBPIXEL_BITS: GLenum;
17732     readonly TEXTURE: GLenum;
17733     readonly TEXTURE0: GLenum;
17734     readonly TEXTURE1: GLenum;
17735     readonly TEXTURE10: GLenum;
17736     readonly TEXTURE11: GLenum;
17737     readonly TEXTURE12: GLenum;
17738     readonly TEXTURE13: GLenum;
17739     readonly TEXTURE14: GLenum;
17740     readonly TEXTURE15: GLenum;
17741     readonly TEXTURE16: GLenum;
17742     readonly TEXTURE17: GLenum;
17743     readonly TEXTURE18: GLenum;
17744     readonly TEXTURE19: GLenum;
17745     readonly TEXTURE2: GLenum;
17746     readonly TEXTURE20: GLenum;
17747     readonly TEXTURE21: GLenum;
17748     readonly TEXTURE22: GLenum;
17749     readonly TEXTURE23: GLenum;
17750     readonly TEXTURE24: GLenum;
17751     readonly TEXTURE25: GLenum;
17752     readonly TEXTURE26: GLenum;
17753     readonly TEXTURE27: GLenum;
17754     readonly TEXTURE28: GLenum;
17755     readonly TEXTURE29: GLenum;
17756     readonly TEXTURE3: GLenum;
17757     readonly TEXTURE30: GLenum;
17758     readonly TEXTURE31: GLenum;
17759     readonly TEXTURE4: GLenum;
17760     readonly TEXTURE5: GLenum;
17761     readonly TEXTURE6: GLenum;
17762     readonly TEXTURE7: GLenum;
17763     readonly TEXTURE8: GLenum;
17764     readonly TEXTURE9: GLenum;
17765     readonly TEXTURE_2D: GLenum;
17766     readonly TEXTURE_BINDING_2D: GLenum;
17767     readonly TEXTURE_BINDING_CUBE_MAP: GLenum;
17768     readonly TEXTURE_CUBE_MAP: GLenum;
17769     readonly TEXTURE_CUBE_MAP_NEGATIVE_X: GLenum;
17770     readonly TEXTURE_CUBE_MAP_NEGATIVE_Y: GLenum;
17771     readonly TEXTURE_CUBE_MAP_NEGATIVE_Z: GLenum;
17772     readonly TEXTURE_CUBE_MAP_POSITIVE_X: GLenum;
17773     readonly TEXTURE_CUBE_MAP_POSITIVE_Y: GLenum;
17774     readonly TEXTURE_CUBE_MAP_POSITIVE_Z: GLenum;
17775     readonly TEXTURE_MAG_FILTER: GLenum;
17776     readonly TEXTURE_MIN_FILTER: GLenum;
17777     readonly TEXTURE_WRAP_S: GLenum;
17778     readonly TEXTURE_WRAP_T: GLenum;
17779     readonly TRIANGLES: GLenum;
17780     readonly TRIANGLE_FAN: GLenum;
17781     readonly TRIANGLE_STRIP: GLenum;
17782     readonly UNPACK_ALIGNMENT: GLenum;
17783     readonly UNPACK_COLORSPACE_CONVERSION_WEBGL: GLenum;
17784     readonly UNPACK_FLIP_Y_WEBGL: GLenum;
17785     readonly UNPACK_PREMULTIPLY_ALPHA_WEBGL: GLenum;
17786     readonly UNSIGNED_BYTE: GLenum;
17787     readonly UNSIGNED_INT: GLenum;
17788     readonly UNSIGNED_SHORT: GLenum;
17789     readonly UNSIGNED_SHORT_4_4_4_4: GLenum;
17790     readonly UNSIGNED_SHORT_5_5_5_1: GLenum;
17791     readonly UNSIGNED_SHORT_5_6_5: GLenum;
17792     readonly VALIDATE_STATUS: GLenum;
17793     readonly VENDOR: GLenum;
17794     readonly VERSION: GLenum;
17795     readonly VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: GLenum;
17796     readonly VERTEX_ATTRIB_ARRAY_ENABLED: GLenum;
17797     readonly VERTEX_ATTRIB_ARRAY_NORMALIZED: GLenum;
17798     readonly VERTEX_ATTRIB_ARRAY_POINTER: GLenum;
17799     readonly VERTEX_ATTRIB_ARRAY_SIZE: GLenum;
17800     readonly VERTEX_ATTRIB_ARRAY_STRIDE: GLenum;
17801     readonly VERTEX_ATTRIB_ARRAY_TYPE: GLenum;
17802     readonly VERTEX_SHADER: GLenum;
17803     readonly VIEWPORT: GLenum;
17804     readonly ZERO: GLenum;
17805 };
17806
17807 interface WebGLRenderingContextBase {
17808     readonly canvas: HTMLCanvasElement | OffscreenCanvas;
17809     readonly drawingBufferHeight: GLsizei;
17810     readonly drawingBufferWidth: GLsizei;
17811     activeTexture(texture: GLenum): void;
17812     attachShader(program: WebGLProgram, shader: WebGLShader): void;
17813     bindAttribLocation(program: WebGLProgram, index: GLuint, name: string): void;
17814     bindBuffer(target: GLenum, buffer: WebGLBuffer | null): void;
17815     bindFramebuffer(target: GLenum, framebuffer: WebGLFramebuffer | null): void;
17816     bindRenderbuffer(target: GLenum, renderbuffer: WebGLRenderbuffer | null): void;
17817     bindTexture(target: GLenum, texture: WebGLTexture | null): void;
17818     blendColor(red: GLclampf, green: GLclampf, blue: GLclampf, alpha: GLclampf): void;
17819     blendEquation(mode: GLenum): void;
17820     blendEquationSeparate(modeRGB: GLenum, modeAlpha: GLenum): void;
17821     blendFunc(sfactor: GLenum, dfactor: GLenum): void;
17822     blendFuncSeparate(srcRGB: GLenum, dstRGB: GLenum, srcAlpha: GLenum, dstAlpha: GLenum): void;
17823     checkFramebufferStatus(target: GLenum): GLenum;
17824     clear(mask: GLbitfield): void;
17825     clearColor(red: GLclampf, green: GLclampf, blue: GLclampf, alpha: GLclampf): void;
17826     clearDepth(depth: GLclampf): void;
17827     clearStencil(s: GLint): void;
17828     colorMask(red: GLboolean, green: GLboolean, blue: GLboolean, alpha: GLboolean): void;
17829     compileShader(shader: WebGLShader): void;
17830     copyTexImage2D(target: GLenum, level: GLint, internalformat: GLenum, x: GLint, y: GLint, width: GLsizei, height: GLsizei, border: GLint): void;
17831     copyTexSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, x: GLint, y: GLint, width: GLsizei, height: GLsizei): void;
17832     createBuffer(): WebGLBuffer | null;
17833     createFramebuffer(): WebGLFramebuffer | null;
17834     createProgram(): WebGLProgram | null;
17835     createRenderbuffer(): WebGLRenderbuffer | null;
17836     createShader(type: GLenum): WebGLShader | null;
17837     createTexture(): WebGLTexture | null;
17838     cullFace(mode: GLenum): void;
17839     deleteBuffer(buffer: WebGLBuffer | null): void;
17840     deleteFramebuffer(framebuffer: WebGLFramebuffer | null): void;
17841     deleteProgram(program: WebGLProgram | null): void;
17842     deleteRenderbuffer(renderbuffer: WebGLRenderbuffer | null): void;
17843     deleteShader(shader: WebGLShader | null): void;
17844     deleteTexture(texture: WebGLTexture | null): void;
17845     depthFunc(func: GLenum): void;
17846     depthMask(flag: GLboolean): void;
17847     depthRange(zNear: GLclampf, zFar: GLclampf): void;
17848     detachShader(program: WebGLProgram, shader: WebGLShader): void;
17849     disable(cap: GLenum): void;
17850     disableVertexAttribArray(index: GLuint): void;
17851     drawArrays(mode: GLenum, first: GLint, count: GLsizei): void;
17852     drawElements(mode: GLenum, count: GLsizei, type: GLenum, offset: GLintptr): void;
17853     enable(cap: GLenum): void;
17854     enableVertexAttribArray(index: GLuint): void;
17855     finish(): void;
17856     flush(): void;
17857     framebufferRenderbuffer(target: GLenum, attachment: GLenum, renderbuffertarget: GLenum, renderbuffer: WebGLRenderbuffer | null): void;
17858     framebufferTexture2D(target: GLenum, attachment: GLenum, textarget: GLenum, texture: WebGLTexture | null, level: GLint): void;
17859     frontFace(mode: GLenum): void;
17860     generateMipmap(target: GLenum): void;
17861     getActiveAttrib(program: WebGLProgram, index: GLuint): WebGLActiveInfo | null;
17862     getActiveUniform(program: WebGLProgram, index: GLuint): WebGLActiveInfo | null;
17863     getAttachedShaders(program: WebGLProgram): WebGLShader[] | null;
17864     getAttribLocation(program: WebGLProgram, name: string): GLint;
17865     getBufferParameter(target: GLenum, pname: GLenum): any;
17866     getContextAttributes(): WebGLContextAttributes | null;
17867     getError(): GLenum;
17868     getExtension(extensionName: "EXT_blend_minmax"): EXT_blend_minmax | null;
17869     getExtension(extensionName: "EXT_texture_filter_anisotropic"): EXT_texture_filter_anisotropic | null;
17870     getExtension(extensionName: "EXT_frag_depth"): EXT_frag_depth | null;
17871     getExtension(extensionName: "EXT_shader_texture_lod"): EXT_shader_texture_lod | null;
17872     getExtension(extensionName: "EXT_sRGB"): EXT_sRGB | null;
17873     getExtension(extensionName: "OES_vertex_array_object"): OES_vertex_array_object | null;
17874     getExtension(extensionName: "WEBGL_color_buffer_float"): WEBGL_color_buffer_float | null;
17875     getExtension(extensionName: "WEBGL_compressed_texture_astc"): WEBGL_compressed_texture_astc | null;
17876     getExtension(extensionName: "WEBGL_compressed_texture_s3tc_srgb"): WEBGL_compressed_texture_s3tc_srgb | null;
17877     getExtension(extensionName: "WEBGL_debug_shaders"): WEBGL_debug_shaders | null;
17878     getExtension(extensionName: "WEBGL_draw_buffers"): WEBGL_draw_buffers | null;
17879     getExtension(extensionName: "WEBGL_lose_context"): WEBGL_lose_context | null;
17880     getExtension(extensionName: "WEBGL_depth_texture"): WEBGL_depth_texture | null;
17881     getExtension(extensionName: "WEBGL_debug_renderer_info"): WEBGL_debug_renderer_info | null;
17882     getExtension(extensionName: "WEBGL_compressed_texture_s3tc"): WEBGL_compressed_texture_s3tc | null;
17883     getExtension(extensionName: "OES_texture_half_float_linear"): OES_texture_half_float_linear | null;
17884     getExtension(extensionName: "OES_texture_half_float"): OES_texture_half_float | null;
17885     getExtension(extensionName: "OES_texture_float_linear"): OES_texture_float_linear | null;
17886     getExtension(extensionName: "OES_texture_float"): OES_texture_float | null;
17887     getExtension(extensionName: "OES_standard_derivatives"): OES_standard_derivatives | null;
17888     getExtension(extensionName: "OES_element_index_uint"): OES_element_index_uint | null;
17889     getExtension(extensionName: "ANGLE_instanced_arrays"): ANGLE_instanced_arrays | null;
17890     getExtension(extensionName: string): any;
17891     getFramebufferAttachmentParameter(target: GLenum, attachment: GLenum, pname: GLenum): any;
17892     getParameter(pname: GLenum): any;
17893     getProgramInfoLog(program: WebGLProgram): string | null;
17894     getProgramParameter(program: WebGLProgram, pname: GLenum): any;
17895     getRenderbufferParameter(target: GLenum, pname: GLenum): any;
17896     getShaderInfoLog(shader: WebGLShader): string | null;
17897     getShaderParameter(shader: WebGLShader, pname: GLenum): any;
17898     getShaderPrecisionFormat(shadertype: GLenum, precisiontype: GLenum): WebGLShaderPrecisionFormat | null;
17899     getShaderSource(shader: WebGLShader): string | null;
17900     getSupportedExtensions(): string[] | null;
17901     getTexParameter(target: GLenum, pname: GLenum): any;
17902     getUniform(program: WebGLProgram, location: WebGLUniformLocation): any;
17903     getUniformLocation(program: WebGLProgram, name: string): WebGLUniformLocation | null;
17904     getVertexAttrib(index: GLuint, pname: GLenum): any;
17905     getVertexAttribOffset(index: GLuint, pname: GLenum): GLintptr;
17906     hint(target: GLenum, mode: GLenum): void;
17907     isBuffer(buffer: WebGLBuffer | null): GLboolean;
17908     isContextLost(): boolean;
17909     isEnabled(cap: GLenum): GLboolean;
17910     isFramebuffer(framebuffer: WebGLFramebuffer | null): GLboolean;
17911     isProgram(program: WebGLProgram | null): GLboolean;
17912     isRenderbuffer(renderbuffer: WebGLRenderbuffer | null): GLboolean;
17913     isShader(shader: WebGLShader | null): GLboolean;
17914     isTexture(texture: WebGLTexture | null): GLboolean;
17915     lineWidth(width: GLfloat): void;
17916     linkProgram(program: WebGLProgram): void;
17917     pixelStorei(pname: GLenum, param: GLint | GLboolean): void;
17918     polygonOffset(factor: GLfloat, units: GLfloat): void;
17919     renderbufferStorage(target: GLenum, internalformat: GLenum, width: GLsizei, height: GLsizei): void;
17920     sampleCoverage(value: GLclampf, invert: GLboolean): void;
17921     scissor(x: GLint, y: GLint, width: GLsizei, height: GLsizei): void;
17922     shaderSource(shader: WebGLShader, source: string): void;
17923     stencilFunc(func: GLenum, ref: GLint, mask: GLuint): void;
17924     stencilFuncSeparate(face: GLenum, func: GLenum, ref: GLint, mask: GLuint): void;
17925     stencilMask(mask: GLuint): void;
17926     stencilMaskSeparate(face: GLenum, mask: GLuint): void;
17927     stencilOp(fail: GLenum, zfail: GLenum, zpass: GLenum): void;
17928     stencilOpSeparate(face: GLenum, fail: GLenum, zfail: GLenum, zpass: GLenum): void;
17929     texParameterf(target: GLenum, pname: GLenum, param: GLfloat): void;
17930     texParameteri(target: GLenum, pname: GLenum, param: GLint): void;
17931     uniform1f(location: WebGLUniformLocation | null, x: GLfloat): void;
17932     uniform1i(location: WebGLUniformLocation | null, x: GLint): void;
17933     uniform2f(location: WebGLUniformLocation | null, x: GLfloat, y: GLfloat): void;
17934     uniform2i(location: WebGLUniformLocation | null, x: GLint, y: GLint): void;
17935     uniform3f(location: WebGLUniformLocation | null, x: GLfloat, y: GLfloat, z: GLfloat): void;
17936     uniform3i(location: WebGLUniformLocation | null, x: GLint, y: GLint, z: GLint): void;
17937     uniform4f(location: WebGLUniformLocation | null, x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat): void;
17938     uniform4i(location: WebGLUniformLocation | null, x: GLint, y: GLint, z: GLint, w: GLint): void;
17939     useProgram(program: WebGLProgram | null): void;
17940     validateProgram(program: WebGLProgram): void;
17941     vertexAttrib1f(index: GLuint, x: GLfloat): void;
17942     vertexAttrib1fv(index: GLuint, values: Float32List): void;
17943     vertexAttrib2f(index: GLuint, x: GLfloat, y: GLfloat): void;
17944     vertexAttrib2fv(index: GLuint, values: Float32List): void;
17945     vertexAttrib3f(index: GLuint, x: GLfloat, y: GLfloat, z: GLfloat): void;
17946     vertexAttrib3fv(index: GLuint, values: Float32List): void;
17947     vertexAttrib4f(index: GLuint, x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat): void;
17948     vertexAttrib4fv(index: GLuint, values: Float32List): void;
17949     vertexAttribPointer(index: GLuint, size: GLint, type: GLenum, normalized: GLboolean, stride: GLsizei, offset: GLintptr): void;
17950     viewport(x: GLint, y: GLint, width: GLsizei, height: GLsizei): void;
17951     readonly ACTIVE_ATTRIBUTES: GLenum;
17952     readonly ACTIVE_TEXTURE: GLenum;
17953     readonly ACTIVE_UNIFORMS: GLenum;
17954     readonly ALIASED_LINE_WIDTH_RANGE: GLenum;
17955     readonly ALIASED_POINT_SIZE_RANGE: GLenum;
17956     readonly ALPHA: GLenum;
17957     readonly ALPHA_BITS: GLenum;
17958     readonly ALWAYS: GLenum;
17959     readonly ARRAY_BUFFER: GLenum;
17960     readonly ARRAY_BUFFER_BINDING: GLenum;
17961     readonly ATTACHED_SHADERS: GLenum;
17962     readonly BACK: GLenum;
17963     readonly BLEND: GLenum;
17964     readonly BLEND_COLOR: GLenum;
17965     readonly BLEND_DST_ALPHA: GLenum;
17966     readonly BLEND_DST_RGB: GLenum;
17967     readonly BLEND_EQUATION: GLenum;
17968     readonly BLEND_EQUATION_ALPHA: GLenum;
17969     readonly BLEND_EQUATION_RGB: GLenum;
17970     readonly BLEND_SRC_ALPHA: GLenum;
17971     readonly BLEND_SRC_RGB: GLenum;
17972     readonly BLUE_BITS: GLenum;
17973     readonly BOOL: GLenum;
17974     readonly BOOL_VEC2: GLenum;
17975     readonly BOOL_VEC3: GLenum;
17976     readonly BOOL_VEC4: GLenum;
17977     readonly BROWSER_DEFAULT_WEBGL: GLenum;
17978     readonly BUFFER_SIZE: GLenum;
17979     readonly BUFFER_USAGE: GLenum;
17980     readonly BYTE: GLenum;
17981     readonly CCW: GLenum;
17982     readonly CLAMP_TO_EDGE: GLenum;
17983     readonly COLOR_ATTACHMENT0: GLenum;
17984     readonly COLOR_BUFFER_BIT: GLenum;
17985     readonly COLOR_CLEAR_VALUE: GLenum;
17986     readonly COLOR_WRITEMASK: GLenum;
17987     readonly COMPILE_STATUS: GLenum;
17988     readonly COMPRESSED_TEXTURE_FORMATS: GLenum;
17989     readonly CONSTANT_ALPHA: GLenum;
17990     readonly CONSTANT_COLOR: GLenum;
17991     readonly CONTEXT_LOST_WEBGL: GLenum;
17992     readonly CULL_FACE: GLenum;
17993     readonly CULL_FACE_MODE: GLenum;
17994     readonly CURRENT_PROGRAM: GLenum;
17995     readonly CURRENT_VERTEX_ATTRIB: GLenum;
17996     readonly CW: GLenum;
17997     readonly DECR: GLenum;
17998     readonly DECR_WRAP: GLenum;
17999     readonly DELETE_STATUS: GLenum;
18000     readonly DEPTH_ATTACHMENT: GLenum;
18001     readonly DEPTH_BITS: GLenum;
18002     readonly DEPTH_BUFFER_BIT: GLenum;
18003     readonly DEPTH_CLEAR_VALUE: GLenum;
18004     readonly DEPTH_COMPONENT: GLenum;
18005     readonly DEPTH_COMPONENT16: GLenum;
18006     readonly DEPTH_FUNC: GLenum;
18007     readonly DEPTH_RANGE: GLenum;
18008     readonly DEPTH_STENCIL: GLenum;
18009     readonly DEPTH_STENCIL_ATTACHMENT: GLenum;
18010     readonly DEPTH_TEST: GLenum;
18011     readonly DEPTH_WRITEMASK: GLenum;
18012     readonly DITHER: GLenum;
18013     readonly DONT_CARE: GLenum;
18014     readonly DST_ALPHA: GLenum;
18015     readonly DST_COLOR: GLenum;
18016     readonly DYNAMIC_DRAW: GLenum;
18017     readonly ELEMENT_ARRAY_BUFFER: GLenum;
18018     readonly ELEMENT_ARRAY_BUFFER_BINDING: GLenum;
18019     readonly EQUAL: GLenum;
18020     readonly FASTEST: GLenum;
18021     readonly FLOAT: GLenum;
18022     readonly FLOAT_MAT2: GLenum;
18023     readonly FLOAT_MAT3: GLenum;
18024     readonly FLOAT_MAT4: GLenum;
18025     readonly FLOAT_VEC2: GLenum;
18026     readonly FLOAT_VEC3: GLenum;
18027     readonly FLOAT_VEC4: GLenum;
18028     readonly FRAGMENT_SHADER: GLenum;
18029     readonly FRAMEBUFFER: GLenum;
18030     readonly FRAMEBUFFER_ATTACHMENT_OBJECT_NAME: GLenum;
18031     readonly FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE: GLenum;
18032     readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE: GLenum;
18033     readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL: GLenum;
18034     readonly FRAMEBUFFER_BINDING: GLenum;
18035     readonly FRAMEBUFFER_COMPLETE: GLenum;
18036     readonly FRAMEBUFFER_INCOMPLETE_ATTACHMENT: GLenum;
18037     readonly FRAMEBUFFER_INCOMPLETE_DIMENSIONS: GLenum;
18038     readonly FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: GLenum;
18039     readonly FRAMEBUFFER_UNSUPPORTED: GLenum;
18040     readonly FRONT: GLenum;
18041     readonly FRONT_AND_BACK: GLenum;
18042     readonly FRONT_FACE: GLenum;
18043     readonly FUNC_ADD: GLenum;
18044     readonly FUNC_REVERSE_SUBTRACT: GLenum;
18045     readonly FUNC_SUBTRACT: GLenum;
18046     readonly GENERATE_MIPMAP_HINT: GLenum;
18047     readonly GEQUAL: GLenum;
18048     readonly GREATER: GLenum;
18049     readonly GREEN_BITS: GLenum;
18050     readonly HIGH_FLOAT: GLenum;
18051     readonly HIGH_INT: GLenum;
18052     readonly IMPLEMENTATION_COLOR_READ_FORMAT: GLenum;
18053     readonly IMPLEMENTATION_COLOR_READ_TYPE: GLenum;
18054     readonly INCR: GLenum;
18055     readonly INCR_WRAP: GLenum;
18056     readonly INT: GLenum;
18057     readonly INT_VEC2: GLenum;
18058     readonly INT_VEC3: GLenum;
18059     readonly INT_VEC4: GLenum;
18060     readonly INVALID_ENUM: GLenum;
18061     readonly INVALID_FRAMEBUFFER_OPERATION: GLenum;
18062     readonly INVALID_OPERATION: GLenum;
18063     readonly INVALID_VALUE: GLenum;
18064     readonly INVERT: GLenum;
18065     readonly KEEP: GLenum;
18066     readonly LEQUAL: GLenum;
18067     readonly LESS: GLenum;
18068     readonly LINEAR: GLenum;
18069     readonly LINEAR_MIPMAP_LINEAR: GLenum;
18070     readonly LINEAR_MIPMAP_NEAREST: GLenum;
18071     readonly LINES: GLenum;
18072     readonly LINE_LOOP: GLenum;
18073     readonly LINE_STRIP: GLenum;
18074     readonly LINE_WIDTH: GLenum;
18075     readonly LINK_STATUS: GLenum;
18076     readonly LOW_FLOAT: GLenum;
18077     readonly LOW_INT: GLenum;
18078     readonly LUMINANCE: GLenum;
18079     readonly LUMINANCE_ALPHA: GLenum;
18080     readonly MAX_COMBINED_TEXTURE_IMAGE_UNITS: GLenum;
18081     readonly MAX_CUBE_MAP_TEXTURE_SIZE: GLenum;
18082     readonly MAX_FRAGMENT_UNIFORM_VECTORS: GLenum;
18083     readonly MAX_RENDERBUFFER_SIZE: GLenum;
18084     readonly MAX_TEXTURE_IMAGE_UNITS: GLenum;
18085     readonly MAX_TEXTURE_SIZE: GLenum;
18086     readonly MAX_VARYING_VECTORS: GLenum;
18087     readonly MAX_VERTEX_ATTRIBS: GLenum;
18088     readonly MAX_VERTEX_TEXTURE_IMAGE_UNITS: GLenum;
18089     readonly MAX_VERTEX_UNIFORM_VECTORS: GLenum;
18090     readonly MAX_VIEWPORT_DIMS: GLenum;
18091     readonly MEDIUM_FLOAT: GLenum;
18092     readonly MEDIUM_INT: GLenum;
18093     readonly MIRRORED_REPEAT: GLenum;
18094     readonly NEAREST: GLenum;
18095     readonly NEAREST_MIPMAP_LINEAR: GLenum;
18096     readonly NEAREST_MIPMAP_NEAREST: GLenum;
18097     readonly NEVER: GLenum;
18098     readonly NICEST: GLenum;
18099     readonly NONE: GLenum;
18100     readonly NOTEQUAL: GLenum;
18101     readonly NO_ERROR: GLenum;
18102     readonly ONE: GLenum;
18103     readonly ONE_MINUS_CONSTANT_ALPHA: GLenum;
18104     readonly ONE_MINUS_CONSTANT_COLOR: GLenum;
18105     readonly ONE_MINUS_DST_ALPHA: GLenum;
18106     readonly ONE_MINUS_DST_COLOR: GLenum;
18107     readonly ONE_MINUS_SRC_ALPHA: GLenum;
18108     readonly ONE_MINUS_SRC_COLOR: GLenum;
18109     readonly OUT_OF_MEMORY: GLenum;
18110     readonly PACK_ALIGNMENT: GLenum;
18111     readonly POINTS: GLenum;
18112     readonly POLYGON_OFFSET_FACTOR: GLenum;
18113     readonly POLYGON_OFFSET_FILL: GLenum;
18114     readonly POLYGON_OFFSET_UNITS: GLenum;
18115     readonly RED_BITS: GLenum;
18116     readonly RENDERBUFFER: GLenum;
18117     readonly RENDERBUFFER_ALPHA_SIZE: GLenum;
18118     readonly RENDERBUFFER_BINDING: GLenum;
18119     readonly RENDERBUFFER_BLUE_SIZE: GLenum;
18120     readonly RENDERBUFFER_DEPTH_SIZE: GLenum;
18121     readonly RENDERBUFFER_GREEN_SIZE: GLenum;
18122     readonly RENDERBUFFER_HEIGHT: GLenum;
18123     readonly RENDERBUFFER_INTERNAL_FORMAT: GLenum;
18124     readonly RENDERBUFFER_RED_SIZE: GLenum;
18125     readonly RENDERBUFFER_STENCIL_SIZE: GLenum;
18126     readonly RENDERBUFFER_WIDTH: GLenum;
18127     readonly RENDERER: GLenum;
18128     readonly REPEAT: GLenum;
18129     readonly REPLACE: GLenum;
18130     readonly RGB: GLenum;
18131     readonly RGB565: GLenum;
18132     readonly RGB5_A1: GLenum;
18133     readonly RGBA: GLenum;
18134     readonly RGBA4: GLenum;
18135     readonly SAMPLER_2D: GLenum;
18136     readonly SAMPLER_CUBE: GLenum;
18137     readonly SAMPLES: GLenum;
18138     readonly SAMPLE_ALPHA_TO_COVERAGE: GLenum;
18139     readonly SAMPLE_BUFFERS: GLenum;
18140     readonly SAMPLE_COVERAGE: GLenum;
18141     readonly SAMPLE_COVERAGE_INVERT: GLenum;
18142     readonly SAMPLE_COVERAGE_VALUE: GLenum;
18143     readonly SCISSOR_BOX: GLenum;
18144     readonly SCISSOR_TEST: GLenum;
18145     readonly SHADER_TYPE: GLenum;
18146     readonly SHADING_LANGUAGE_VERSION: GLenum;
18147     readonly SHORT: GLenum;
18148     readonly SRC_ALPHA: GLenum;
18149     readonly SRC_ALPHA_SATURATE: GLenum;
18150     readonly SRC_COLOR: GLenum;
18151     readonly STATIC_DRAW: GLenum;
18152     readonly STENCIL_ATTACHMENT: GLenum;
18153     readonly STENCIL_BACK_FAIL: GLenum;
18154     readonly STENCIL_BACK_FUNC: GLenum;
18155     readonly STENCIL_BACK_PASS_DEPTH_FAIL: GLenum;
18156     readonly STENCIL_BACK_PASS_DEPTH_PASS: GLenum;
18157     readonly STENCIL_BACK_REF: GLenum;
18158     readonly STENCIL_BACK_VALUE_MASK: GLenum;
18159     readonly STENCIL_BACK_WRITEMASK: GLenum;
18160     readonly STENCIL_BITS: GLenum;
18161     readonly STENCIL_BUFFER_BIT: GLenum;
18162     readonly STENCIL_CLEAR_VALUE: GLenum;
18163     readonly STENCIL_FAIL: GLenum;
18164     readonly STENCIL_FUNC: GLenum;
18165     readonly STENCIL_INDEX8: GLenum;
18166     readonly STENCIL_PASS_DEPTH_FAIL: GLenum;
18167     readonly STENCIL_PASS_DEPTH_PASS: GLenum;
18168     readonly STENCIL_REF: GLenum;
18169     readonly STENCIL_TEST: GLenum;
18170     readonly STENCIL_VALUE_MASK: GLenum;
18171     readonly STENCIL_WRITEMASK: GLenum;
18172     readonly STREAM_DRAW: GLenum;
18173     readonly SUBPIXEL_BITS: GLenum;
18174     readonly TEXTURE: GLenum;
18175     readonly TEXTURE0: GLenum;
18176     readonly TEXTURE1: GLenum;
18177     readonly TEXTURE10: GLenum;
18178     readonly TEXTURE11: GLenum;
18179     readonly TEXTURE12: GLenum;
18180     readonly TEXTURE13: GLenum;
18181     readonly TEXTURE14: GLenum;
18182     readonly TEXTURE15: GLenum;
18183     readonly TEXTURE16: GLenum;
18184     readonly TEXTURE17: GLenum;
18185     readonly TEXTURE18: GLenum;
18186     readonly TEXTURE19: GLenum;
18187     readonly TEXTURE2: GLenum;
18188     readonly TEXTURE20: GLenum;
18189     readonly TEXTURE21: GLenum;
18190     readonly TEXTURE22: GLenum;
18191     readonly TEXTURE23: GLenum;
18192     readonly TEXTURE24: GLenum;
18193     readonly TEXTURE25: GLenum;
18194     readonly TEXTURE26: GLenum;
18195     readonly TEXTURE27: GLenum;
18196     readonly TEXTURE28: GLenum;
18197     readonly TEXTURE29: GLenum;
18198     readonly TEXTURE3: GLenum;
18199     readonly TEXTURE30: GLenum;
18200     readonly TEXTURE31: GLenum;
18201     readonly TEXTURE4: GLenum;
18202     readonly TEXTURE5: GLenum;
18203     readonly TEXTURE6: GLenum;
18204     readonly TEXTURE7: GLenum;
18205     readonly TEXTURE8: GLenum;
18206     readonly TEXTURE9: GLenum;
18207     readonly TEXTURE_2D: GLenum;
18208     readonly TEXTURE_BINDING_2D: GLenum;
18209     readonly TEXTURE_BINDING_CUBE_MAP: GLenum;
18210     readonly TEXTURE_CUBE_MAP: GLenum;
18211     readonly TEXTURE_CUBE_MAP_NEGATIVE_X: GLenum;
18212     readonly TEXTURE_CUBE_MAP_NEGATIVE_Y: GLenum;
18213     readonly TEXTURE_CUBE_MAP_NEGATIVE_Z: GLenum;
18214     readonly TEXTURE_CUBE_MAP_POSITIVE_X: GLenum;
18215     readonly TEXTURE_CUBE_MAP_POSITIVE_Y: GLenum;
18216     readonly TEXTURE_CUBE_MAP_POSITIVE_Z: GLenum;
18217     readonly TEXTURE_MAG_FILTER: GLenum;
18218     readonly TEXTURE_MIN_FILTER: GLenum;
18219     readonly TEXTURE_WRAP_S: GLenum;
18220     readonly TEXTURE_WRAP_T: GLenum;
18221     readonly TRIANGLES: GLenum;
18222     readonly TRIANGLE_FAN: GLenum;
18223     readonly TRIANGLE_STRIP: GLenum;
18224     readonly UNPACK_ALIGNMENT: GLenum;
18225     readonly UNPACK_COLORSPACE_CONVERSION_WEBGL: GLenum;
18226     readonly UNPACK_FLIP_Y_WEBGL: GLenum;
18227     readonly UNPACK_PREMULTIPLY_ALPHA_WEBGL: GLenum;
18228     readonly UNSIGNED_BYTE: GLenum;
18229     readonly UNSIGNED_INT: GLenum;
18230     readonly UNSIGNED_SHORT: GLenum;
18231     readonly UNSIGNED_SHORT_4_4_4_4: GLenum;
18232     readonly UNSIGNED_SHORT_5_5_5_1: GLenum;
18233     readonly UNSIGNED_SHORT_5_6_5: GLenum;
18234     readonly VALIDATE_STATUS: GLenum;
18235     readonly VENDOR: GLenum;
18236     readonly VERSION: GLenum;
18237     readonly VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: GLenum;
18238     readonly VERTEX_ATTRIB_ARRAY_ENABLED: GLenum;
18239     readonly VERTEX_ATTRIB_ARRAY_NORMALIZED: GLenum;
18240     readonly VERTEX_ATTRIB_ARRAY_POINTER: GLenum;
18241     readonly VERTEX_ATTRIB_ARRAY_SIZE: GLenum;
18242     readonly VERTEX_ATTRIB_ARRAY_STRIDE: GLenum;
18243     readonly VERTEX_ATTRIB_ARRAY_TYPE: GLenum;
18244     readonly VERTEX_SHADER: GLenum;
18245     readonly VIEWPORT: GLenum;
18246     readonly ZERO: GLenum;
18247 }
18248
18249 interface WebGLRenderingContextOverloads {
18250     bufferData(target: GLenum, size: GLsizeiptr, usage: GLenum): void;
18251     bufferData(target: GLenum, data: BufferSource | null, usage: GLenum): void;
18252     bufferSubData(target: GLenum, offset: GLintptr, data: BufferSource): void;
18253     compressedTexImage2D(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, border: GLint, data: ArrayBufferView): void;
18254     compressedTexSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, data: ArrayBufferView): void;
18255     readPixels(x: GLint, y: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, pixels: ArrayBufferView | null): void;
18256     texImage2D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, border: GLint, format: GLenum, type: GLenum, pixels: ArrayBufferView | null): void;
18257     texImage2D(target: GLenum, level: GLint, internalformat: GLint, format: GLenum, type: GLenum, source: TexImageSource): void;
18258     texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, pixels: ArrayBufferView | null): void;
18259     texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, format: GLenum, type: GLenum, source: TexImageSource): void;
18260     uniform1fv(location: WebGLUniformLocation | null, v: Float32List): void;
18261     uniform1iv(location: WebGLUniformLocation | null, v: Int32List): void;
18262     uniform2fv(location: WebGLUniformLocation | null, v: Float32List): void;
18263     uniform2iv(location: WebGLUniformLocation | null, v: Int32List): void;
18264     uniform3fv(location: WebGLUniformLocation | null, v: Float32List): void;
18265     uniform3iv(location: WebGLUniformLocation | null, v: Int32List): void;
18266     uniform4fv(location: WebGLUniformLocation | null, v: Float32List): void;
18267     uniform4iv(location: WebGLUniformLocation | null, v: Int32List): void;
18268     uniformMatrix2fv(location: WebGLUniformLocation | null, transpose: GLboolean, value: Float32List): void;
18269     uniformMatrix3fv(location: WebGLUniformLocation | null, transpose: GLboolean, value: Float32List): void;
18270     uniformMatrix4fv(location: WebGLUniformLocation | null, transpose: GLboolean, value: Float32List): void;
18271 }
18272
18273 interface WebGLSampler extends WebGLObject {
18274 }
18275
18276 declare var WebGLSampler: {
18277     prototype: WebGLSampler;
18278     new(): WebGLSampler;
18279 };
18280
18281 /** The WebGLShader is part of the WebGL API and can either be a vertex or a fragment shader. A WebGLProgram requires both types of shaders. */
18282 interface WebGLShader extends WebGLObject {
18283 }
18284
18285 declare var WebGLShader: {
18286     prototype: WebGLShader;
18287     new(): WebGLShader;
18288 };
18289
18290 /** Part of the WebGL API and represents the information returned by calling the WebGLRenderingContext.getShaderPrecisionFormat() method. */
18291 interface WebGLShaderPrecisionFormat {
18292     readonly precision: GLint;
18293     readonly rangeMax: GLint;
18294     readonly rangeMin: GLint;
18295 }
18296
18297 declare var WebGLShaderPrecisionFormat: {
18298     prototype: WebGLShaderPrecisionFormat;
18299     new(): WebGLShaderPrecisionFormat;
18300 };
18301
18302 interface WebGLSync extends WebGLObject {
18303 }
18304
18305 declare var WebGLSync: {
18306     prototype: WebGLSync;
18307     new(): WebGLSync;
18308 };
18309
18310 /** Part of the WebGL API and represents an opaque texture object providing storage and state for texturing operations. */
18311 interface WebGLTexture extends WebGLObject {
18312 }
18313
18314 declare var WebGLTexture: {
18315     prototype: WebGLTexture;
18316     new(): WebGLTexture;
18317 };
18318
18319 interface WebGLTransformFeedback extends WebGLObject {
18320 }
18321
18322 declare var WebGLTransformFeedback: {
18323     prototype: WebGLTransformFeedback;
18324     new(): WebGLTransformFeedback;
18325 };
18326
18327 /** Part of the WebGL API and represents the location of a uniform variable in a shader program. */
18328 interface WebGLUniformLocation {
18329 }
18330
18331 declare var WebGLUniformLocation: {
18332     prototype: WebGLUniformLocation;
18333     new(): WebGLUniformLocation;
18334 };
18335
18336 interface WebGLVertexArrayObject extends WebGLObject {
18337 }
18338
18339 declare var WebGLVertexArrayObject: {
18340     prototype: WebGLVertexArrayObject;
18341     new(): WebGLVertexArrayObject;
18342 };
18343
18344 interface WebGLVertexArrayObjectOES extends WebGLObject {
18345 }
18346
18347 interface WebKitPoint {
18348     x: number;
18349     y: number;
18350 }
18351
18352 declare var WebKitPoint: {
18353     prototype: WebKitPoint;
18354     new(x?: number, y?: number): WebKitPoint;
18355 };
18356
18357 interface WebSocketEventMap {
18358     "close": CloseEvent;
18359     "error": Event;
18360     "message": MessageEvent;
18361     "open": Event;
18362 }
18363
18364 /** Provides the API for creating and managing a WebSocket connection to a server, as well as for sending and receiving data on the connection. */
18365 interface WebSocket extends EventTarget {
18366     /**
18367      * Returns a string that indicates how binary data from the WebSocket object is exposed to scripts:
18368      *
18369      * Can be set, to change how binary data is returned. The default is "blob".
18370      */
18371     binaryType: BinaryType;
18372     /**
18373      * Returns the number of bytes of application data (UTF-8 text and binary data) that have been queued using send() but not yet been transmitted to the network.
18374      *
18375      * If the WebSocket connection is closed, this attribute's value will only increase with each call to the send() method. (The number does not reset to zero once the connection closes.)
18376      */
18377     readonly bufferedAmount: number;
18378     /**
18379      * Returns the extensions selected by the server, if any.
18380      */
18381     readonly extensions: string;
18382     onclose: ((this: WebSocket, ev: CloseEvent) => any) | null;
18383     onerror: ((this: WebSocket, ev: Event) => any) | null;
18384     onmessage: ((this: WebSocket, ev: MessageEvent) => any) | null;
18385     onopen: ((this: WebSocket, ev: Event) => any) | null;
18386     /**
18387      * Returns the subprotocol selected by the server, if any. It can be used in conjunction with the array form of the constructor's second argument to perform subprotocol negotiation.
18388      */
18389     readonly protocol: string;
18390     /**
18391      * Returns the state of the WebSocket object's connection. It can have the values described below.
18392      */
18393     readonly readyState: number;
18394     /**
18395      * Returns the URL that was used to establish the WebSocket connection.
18396      */
18397     readonly url: string;
18398     /**
18399      * Closes the WebSocket connection, optionally using code as the the WebSocket connection close code and reason as the the WebSocket connection close reason.
18400      */
18401     close(code?: number, reason?: string): void;
18402     /**
18403      * Transmits data using the WebSocket connection. data can be a string, a Blob, an ArrayBuffer, or an ArrayBufferView.
18404      */
18405     send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void;
18406     readonly CLOSED: number;
18407     readonly CLOSING: number;
18408     readonly CONNECTING: number;
18409     readonly OPEN: number;
18410     addEventListener<K extends keyof WebSocketEventMap>(type: K, listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
18411     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
18412     removeEventListener<K extends keyof WebSocketEventMap>(type: K, listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
18413     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
18414 }
18415
18416 declare var WebSocket: {
18417     prototype: WebSocket;
18418     new(url: string, protocols?: string | string[]): WebSocket;
18419     readonly CLOSED: number;
18420     readonly CLOSING: number;
18421     readonly CONNECTING: number;
18422     readonly OPEN: number;
18423 };
18424
18425 /** Events that occur due to the user moving a mouse wheel or similar input device. */
18426 interface WheelEvent extends MouseEvent {
18427     readonly deltaMode: number;
18428     readonly deltaX: number;
18429     readonly deltaY: number;
18430     readonly deltaZ: number;
18431     readonly DOM_DELTA_LINE: number;
18432     readonly DOM_DELTA_PAGE: number;
18433     readonly DOM_DELTA_PIXEL: number;
18434 }
18435
18436 declare var WheelEvent: {
18437     prototype: WheelEvent;
18438     new(type: string, eventInitDict?: WheelEventInit): WheelEvent;
18439     readonly DOM_DELTA_LINE: number;
18440     readonly DOM_DELTA_PAGE: number;
18441     readonly DOM_DELTA_PIXEL: number;
18442 };
18443
18444 interface WindowEventMap extends GlobalEventHandlersEventMap, WindowEventHandlersEventMap {
18445     "abort": UIEvent;
18446     "afterprint": Event;
18447     "beforeprint": Event;
18448     "beforeunload": BeforeUnloadEvent;
18449     "blur": FocusEvent;
18450     "canplay": Event;
18451     "canplaythrough": Event;
18452     "change": Event;
18453     "click": MouseEvent;
18454     "compassneedscalibration": Event;
18455     "contextmenu": MouseEvent;
18456     "dblclick": MouseEvent;
18457     "devicelight": DeviceLightEvent;
18458     "devicemotion": DeviceMotionEvent;
18459     "deviceorientation": DeviceOrientationEvent;
18460     "deviceorientationabsolute": DeviceOrientationEvent;
18461     "drag": DragEvent;
18462     "dragend": DragEvent;
18463     "dragenter": DragEvent;
18464     "dragleave": DragEvent;
18465     "dragover": DragEvent;
18466     "dragstart": DragEvent;
18467     "drop": DragEvent;
18468     "durationchange": Event;
18469     "emptied": Event;
18470     "ended": Event;
18471     "error": ErrorEvent;
18472     "focus": FocusEvent;
18473     "gamepadconnected": GamepadEvent;
18474     "gamepaddisconnected": GamepadEvent;
18475     "hashchange": HashChangeEvent;
18476     "input": Event;
18477     "invalid": Event;
18478     "keydown": KeyboardEvent;
18479     "keypress": KeyboardEvent;
18480     "keyup": KeyboardEvent;
18481     "load": Event;
18482     "loadeddata": Event;
18483     "loadedmetadata": Event;
18484     "loadstart": Event;
18485     "message": MessageEvent;
18486     "mousedown": MouseEvent;
18487     "mouseenter": MouseEvent;
18488     "mouseleave": MouseEvent;
18489     "mousemove": MouseEvent;
18490     "mouseout": MouseEvent;
18491     "mouseover": MouseEvent;
18492     "mouseup": MouseEvent;
18493     "mousewheel": Event;
18494     "MSGestureChange": Event;
18495     "MSGestureDoubleTap": Event;
18496     "MSGestureEnd": Event;
18497     "MSGestureHold": Event;
18498     "MSGestureStart": Event;
18499     "MSGestureTap": Event;
18500     "MSInertiaStart": Event;
18501     "MSPointerCancel": Event;
18502     "MSPointerDown": Event;
18503     "MSPointerEnter": Event;
18504     "MSPointerLeave": Event;
18505     "MSPointerMove": Event;
18506     "MSPointerOut": Event;
18507     "MSPointerOver": Event;
18508     "MSPointerUp": Event;
18509     "offline": Event;
18510     "online": Event;
18511     "orientationchange": Event;
18512     "pagehide": PageTransitionEvent;
18513     "pageshow": PageTransitionEvent;
18514     "pause": Event;
18515     "play": Event;
18516     "playing": Event;
18517     "popstate": PopStateEvent;
18518     "progress": ProgressEvent<Window>;
18519     "ratechange": Event;
18520     "readystatechange": ProgressEvent<Window>;
18521     "reset": Event;
18522     "resize": UIEvent;
18523     "scroll": Event;
18524     "seeked": Event;
18525     "seeking": Event;
18526     "select": Event;
18527     "stalled": Event;
18528     "storage": StorageEvent;
18529     "submit": Event;
18530     "suspend": Event;
18531     "timeupdate": Event;
18532     "unload": Event;
18533     "volumechange": Event;
18534     "vrdisplayactivate": Event;
18535     "vrdisplayblur": Event;
18536     "vrdisplayconnect": Event;
18537     "vrdisplaydeactivate": Event;
18538     "vrdisplaydisconnect": Event;
18539     "vrdisplayfocus": Event;
18540     "vrdisplaypointerrestricted": Event;
18541     "vrdisplaypointerunrestricted": Event;
18542     "vrdisplaypresentchange": Event;
18543     "waiting": Event;
18544 }
18545
18546 /** A window containing a DOM document; the document property points to the DOM document loaded in that window. */
18547 interface Window extends EventTarget, AnimationFrameProvider, GlobalEventHandlers, WindowEventHandlers, WindowLocalStorage, WindowOrWorkerGlobalScope, WindowSessionStorage {
18548     readonly applicationCache: ApplicationCache;
18549     readonly clientInformation: Navigator;
18550     readonly closed: boolean;
18551     customElements: CustomElementRegistry;
18552     defaultStatus: string;
18553     readonly devicePixelRatio: number;
18554     readonly doNotTrack: string;
18555     readonly document: Document;
18556     /** @deprecated */
18557     readonly event: Event | undefined;
18558     /** @deprecated */
18559     readonly external: External;
18560     readonly frameElement: Element | null;
18561     readonly frames: Window;
18562     readonly history: History;
18563     readonly innerHeight: number;
18564     readonly innerWidth: number;
18565     readonly length: number;
18566     location: Location;
18567     readonly locationbar: BarProp;
18568     readonly menubar: BarProp;
18569     readonly msContentScript: ExtensionScriptApis;
18570     name: string;
18571     readonly navigator: Navigator;
18572     offscreenBuffering: string | boolean;
18573     oncompassneedscalibration: ((this: Window, ev: Event) => any) | null;
18574     ondevicelight: ((this: Window, ev: DeviceLightEvent) => any) | null;
18575     ondevicemotion: ((this: Window, ev: DeviceMotionEvent) => any) | null;
18576     ondeviceorientation: ((this: Window, ev: DeviceOrientationEvent) => any) | null;
18577     ondeviceorientationabsolute: ((this: Window, ev: DeviceOrientationEvent) => any) | null;
18578     ongamepadconnected: ((this: Window, ev: GamepadEvent) => any) | null;
18579     ongamepaddisconnected: ((this: Window, ev: GamepadEvent) => any) | null;
18580     onmousewheel: ((this: Window, ev: Event) => any) | null;
18581     onmsgesturechange: ((this: Window, ev: Event) => any) | null;
18582     onmsgesturedoubletap: ((this: Window, ev: Event) => any) | null;
18583     onmsgestureend: ((this: Window, ev: Event) => any) | null;
18584     onmsgesturehold: ((this: Window, ev: Event) => any) | null;
18585     onmsgesturestart: ((this: Window, ev: Event) => any) | null;
18586     onmsgesturetap: ((this: Window, ev: Event) => any) | null;
18587     onmsinertiastart: ((this: Window, ev: Event) => any) | null;
18588     onmspointercancel: ((this: Window, ev: Event) => any) | null;
18589     onmspointerdown: ((this: Window, ev: Event) => any) | null;
18590     onmspointerenter: ((this: Window, ev: Event) => any) | null;
18591     onmspointerleave: ((this: Window, ev: Event) => any) | null;
18592     onmspointermove: ((this: Window, ev: Event) => any) | null;
18593     onmspointerout: ((this: Window, ev: Event) => any) | null;
18594     onmspointerover: ((this: Window, ev: Event) => any) | null;
18595     onmspointerup: ((this: Window, ev: Event) => any) | null;
18596     /** @deprecated */
18597     onorientationchange: ((this: Window, ev: Event) => any) | null;
18598     onreadystatechange: ((this: Window, ev: ProgressEvent<Window>) => any) | null;
18599     onvrdisplayactivate: ((this: Window, ev: Event) => any) | null;
18600     onvrdisplayblur: ((this: Window, ev: Event) => any) | null;
18601     onvrdisplayconnect: ((this: Window, ev: Event) => any) | null;
18602     onvrdisplaydeactivate: ((this: Window, ev: Event) => any) | null;
18603     onvrdisplaydisconnect: ((this: Window, ev: Event) => any) | null;
18604     onvrdisplayfocus: ((this: Window, ev: Event) => any) | null;
18605     onvrdisplaypointerrestricted: ((this: Window, ev: Event) => any) | null;
18606     onvrdisplaypointerunrestricted: ((this: Window, ev: Event) => any) | null;
18607     onvrdisplaypresentchange: ((this: Window, ev: Event) => any) | null;
18608     opener: any;
18609     /** @deprecated */
18610     readonly orientation: string | number;
18611     readonly outerHeight: number;
18612     readonly outerWidth: number;
18613     readonly pageXOffset: number;
18614     readonly pageYOffset: number;
18615     readonly parent: Window;
18616     readonly personalbar: BarProp;
18617     readonly screen: Screen;
18618     readonly screenLeft: number;
18619     readonly screenTop: number;
18620     readonly screenX: number;
18621     readonly screenY: number;
18622     readonly scrollX: number;
18623     readonly scrollY: number;
18624     readonly scrollbars: BarProp;
18625     readonly self: Window & typeof globalThis;
18626     readonly speechSynthesis: SpeechSynthesis;
18627     status: string;
18628     readonly statusbar: BarProp;
18629     readonly styleMedia: StyleMedia;
18630     readonly toolbar: BarProp;
18631     readonly top: Window;
18632     readonly visualViewport: VisualViewport;
18633     readonly window: Window & typeof globalThis;
18634     alert(message?: any): void;
18635     blur(): void;
18636     /** @deprecated */
18637     captureEvents(): void;
18638     close(): void;
18639     confirm(message?: string): boolean;
18640     departFocus(navigationReason: NavigationReason, origin: FocusNavigationOrigin): void;
18641     focus(): void;
18642     getComputedStyle(elt: Element, pseudoElt?: string | null): CSSStyleDeclaration;
18643     getMatchedCSSRules(elt: Element, pseudoElt?: string | null): CSSRuleList;
18644     getSelection(): Selection | null;
18645     matchMedia(query: string): MediaQueryList;
18646     moveBy(x: number, y: number): void;
18647     moveTo(x: number, y: number): void;
18648     msWriteProfilerMark(profilerMarkName: string): void;
18649     open(url?: string, target?: string, features?: string, replace?: boolean): Window | null;
18650     postMessage(message: any, targetOrigin: string, transfer?: Transferable[]): void;
18651     print(): void;
18652     prompt(message?: string, _default?: string): string | null;
18653     /** @deprecated */
18654     releaseEvents(): void;
18655     resizeBy(x: number, y: number): void;
18656     resizeTo(width: number, height: number): void;
18657     scroll(options?: ScrollToOptions): void;
18658     scroll(x: number, y: number): void;
18659     scrollBy(options?: ScrollToOptions): void;
18660     scrollBy(x: number, y: number): void;
18661     scrollTo(options?: ScrollToOptions): void;
18662     scrollTo(x: number, y: number): void;
18663     stop(): void;
18664     webkitCancelAnimationFrame(handle: number): void;
18665     webkitConvertPointFromNodeToPage(node: Node, pt: WebKitPoint): WebKitPoint;
18666     webkitConvertPointFromPageToNode(node: Node, pt: WebKitPoint): WebKitPoint;
18667     webkitRequestAnimationFrame(callback: FrameRequestCallback): number;
18668     addEventListener<K extends keyof WindowEventMap>(type: K, listener: (this: Window, ev: WindowEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
18669     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
18670     removeEventListener<K extends keyof WindowEventMap>(type: K, listener: (this: Window, ev: WindowEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
18671     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
18672     [index: number]: Window;
18673 }
18674
18675 declare var Window: {
18676     prototype: Window;
18677     new(): Window;
18678 };
18679
18680 interface WindowEventHandlersEventMap {
18681     "afterprint": Event;
18682     "beforeprint": Event;
18683     "beforeunload": BeforeUnloadEvent;
18684     "hashchange": HashChangeEvent;
18685     "languagechange": Event;
18686     "message": MessageEvent;
18687     "messageerror": MessageEvent;
18688     "offline": Event;
18689     "online": Event;
18690     "pagehide": PageTransitionEvent;
18691     "pageshow": PageTransitionEvent;
18692     "popstate": PopStateEvent;
18693     "rejectionhandled": PromiseRejectionEvent;
18694     "storage": StorageEvent;
18695     "unhandledrejection": PromiseRejectionEvent;
18696     "unload": Event;
18697 }
18698
18699 interface WindowEventHandlers {
18700     onafterprint: ((this: WindowEventHandlers, ev: Event) => any) | null;
18701     onbeforeprint: ((this: WindowEventHandlers, ev: Event) => any) | null;
18702     onbeforeunload: ((this: WindowEventHandlers, ev: BeforeUnloadEvent) => any) | null;
18703     onhashchange: ((this: WindowEventHandlers, ev: HashChangeEvent) => any) | null;
18704     onlanguagechange: ((this: WindowEventHandlers, ev: Event) => any) | null;
18705     onmessage: ((this: WindowEventHandlers, ev: MessageEvent) => any) | null;
18706     onmessageerror: ((this: WindowEventHandlers, ev: MessageEvent) => any) | null;
18707     onoffline: ((this: WindowEventHandlers, ev: Event) => any) | null;
18708     ononline: ((this: WindowEventHandlers, ev: Event) => any) | null;
18709     onpagehide: ((this: WindowEventHandlers, ev: PageTransitionEvent) => any) | null;
18710     onpageshow: ((this: WindowEventHandlers, ev: PageTransitionEvent) => any) | null;
18711     onpopstate: ((this: WindowEventHandlers, ev: PopStateEvent) => any) | null;
18712     onrejectionhandled: ((this: WindowEventHandlers, ev: PromiseRejectionEvent) => any) | null;
18713     onstorage: ((this: WindowEventHandlers, ev: StorageEvent) => any) | null;
18714     onunhandledrejection: ((this: WindowEventHandlers, ev: PromiseRejectionEvent) => any) | null;
18715     onunload: ((this: WindowEventHandlers, ev: Event) => any) | null;
18716     addEventListener<K extends keyof WindowEventHandlersEventMap>(type: K, listener: (this: WindowEventHandlers, ev: WindowEventHandlersEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
18717     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
18718     removeEventListener<K extends keyof WindowEventHandlersEventMap>(type: K, listener: (this: WindowEventHandlers, ev: WindowEventHandlersEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
18719     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
18720 }
18721
18722 interface WindowLocalStorage {
18723     readonly localStorage: Storage;
18724 }
18725
18726 interface WindowOrWorkerGlobalScope {
18727     readonly caches: CacheStorage;
18728     readonly crypto: Crypto;
18729     readonly indexedDB: IDBFactory;
18730     readonly isSecureContext: boolean;
18731     readonly origin: string;
18732     readonly performance: Performance;
18733     atob(data: string): string;
18734     btoa(data: string): string;
18735     clearInterval(handle?: number): void;
18736     clearTimeout(handle?: number): void;
18737     createImageBitmap(image: ImageBitmapSource, options?: ImageBitmapOptions): Promise<ImageBitmap>;
18738     createImageBitmap(image: ImageBitmapSource, sx: number, sy: number, sw: number, sh: number, options?: ImageBitmapOptions): Promise<ImageBitmap>;
18739     fetch(input: RequestInfo, init?: RequestInit): Promise<Response>;
18740     queueMicrotask(callback: VoidFunction): void;
18741     setInterval(handler: TimerHandler, timeout?: number, ...arguments: any[]): number;
18742     setTimeout(handler: TimerHandler, timeout?: number, ...arguments: any[]): number;
18743 }
18744
18745 interface WindowSessionStorage {
18746     readonly sessionStorage: Storage;
18747 }
18748
18749 interface WorkerEventMap extends AbstractWorkerEventMap {
18750     "message": MessageEvent;
18751     "messageerror": MessageEvent;
18752 }
18753
18754 /** This Web Workers API interface represents a background task that can be easily created and can send messages back to its creator. Creating a worker is as simple as calling the Worker() constructor and specifying a script to be run in the worker thread. */
18755 interface Worker extends EventTarget, AbstractWorker {
18756     onmessage: ((this: Worker, ev: MessageEvent) => any) | null;
18757     onmessageerror: ((this: Worker, ev: MessageEvent) => any) | null;
18758     /**
18759      * Clones message and transmits it to worker's global environment. transfer can be passed as a list of objects that are to be transferred rather than cloned.
18760      */
18761     postMessage(message: any, transfer: Transferable[]): void;
18762     postMessage(message: any, options?: PostMessageOptions): void;
18763     /**
18764      * Aborts worker's associated global environment.
18765      */
18766     terminate(): void;
18767     addEventListener<K extends keyof WorkerEventMap>(type: K, listener: (this: Worker, ev: WorkerEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
18768     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
18769     removeEventListener<K extends keyof WorkerEventMap>(type: K, listener: (this: Worker, ev: WorkerEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
18770     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
18771 }
18772
18773 declare var Worker: {
18774     prototype: Worker;
18775     new(stringUrl: string | URL, options?: WorkerOptions): Worker;
18776 };
18777
18778 interface Worklet {
18779     addModule(moduleURL: string, options?: WorkletOptions): Promise<void>;
18780 }
18781
18782 declare var Worklet: {
18783     prototype: Worklet;
18784     new(): Worklet;
18785 };
18786
18787 /** This Streams API interface provides a standard abstraction for writing streaming data to a destination, known as a sink. This object comes with built-in backpressure and queuing. */
18788 interface WritableStream<W = any> {
18789     readonly locked: boolean;
18790     abort(reason?: any): Promise<void>;
18791     getWriter(): WritableStreamDefaultWriter<W>;
18792 }
18793
18794 declare var WritableStream: {
18795     prototype: WritableStream;
18796     new<W = any>(underlyingSink?: UnderlyingSink<W>, strategy?: QueuingStrategy<W>): WritableStream<W>;
18797 };
18798
18799 /** This Streams API interface represents a controller allowing control of a WritableStream's state. When constructing a WritableStream, the underlying sink is given a corresponding WritableStreamDefaultController instance to manipulate. */
18800 interface WritableStreamDefaultController {
18801     error(e?: any): void;
18802 }
18803
18804 declare var WritableStreamDefaultController: {
18805     prototype: WritableStreamDefaultController;
18806     new(): WritableStreamDefaultController;
18807 };
18808
18809 /** This Streams API interface is the object returned by WritableStream.getWriter() and once created locks the < writer to the WritableStream ensuring that no other streams can write to the underlying sink. */
18810 interface WritableStreamDefaultWriter<W = any> {
18811     readonly closed: Promise<undefined>;
18812     readonly desiredSize: number | null;
18813     readonly ready: Promise<undefined>;
18814     abort(reason?: any): Promise<void>;
18815     close(): Promise<void>;
18816     releaseLock(): void;
18817     write(chunk: W): Promise<void>;
18818 }
18819
18820 declare var WritableStreamDefaultWriter: {
18821     prototype: WritableStreamDefaultWriter;
18822     new<W = any>(stream: WritableStream<W>): WritableStreamDefaultWriter<W>;
18823 };
18824
18825 /** An XML document. It inherits from the generic Document and does not add any specific methods or properties to it: nevertheless, several algorithms behave differently with the two types of documents. */
18826 interface XMLDocument extends Document {
18827     addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: XMLDocument, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
18828     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
18829     removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: XMLDocument, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
18830     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
18831 }
18832
18833 declare var XMLDocument: {
18834     prototype: XMLDocument;
18835     new(): XMLDocument;
18836 };
18837
18838 interface XMLHttpRequestEventMap extends XMLHttpRequestEventTargetEventMap {
18839     "readystatechange": Event;
18840 }
18841
18842 /** Use XMLHttpRequest (XHR) objects to interact with servers. You can retrieve data from a URL without having to do a full page refresh. This enables a Web page to update just part of a page without disrupting what the user is doing. */
18843 interface XMLHttpRequest extends XMLHttpRequestEventTarget {
18844     onreadystatechange: ((this: XMLHttpRequest, ev: Event) => any) | null;
18845     /**
18846      * Returns client's state.
18847      */
18848     readonly readyState: number;
18849     /**
18850      * Returns the response's body.
18851      */
18852     readonly response: any;
18853     /**
18854      * Returns the text response.
18855      *
18856      * Throws an "InvalidStateError" DOMException if responseType is not the empty string or "text".
18857      */
18858     readonly responseText: string;
18859     /**
18860      * Returns the response type.
18861      *
18862      * Can be set to change the response type. Values are: the empty string (default), "arraybuffer", "blob", "document", "json", and "text".
18863      *
18864      * When set: setting to "document" is ignored if current global object is not a Window object.
18865      *
18866      * When set: throws an "InvalidStateError" DOMException if state is loading or done.
18867      *
18868      * When set: throws an "InvalidAccessError" DOMException if the synchronous flag is set and current global object is a Window object.
18869      */
18870     responseType: XMLHttpRequestResponseType;
18871     readonly responseURL: string;
18872     /**
18873      * Returns the document response.
18874      *
18875      * Throws an "InvalidStateError" DOMException if responseType is not the empty string or "document".
18876      */
18877     readonly responseXML: Document | null;
18878     readonly status: number;
18879     readonly statusText: string;
18880     /**
18881      * Can be set to a time in milliseconds. When set to a non-zero value will cause fetching to terminate after the given time has passed. When the time has passed, the request has not yet completed, and the synchronous flag is unset, a timeout event will then be dispatched, or a "TimeoutError" DOMException will be thrown otherwise (for the send() method).
18882      *
18883      * When set: throws an "InvalidAccessError" DOMException if the synchronous flag is set and current global object is a Window object.
18884      */
18885     timeout: number;
18886     /**
18887      * Returns the associated XMLHttpRequestUpload object. It can be used to gather transmission information when data is transferred to a server.
18888      */
18889     readonly upload: XMLHttpRequestUpload;
18890     /**
18891      * True when credentials are to be included in a cross-origin request. False when they are to be excluded in a cross-origin request and when cookies are to be ignored in its response. Initially false.
18892      *
18893      * When set: throws an "InvalidStateError" DOMException if state is not unsent or opened, or if the send() flag is set.
18894      */
18895     withCredentials: boolean;
18896     /**
18897      * Cancels any network activity.
18898      */
18899     abort(): void;
18900     getAllResponseHeaders(): string;
18901     getResponseHeader(name: string): string | null;
18902     /**
18903      * Sets the request method, request URL, and synchronous flag.
18904      *
18905      * Throws a "SyntaxError" DOMException if either method is not a valid HTTP method or url cannot be parsed.
18906      *
18907      * Throws a "SecurityError" DOMException if method is a case-insensitive match for `CONNECT`, `TRACE`, or `TRACK`.
18908      *
18909      * Throws an "InvalidAccessError" DOMException if async is false, current global object is a Window object, and the timeout attribute is not zero or the responseType attribute is not the empty string.
18910      */
18911     open(method: string, url: string): void;
18912     open(method: string, url: string, async: boolean, username?: string | null, password?: string | null): void;
18913     /**
18914      * Acts as if the `Content-Type` header value for response is mime. (It does not actually change the header though.)
18915      *
18916      * Throws an "InvalidStateError" DOMException if state is loading or done.
18917      */
18918     overrideMimeType(mime: string): void;
18919     /**
18920      * Initiates the request. The body argument provides the request body, if any, and is ignored if the request method is GET or HEAD.
18921      *
18922      * Throws an "InvalidStateError" DOMException if either state is not opened or the send() flag is set.
18923      */
18924     send(body?: Document | BodyInit | null): void;
18925     /**
18926      * Combines a header in author request headers.
18927      *
18928      * Throws an "InvalidStateError" DOMException if either state is not opened or the send() flag is set.
18929      *
18930      * Throws a "SyntaxError" DOMException if name is not a header name or if value is not a header value.
18931      */
18932     setRequestHeader(name: string, value: string): void;
18933     readonly DONE: number;
18934     readonly HEADERS_RECEIVED: number;
18935     readonly LOADING: number;
18936     readonly OPENED: number;
18937     readonly UNSENT: number;
18938     addEventListener<K extends keyof XMLHttpRequestEventMap>(type: K, listener: (this: XMLHttpRequest, ev: XMLHttpRequestEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
18939     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
18940     removeEventListener<K extends keyof XMLHttpRequestEventMap>(type: K, listener: (this: XMLHttpRequest, ev: XMLHttpRequestEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
18941     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
18942 }
18943
18944 declare var XMLHttpRequest: {
18945     prototype: XMLHttpRequest;
18946     new(): XMLHttpRequest;
18947     readonly DONE: number;
18948     readonly HEADERS_RECEIVED: number;
18949     readonly LOADING: number;
18950     readonly OPENED: number;
18951     readonly UNSENT: number;
18952 };
18953
18954 interface XMLHttpRequestEventTargetEventMap {
18955     "abort": ProgressEvent<XMLHttpRequestEventTarget>;
18956     "error": ProgressEvent<XMLHttpRequestEventTarget>;
18957     "load": ProgressEvent<XMLHttpRequestEventTarget>;
18958     "loadend": ProgressEvent<XMLHttpRequestEventTarget>;
18959     "loadstart": ProgressEvent<XMLHttpRequestEventTarget>;
18960     "progress": ProgressEvent<XMLHttpRequestEventTarget>;
18961     "timeout": ProgressEvent<XMLHttpRequestEventTarget>;
18962 }
18963
18964 interface XMLHttpRequestEventTarget extends EventTarget {
18965     onabort: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
18966     onerror: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
18967     onload: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
18968     onloadend: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
18969     onloadstart: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
18970     onprogress: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
18971     ontimeout: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
18972     addEventListener<K extends keyof XMLHttpRequestEventTargetEventMap>(type: K, listener: (this: XMLHttpRequestEventTarget, ev: XMLHttpRequestEventTargetEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
18973     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
18974     removeEventListener<K extends keyof XMLHttpRequestEventTargetEventMap>(type: K, listener: (this: XMLHttpRequestEventTarget, ev: XMLHttpRequestEventTargetEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
18975     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
18976 }
18977
18978 declare var XMLHttpRequestEventTarget: {
18979     prototype: XMLHttpRequestEventTarget;
18980     new(): XMLHttpRequestEventTarget;
18981 };
18982
18983 interface XMLHttpRequestUpload extends XMLHttpRequestEventTarget {
18984     addEventListener<K extends keyof XMLHttpRequestEventTargetEventMap>(type: K, listener: (this: XMLHttpRequestUpload, ev: XMLHttpRequestEventTargetEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
18985     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
18986     removeEventListener<K extends keyof XMLHttpRequestEventTargetEventMap>(type: K, listener: (this: XMLHttpRequestUpload, ev: XMLHttpRequestEventTargetEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
18987     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
18988 }
18989
18990 declare var XMLHttpRequestUpload: {
18991     prototype: XMLHttpRequestUpload;
18992     new(): XMLHttpRequestUpload;
18993 };
18994
18995 /** Provides the serializeToString() method to construct an XML string representing a DOM tree. */
18996 interface XMLSerializer {
18997     serializeToString(root: Node): string;
18998 }
18999
19000 declare var XMLSerializer: {
19001     prototype: XMLSerializer;
19002     new(): XMLSerializer;
19003 };
19004
19005 /** The XPathEvaluator interface allows to compile and evaluate XPath expressions. */
19006 interface XPathEvaluator extends XPathEvaluatorBase {
19007 }
19008
19009 declare var XPathEvaluator: {
19010     prototype: XPathEvaluator;
19011     new(): XPathEvaluator;
19012 };
19013
19014 interface XPathEvaluatorBase {
19015     createExpression(expression: string, resolver?: XPathNSResolver | null): XPathExpression;
19016     createNSResolver(nodeResolver: Node): XPathNSResolver;
19017     evaluate(expression: string, contextNode: Node, resolver?: XPathNSResolver | null, type?: number, result?: XPathResult | null): XPathResult;
19018 }
19019
19020 /** This interface is a compiled XPath expression that can be evaluated on a document or specific node to return information its DOM tree. */
19021 interface XPathExpression {
19022     evaluate(contextNode: Node, type?: number, result?: XPathResult | null): XPathResult;
19023 }
19024
19025 declare var XPathExpression: {
19026     prototype: XPathExpression;
19027     new(): XPathExpression;
19028 };
19029
19030 /** The results generated by evaluating an XPath expression within the context of a given node. */
19031 interface XPathResult {
19032     readonly booleanValue: boolean;
19033     readonly invalidIteratorState: boolean;
19034     readonly numberValue: number;
19035     readonly resultType: number;
19036     readonly singleNodeValue: Node | null;
19037     readonly snapshotLength: number;
19038     readonly stringValue: string;
19039     iterateNext(): Node | null;
19040     snapshotItem(index: number): Node | null;
19041     readonly ANY_TYPE: number;
19042     readonly ANY_UNORDERED_NODE_TYPE: number;
19043     readonly BOOLEAN_TYPE: number;
19044     readonly FIRST_ORDERED_NODE_TYPE: number;
19045     readonly NUMBER_TYPE: number;
19046     readonly ORDERED_NODE_ITERATOR_TYPE: number;
19047     readonly ORDERED_NODE_SNAPSHOT_TYPE: number;
19048     readonly STRING_TYPE: number;
19049     readonly UNORDERED_NODE_ITERATOR_TYPE: number;
19050     readonly UNORDERED_NODE_SNAPSHOT_TYPE: number;
19051 }
19052
19053 declare var XPathResult: {
19054     prototype: XPathResult;
19055     new(): XPathResult;
19056     readonly ANY_TYPE: number;
19057     readonly ANY_UNORDERED_NODE_TYPE: number;
19058     readonly BOOLEAN_TYPE: number;
19059     readonly FIRST_ORDERED_NODE_TYPE: number;
19060     readonly NUMBER_TYPE: number;
19061     readonly ORDERED_NODE_ITERATOR_TYPE: number;
19062     readonly ORDERED_NODE_SNAPSHOT_TYPE: number;
19063     readonly STRING_TYPE: number;
19064     readonly UNORDERED_NODE_ITERATOR_TYPE: number;
19065     readonly UNORDERED_NODE_SNAPSHOT_TYPE: number;
19066 };
19067
19068 /** An XSLTProcessor applies an XSLT stylesheet transformation to an XML document to produce a new XML document as output. It has methods to load the XSLT stylesheet, to manipulate <xsl:param> parameter values, and to apply the transformation to documents. */
19069 interface XSLTProcessor {
19070     clearParameters(): void;
19071     getParameter(namespaceURI: string, localName: string): any;
19072     importStylesheet(style: Node): void;
19073     removeParameter(namespaceURI: string, localName: string): void;
19074     reset(): void;
19075     setParameter(namespaceURI: string, localName: string, value: any): void;
19076     transformToDocument(source: Node): Document;
19077     transformToFragment(source: Node, document: Document): DocumentFragment;
19078 }
19079
19080 declare var XSLTProcessor: {
19081     prototype: XSLTProcessor;
19082     new(): XSLTProcessor;
19083 };
19084
19085 interface webkitRTCPeerConnection extends RTCPeerConnection {
19086     addEventListener<K extends keyof RTCPeerConnectionEventMap>(type: K, listener: (this: webkitRTCPeerConnection, ev: RTCPeerConnectionEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
19087     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
19088     removeEventListener<K extends keyof RTCPeerConnectionEventMap>(type: K, listener: (this: webkitRTCPeerConnection, ev: RTCPeerConnectionEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
19089     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
19090 }
19091
19092 declare var webkitRTCPeerConnection: {
19093     prototype: webkitRTCPeerConnection;
19094     new(configuration: RTCConfiguration): webkitRTCPeerConnection;
19095 };
19096
19097 declare type EventListenerOrEventListenerObject = EventListener | EventListenerObject;
19098
19099 interface Console {
19100     memory: any;
19101     assert(condition?: boolean, ...data: any[]): void;
19102     clear(): void;
19103     count(label?: string): void;
19104     countReset(label?: string): void;
19105     debug(...data: any[]): void;
19106     dir(item?: any, options?: any): void;
19107     dirxml(...data: any[]): void;
19108     error(...data: any[]): void;
19109     exception(message?: string, ...optionalParams: any[]): void;
19110     group(...data: any[]): void;
19111     groupCollapsed(...data: any[]): void;
19112     groupEnd(): void;
19113     info(...data: any[]): void;
19114     log(...data: any[]): void;
19115     table(tabularData?: any, properties?: string[]): void;
19116     time(label?: string): void;
19117     timeEnd(label?: string): void;
19118     timeLog(label?: string, ...data: any[]): void;
19119     timeStamp(label?: string): void;
19120     trace(...data: any[]): void;
19121     warn(...data: any[]): void;
19122 }
19123
19124 declare var console: Console;
19125
19126 /** Holds useful CSS-related methods. No object with this interface are implemented: it contains only static methods and therefore is a utilitarian interface. */
19127 declare namespace CSS {
19128     function escape(ident: string): string;
19129     function supports(property: string, value: string): boolean;
19130     function supports(conditionText: string): boolean;
19131 }
19132
19133 declare namespace WebAssembly {
19134     interface CompileError {
19135     }
19136
19137     var CompileError: {
19138         prototype: CompileError;
19139         new(): CompileError;
19140     };
19141
19142     interface Global {
19143         value: any;
19144         valueOf(): any;
19145     }
19146
19147     var Global: {
19148         prototype: Global;
19149         new(descriptor: GlobalDescriptor, v?: any): Global;
19150     };
19151
19152     interface Instance {
19153         readonly exports: Exports;
19154     }
19155
19156     var Instance: {
19157         prototype: Instance;
19158         new(module: Module, importObject?: Imports): Instance;
19159     };
19160
19161     interface LinkError {
19162     }
19163
19164     var LinkError: {
19165         prototype: LinkError;
19166         new(): LinkError;
19167     };
19168
19169     interface Memory {
19170         readonly buffer: ArrayBuffer;
19171         grow(delta: number): number;
19172     }
19173
19174     var Memory: {
19175         prototype: Memory;
19176         new(descriptor: MemoryDescriptor): Memory;
19177     };
19178
19179     interface Module {
19180     }
19181
19182     var Module: {
19183         prototype: Module;
19184         new(bytes: BufferSource): Module;
19185         customSections(moduleObject: Module, sectionName: string): ArrayBuffer[];
19186         exports(moduleObject: Module): ModuleExportDescriptor[];
19187         imports(moduleObject: Module): ModuleImportDescriptor[];
19188     };
19189
19190     interface RuntimeError {
19191     }
19192
19193     var RuntimeError: {
19194         prototype: RuntimeError;
19195         new(): RuntimeError;
19196     };
19197
19198     interface Table {
19199         readonly length: number;
19200         get(index: number): Function | null;
19201         grow(delta: number): number;
19202         set(index: number, value: Function | null): void;
19203     }
19204
19205     var Table: {
19206         prototype: Table;
19207         new(descriptor: TableDescriptor): Table;
19208     };
19209
19210     interface GlobalDescriptor {
19211         mutable?: boolean;
19212         value: ValueType;
19213     }
19214
19215     interface MemoryDescriptor {
19216         initial: number;
19217         maximum?: number;
19218     }
19219
19220     interface ModuleExportDescriptor {
19221         kind: ImportExportKind;
19222         name: string;
19223     }
19224
19225     interface ModuleImportDescriptor {
19226         kind: ImportExportKind;
19227         module: string;
19228         name: string;
19229     }
19230
19231     interface TableDescriptor {
19232         element: TableKind;
19233         initial: number;
19234         maximum?: number;
19235     }
19236
19237     interface WebAssemblyInstantiatedSource {
19238         instance: Instance;
19239         module: Module;
19240     }
19241
19242     type ImportExportKind = "function" | "global" | "memory" | "table";
19243     type TableKind = "anyfunc";
19244     type ValueType = "f32" | "f64" | "i32" | "i64";
19245     type ExportValue = Function | Global | Memory | Table;
19246     type Exports = Record<string, ExportValue>;
19247     type ImportValue = ExportValue | number;
19248     type ModuleImports = Record<string, ImportValue>;
19249     type Imports = Record<string, ModuleImports>;
19250     function compile(bytes: BufferSource): Promise<Module>;
19251     function compileStreaming(source: Response | Promise<Response>): Promise<Module>;
19252     function instantiate(bytes: BufferSource, importObject?: Imports): Promise<WebAssemblyInstantiatedSource>;
19253     function instantiate(moduleObject: Module, importObject?: Imports): Promise<Instance>;
19254     function instantiateStreaming(response: Response | PromiseLike<Response>, importObject?: Imports): Promise<WebAssemblyInstantiatedSource>;
19255     function validate(bytes: BufferSource): boolean;
19256 }
19257
19258 interface BlobCallback {
19259     (blob: Blob | null): void;
19260 }
19261
19262 interface CustomElementConstructor {
19263     new (...params: any[]): HTMLElement;
19264 }
19265
19266 interface DecodeErrorCallback {
19267     (error: DOMException): void;
19268 }
19269
19270 interface DecodeSuccessCallback {
19271     (decodedData: AudioBuffer): void;
19272 }
19273
19274 interface EventHandlerNonNull {
19275     (event: Event): any;
19276 }
19277
19278 interface ForEachCallback {
19279     (keyId: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer | null, status: MediaKeyStatus): void;
19280 }
19281
19282 interface FrameRequestCallback {
19283     (time: number): void;
19284 }
19285
19286 interface FunctionStringCallback {
19287     (data: string): void;
19288 }
19289
19290 interface IntersectionObserverCallback {
19291     (entries: IntersectionObserverEntry[], observer: IntersectionObserver): void;
19292 }
19293
19294 interface MSLaunchUriCallback {
19295     (): void;
19296 }
19297
19298 interface MutationCallback {
19299     (mutations: MutationRecord[], observer: MutationObserver): void;
19300 }
19301
19302 interface NavigatorUserMediaErrorCallback {
19303     (error: MediaStreamError): void;
19304 }
19305
19306 interface NavigatorUserMediaSuccessCallback {
19307     (stream: MediaStream): void;
19308 }
19309
19310 interface NotificationPermissionCallback {
19311     (permission: NotificationPermission): void;
19312 }
19313
19314 interface OnBeforeUnloadEventHandlerNonNull {
19315     (event: Event): string | null;
19316 }
19317
19318 interface OnErrorEventHandlerNonNull {
19319     (event: Event | string, source?: string, lineno?: number, colno?: number, error?: Error): any;
19320 }
19321
19322 interface PerformanceObserverCallback {
19323     (entries: PerformanceObserverEntryList, observer: PerformanceObserver): void;
19324 }
19325
19326 interface PositionCallback {
19327     (position: GeolocationPosition): void;
19328 }
19329
19330 interface PositionErrorCallback {
19331     (positionError: GeolocationPositionError): void;
19332 }
19333
19334 interface QueuingStrategySize<T = any> {
19335     (chunk: T): number;
19336 }
19337
19338 interface RTCPeerConnectionErrorCallback {
19339     (error: DOMException): void;
19340 }
19341
19342 interface RTCSessionDescriptionCallback {
19343     (description: RTCSessionDescriptionInit): void;
19344 }
19345
19346 interface RTCStatsCallback {
19347     (report: RTCStatsReport): void;
19348 }
19349
19350 interface ResizeObserverCallback {
19351     (entries: ResizeObserverEntry[], observer: ResizeObserver): void;
19352 }
19353
19354 interface TransformerFlushCallback<O> {
19355     (controller: TransformStreamDefaultController<O>): void | PromiseLike<void>;
19356 }
19357
19358 interface TransformerStartCallback<O> {
19359     (controller: TransformStreamDefaultController<O>): void | PromiseLike<void>;
19360 }
19361
19362 interface TransformerTransformCallback<I, O> {
19363     (chunk: I, controller: TransformStreamDefaultController<O>): void | PromiseLike<void>;
19364 }
19365
19366 interface UnderlyingSinkAbortCallback {
19367     (reason: any): void | PromiseLike<void>;
19368 }
19369
19370 interface UnderlyingSinkCloseCallback {
19371     (): void | PromiseLike<void>;
19372 }
19373
19374 interface UnderlyingSinkStartCallback {
19375     (controller: WritableStreamDefaultController): void | PromiseLike<void>;
19376 }
19377
19378 interface UnderlyingSinkWriteCallback<W> {
19379     (chunk: W, controller: WritableStreamDefaultController): void | PromiseLike<void>;
19380 }
19381
19382 interface UnderlyingSourceCancelCallback {
19383     (reason: any): void | PromiseLike<void>;
19384 }
19385
19386 interface UnderlyingSourcePullCallback<R> {
19387     (controller: ReadableStreamController<R>): void | PromiseLike<void>;
19388 }
19389
19390 interface UnderlyingSourceStartCallback<R> {
19391     (controller: ReadableStreamController<R>): void | PromiseLike<void>;
19392 }
19393
19394 interface VoidFunction {
19395     (): void;
19396 }
19397
19398 interface HTMLElementTagNameMap {
19399     "a": HTMLAnchorElement;
19400     "abbr": HTMLElement;
19401     "address": HTMLElement;
19402     "applet": HTMLAppletElement;
19403     "area": HTMLAreaElement;
19404     "article": HTMLElement;
19405     "aside": HTMLElement;
19406     "audio": HTMLAudioElement;
19407     "b": HTMLElement;
19408     "base": HTMLBaseElement;
19409     "basefont": HTMLBaseFontElement;
19410     "bdi": HTMLElement;
19411     "bdo": HTMLElement;
19412     "blockquote": HTMLQuoteElement;
19413     "body": HTMLBodyElement;
19414     "br": HTMLBRElement;
19415     "button": HTMLButtonElement;
19416     "canvas": HTMLCanvasElement;
19417     "caption": HTMLTableCaptionElement;
19418     "cite": HTMLElement;
19419     "code": HTMLElement;
19420     "col": HTMLTableColElement;
19421     "colgroup": HTMLTableColElement;
19422     "data": HTMLDataElement;
19423     "datalist": HTMLDataListElement;
19424     "dd": HTMLElement;
19425     "del": HTMLModElement;
19426     "details": HTMLDetailsElement;
19427     "dfn": HTMLElement;
19428     "dialog": HTMLDialogElement;
19429     "dir": HTMLDirectoryElement;
19430     "div": HTMLDivElement;
19431     "dl": HTMLDListElement;
19432     "dt": HTMLElement;
19433     "em": HTMLElement;
19434     "embed": HTMLEmbedElement;
19435     "fieldset": HTMLFieldSetElement;
19436     "figcaption": HTMLElement;
19437     "figure": HTMLElement;
19438     "font": HTMLFontElement;
19439     "footer": HTMLElement;
19440     "form": HTMLFormElement;
19441     "frame": HTMLFrameElement;
19442     "frameset": HTMLFrameSetElement;
19443     "h1": HTMLHeadingElement;
19444     "h2": HTMLHeadingElement;
19445     "h3": HTMLHeadingElement;
19446     "h4": HTMLHeadingElement;
19447     "h5": HTMLHeadingElement;
19448     "h6": HTMLHeadingElement;
19449     "head": HTMLHeadElement;
19450     "header": HTMLElement;
19451     "hgroup": HTMLElement;
19452     "hr": HTMLHRElement;
19453     "html": HTMLHtmlElement;
19454     "i": HTMLElement;
19455     "iframe": HTMLIFrameElement;
19456     "img": HTMLImageElement;
19457     "input": HTMLInputElement;
19458     "ins": HTMLModElement;
19459     "kbd": HTMLElement;
19460     "label": HTMLLabelElement;
19461     "legend": HTMLLegendElement;
19462     "li": HTMLLIElement;
19463     "link": HTMLLinkElement;
19464     "main": HTMLElement;
19465     "map": HTMLMapElement;
19466     "mark": HTMLElement;
19467     "marquee": HTMLMarqueeElement;
19468     "menu": HTMLMenuElement;
19469     "meta": HTMLMetaElement;
19470     "meter": HTMLMeterElement;
19471     "nav": HTMLElement;
19472     "noscript": HTMLElement;
19473     "object": HTMLObjectElement;
19474     "ol": HTMLOListElement;
19475     "optgroup": HTMLOptGroupElement;
19476     "option": HTMLOptionElement;
19477     "output": HTMLOutputElement;
19478     "p": HTMLParagraphElement;
19479     "param": HTMLParamElement;
19480     "picture": HTMLPictureElement;
19481     "pre": HTMLPreElement;
19482     "progress": HTMLProgressElement;
19483     "q": HTMLQuoteElement;
19484     "rp": HTMLElement;
19485     "rt": HTMLElement;
19486     "ruby": HTMLElement;
19487     "s": HTMLElement;
19488     "samp": HTMLElement;
19489     "script": HTMLScriptElement;
19490     "section": HTMLElement;
19491     "select": HTMLSelectElement;
19492     "slot": HTMLSlotElement;
19493     "small": HTMLElement;
19494     "source": HTMLSourceElement;
19495     "span": HTMLSpanElement;
19496     "strong": HTMLElement;
19497     "style": HTMLStyleElement;
19498     "sub": HTMLElement;
19499     "summary": HTMLElement;
19500     "sup": HTMLElement;
19501     "table": HTMLTableElement;
19502     "tbody": HTMLTableSectionElement;
19503     "td": HTMLTableDataCellElement;
19504     "template": HTMLTemplateElement;
19505     "textarea": HTMLTextAreaElement;
19506     "tfoot": HTMLTableSectionElement;
19507     "th": HTMLTableHeaderCellElement;
19508     "thead": HTMLTableSectionElement;
19509     "time": HTMLTimeElement;
19510     "title": HTMLTitleElement;
19511     "tr": HTMLTableRowElement;
19512     "track": HTMLTrackElement;
19513     "u": HTMLElement;
19514     "ul": HTMLUListElement;
19515     "var": HTMLElement;
19516     "video": HTMLVideoElement;
19517     "wbr": HTMLElement;
19518 }
19519
19520 interface HTMLElementDeprecatedTagNameMap {
19521     "listing": HTMLPreElement;
19522     "xmp": HTMLPreElement;
19523 }
19524
19525 interface SVGElementTagNameMap {
19526     "a": SVGAElement;
19527     "circle": SVGCircleElement;
19528     "clipPath": SVGClipPathElement;
19529     "defs": SVGDefsElement;
19530     "desc": SVGDescElement;
19531     "ellipse": SVGEllipseElement;
19532     "feBlend": SVGFEBlendElement;
19533     "feColorMatrix": SVGFEColorMatrixElement;
19534     "feComponentTransfer": SVGFEComponentTransferElement;
19535     "feComposite": SVGFECompositeElement;
19536     "feConvolveMatrix": SVGFEConvolveMatrixElement;
19537     "feDiffuseLighting": SVGFEDiffuseLightingElement;
19538     "feDisplacementMap": SVGFEDisplacementMapElement;
19539     "feDistantLight": SVGFEDistantLightElement;
19540     "feFlood": SVGFEFloodElement;
19541     "feFuncA": SVGFEFuncAElement;
19542     "feFuncB": SVGFEFuncBElement;
19543     "feFuncG": SVGFEFuncGElement;
19544     "feFuncR": SVGFEFuncRElement;
19545     "feGaussianBlur": SVGFEGaussianBlurElement;
19546     "feImage": SVGFEImageElement;
19547     "feMerge": SVGFEMergeElement;
19548     "feMergeNode": SVGFEMergeNodeElement;
19549     "feMorphology": SVGFEMorphologyElement;
19550     "feOffset": SVGFEOffsetElement;
19551     "fePointLight": SVGFEPointLightElement;
19552     "feSpecularLighting": SVGFESpecularLightingElement;
19553     "feSpotLight": SVGFESpotLightElement;
19554     "feTile": SVGFETileElement;
19555     "feTurbulence": SVGFETurbulenceElement;
19556     "filter": SVGFilterElement;
19557     "foreignObject": SVGForeignObjectElement;
19558     "g": SVGGElement;
19559     "image": SVGImageElement;
19560     "line": SVGLineElement;
19561     "linearGradient": SVGLinearGradientElement;
19562     "marker": SVGMarkerElement;
19563     "mask": SVGMaskElement;
19564     "metadata": SVGMetadataElement;
19565     "path": SVGPathElement;
19566     "pattern": SVGPatternElement;
19567     "polygon": SVGPolygonElement;
19568     "polyline": SVGPolylineElement;
19569     "radialGradient": SVGRadialGradientElement;
19570     "rect": SVGRectElement;
19571     "script": SVGScriptElement;
19572     "stop": SVGStopElement;
19573     "style": SVGStyleElement;
19574     "svg": SVGSVGElement;
19575     "switch": SVGSwitchElement;
19576     "symbol": SVGSymbolElement;
19577     "text": SVGTextElement;
19578     "textPath": SVGTextPathElement;
19579     "title": SVGTitleElement;
19580     "tspan": SVGTSpanElement;
19581     "use": SVGUseElement;
19582     "view": SVGViewElement;
19583 }
19584
19585 /** @deprecated Directly use HTMLElementTagNameMap or SVGElementTagNameMap as appropriate, instead. */
19586 type ElementTagNameMap = HTMLElementTagNameMap & Pick<SVGElementTagNameMap, Exclude<keyof SVGElementTagNameMap, keyof HTMLElementTagNameMap>>;
19587
19588 declare var Audio: {
19589     new(src?: string): HTMLAudioElement;
19590 };
19591 declare var Image: {
19592     new(width?: number, height?: number): HTMLImageElement;
19593 };
19594 declare var Option: {
19595     new(text?: string, value?: string, defaultSelected?: boolean, selected?: boolean): HTMLOptionElement;
19596 };
19597 declare var applicationCache: ApplicationCache;
19598 declare var clientInformation: Navigator;
19599 declare var closed: boolean;
19600 declare var customElements: CustomElementRegistry;
19601 declare var defaultStatus: string;
19602 declare var devicePixelRatio: number;
19603 declare var doNotTrack: string;
19604 declare var document: Document;
19605 /** @deprecated */
19606 declare var event: Event | undefined;
19607 /** @deprecated */
19608 declare var external: External;
19609 declare var frameElement: Element | null;
19610 declare var frames: Window;
19611 declare var history: History;
19612 declare var innerHeight: number;
19613 declare var innerWidth: number;
19614 declare var length: number;
19615 declare var location: Location;
19616 declare var locationbar: BarProp;
19617 declare var menubar: BarProp;
19618 declare var msContentScript: ExtensionScriptApis;
19619 /** @deprecated */
19620 declare const name: void;
19621 declare var navigator: Navigator;
19622 declare var offscreenBuffering: string | boolean;
19623 declare var oncompassneedscalibration: ((this: Window, ev: Event) => any) | null;
19624 declare var ondevicelight: ((this: Window, ev: DeviceLightEvent) => any) | null;
19625 declare var ondevicemotion: ((this: Window, ev: DeviceMotionEvent) => any) | null;
19626 declare var ondeviceorientation: ((this: Window, ev: DeviceOrientationEvent) => any) | null;
19627 declare var ondeviceorientationabsolute: ((this: Window, ev: DeviceOrientationEvent) => any) | null;
19628 declare var ongamepadconnected: ((this: Window, ev: GamepadEvent) => any) | null;
19629 declare var ongamepaddisconnected: ((this: Window, ev: GamepadEvent) => any) | null;
19630 declare var onmousewheel: ((this: Window, ev: Event) => any) | null;
19631 declare var onmsgesturechange: ((this: Window, ev: Event) => any) | null;
19632 declare var onmsgesturedoubletap: ((this: Window, ev: Event) => any) | null;
19633 declare var onmsgestureend: ((this: Window, ev: Event) => any) | null;
19634 declare var onmsgesturehold: ((this: Window, ev: Event) => any) | null;
19635 declare var onmsgesturestart: ((this: Window, ev: Event) => any) | null;
19636 declare var onmsgesturetap: ((this: Window, ev: Event) => any) | null;
19637 declare var onmsinertiastart: ((this: Window, ev: Event) => any) | null;
19638 declare var onmspointercancel: ((this: Window, ev: Event) => any) | null;
19639 declare var onmspointerdown: ((this: Window, ev: Event) => any) | null;
19640 declare var onmspointerenter: ((this: Window, ev: Event) => any) | null;
19641 declare var onmspointerleave: ((this: Window, ev: Event) => any) | null;
19642 declare var onmspointermove: ((this: Window, ev: Event) => any) | null;
19643 declare var onmspointerout: ((this: Window, ev: Event) => any) | null;
19644 declare var onmspointerover: ((this: Window, ev: Event) => any) | null;
19645 declare var onmspointerup: ((this: Window, ev: Event) => any) | null;
19646 /** @deprecated */
19647 declare var onorientationchange: ((this: Window, ev: Event) => any) | null;
19648 declare var onreadystatechange: ((this: Window, ev: ProgressEvent<Window>) => any) | null;
19649 declare var onvrdisplayactivate: ((this: Window, ev: Event) => any) | null;
19650 declare var onvrdisplayblur: ((this: Window, ev: Event) => any) | null;
19651 declare var onvrdisplayconnect: ((this: Window, ev: Event) => any) | null;
19652 declare var onvrdisplaydeactivate: ((this: Window, ev: Event) => any) | null;
19653 declare var onvrdisplaydisconnect: ((this: Window, ev: Event) => any) | null;
19654 declare var onvrdisplayfocus: ((this: Window, ev: Event) => any) | null;
19655 declare var onvrdisplaypointerrestricted: ((this: Window, ev: Event) => any) | null;
19656 declare var onvrdisplaypointerunrestricted: ((this: Window, ev: Event) => any) | null;
19657 declare var onvrdisplaypresentchange: ((this: Window, ev: Event) => any) | null;
19658 declare var opener: any;
19659 /** @deprecated */
19660 declare var orientation: string | number;
19661 declare var outerHeight: number;
19662 declare var outerWidth: number;
19663 declare var pageXOffset: number;
19664 declare var pageYOffset: number;
19665 declare var parent: Window;
19666 declare var personalbar: BarProp;
19667 declare var screen: Screen;
19668 declare var screenLeft: number;
19669 declare var screenTop: number;
19670 declare var screenX: number;
19671 declare var screenY: number;
19672 declare var scrollX: number;
19673 declare var scrollY: number;
19674 declare var scrollbars: BarProp;
19675 declare var self: Window & typeof globalThis;
19676 declare var speechSynthesis: SpeechSynthesis;
19677 declare var status: string;
19678 declare var statusbar: BarProp;
19679 declare var styleMedia: StyleMedia;
19680 declare var toolbar: BarProp;
19681 declare var top: Window;
19682 declare var visualViewport: VisualViewport;
19683 declare var window: Window & typeof globalThis;
19684 declare function alert(message?: any): void;
19685 declare function blur(): void;
19686 /** @deprecated */
19687 declare function captureEvents(): void;
19688 declare function close(): void;
19689 declare function confirm(message?: string): boolean;
19690 declare function departFocus(navigationReason: NavigationReason, origin: FocusNavigationOrigin): void;
19691 declare function focus(): void;
19692 declare function getComputedStyle(elt: Element, pseudoElt?: string | null): CSSStyleDeclaration;
19693 declare function getMatchedCSSRules(elt: Element, pseudoElt?: string | null): CSSRuleList;
19694 declare function getSelection(): Selection | null;
19695 declare function matchMedia(query: string): MediaQueryList;
19696 declare function moveBy(x: number, y: number): void;
19697 declare function moveTo(x: number, y: number): void;
19698 declare function msWriteProfilerMark(profilerMarkName: string): void;
19699 declare function open(url?: string, target?: string, features?: string, replace?: boolean): Window | null;
19700 declare function postMessage(message: any, targetOrigin: string, transfer?: Transferable[]): void;
19701 declare function print(): void;
19702 declare function prompt(message?: string, _default?: string): string | null;
19703 /** @deprecated */
19704 declare function releaseEvents(): void;
19705 declare function resizeBy(x: number, y: number): void;
19706 declare function resizeTo(width: number, height: number): void;
19707 declare function scroll(options?: ScrollToOptions): void;
19708 declare function scroll(x: number, y: number): void;
19709 declare function scrollBy(options?: ScrollToOptions): void;
19710 declare function scrollBy(x: number, y: number): void;
19711 declare function scrollTo(options?: ScrollToOptions): void;
19712 declare function scrollTo(x: number, y: number): void;
19713 declare function stop(): void;
19714 declare function webkitCancelAnimationFrame(handle: number): void;
19715 declare function webkitConvertPointFromNodeToPage(node: Node, pt: WebKitPoint): WebKitPoint;
19716 declare function webkitConvertPointFromPageToNode(node: Node, pt: WebKitPoint): WebKitPoint;
19717 declare function webkitRequestAnimationFrame(callback: FrameRequestCallback): number;
19718 declare function toString(): string;
19719 /**
19720  * 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.
19721  */
19722 declare function dispatchEvent(event: Event): boolean;
19723 declare var sessionStorage: Storage;
19724 declare var localStorage: Storage;
19725 /**
19726  * Fires when the user aborts the download.
19727  * @param ev The event.
19728  */
19729 declare var onabort: ((this: Window, ev: UIEvent) => any) | null;
19730 declare var onanimationcancel: ((this: Window, ev: AnimationEvent) => any) | null;
19731 declare var onanimationend: ((this: Window, ev: AnimationEvent) => any) | null;
19732 declare var onanimationiteration: ((this: Window, ev: AnimationEvent) => any) | null;
19733 declare var onanimationstart: ((this: Window, ev: AnimationEvent) => any) | null;
19734 declare var onauxclick: ((this: Window, ev: MouseEvent) => any) | null;
19735 /**
19736  * Fires when the object loses the input focus.
19737  * @param ev The focus event.
19738  */
19739 declare var onblur: ((this: Window, ev: FocusEvent) => any) | null;
19740 declare var oncancel: ((this: Window, ev: Event) => any) | null;
19741 /**
19742  * Occurs when playback is possible, but would require further buffering.
19743  * @param ev The event.
19744  */
19745 declare var oncanplay: ((this: Window, ev: Event) => any) | null;
19746 declare var oncanplaythrough: ((this: Window, ev: Event) => any) | null;
19747 /**
19748  * Fires when the contents of the object or selection have changed.
19749  * @param ev The event.
19750  */
19751 declare var onchange: ((this: Window, ev: Event) => any) | null;
19752 /**
19753  * Fires when the user clicks the left mouse button on the object
19754  * @param ev The mouse event.
19755  */
19756 declare var onclick: ((this: Window, ev: MouseEvent) => any) | null;
19757 declare var onclose: ((this: Window, ev: Event) => any) | null;
19758 /**
19759  * Fires when the user clicks the right mouse button in the client area, opening the context menu.
19760  * @param ev The mouse event.
19761  */
19762 declare var oncontextmenu: ((this: Window, ev: MouseEvent) => any) | null;
19763 declare var oncuechange: ((this: Window, ev: Event) => any) | null;
19764 /**
19765  * Fires when the user double-clicks the object.
19766  * @param ev The mouse event.
19767  */
19768 declare var ondblclick: ((this: Window, ev: MouseEvent) => any) | null;
19769 /**
19770  * Fires on the source object continuously during a drag operation.
19771  * @param ev The event.
19772  */
19773 declare var ondrag: ((this: Window, ev: DragEvent) => any) | null;
19774 /**
19775  * Fires on the source object when the user releases the mouse at the close of a drag operation.
19776  * @param ev The event.
19777  */
19778 declare var ondragend: ((this: Window, ev: DragEvent) => any) | null;
19779 /**
19780  * Fires on the target element when the user drags the object to a valid drop target.
19781  * @param ev The drag event.
19782  */
19783 declare var ondragenter: ((this: Window, ev: DragEvent) => any) | null;
19784 declare var ondragexit: ((this: Window, ev: Event) => any) | null;
19785 /**
19786  * Fires on the target object when the user moves the mouse out of a valid drop target during a drag operation.
19787  * @param ev The drag event.
19788  */
19789 declare var ondragleave: ((this: Window, ev: DragEvent) => any) | null;
19790 /**
19791  * Fires on the target element continuously while the user drags the object over a valid drop target.
19792  * @param ev The event.
19793  */
19794 declare var ondragover: ((this: Window, ev: DragEvent) => any) | null;
19795 /**
19796  * Fires on the source object when the user starts to drag a text selection or selected object.
19797  * @param ev The event.
19798  */
19799 declare var ondragstart: ((this: Window, ev: DragEvent) => any) | null;
19800 declare var ondrop: ((this: Window, ev: DragEvent) => any) | null;
19801 /**
19802  * Occurs when the duration attribute is updated.
19803  * @param ev The event.
19804  */
19805 declare var ondurationchange: ((this: Window, ev: Event) => any) | null;
19806 /**
19807  * Occurs when the media element is reset to its initial state.
19808  * @param ev The event.
19809  */
19810 declare var onemptied: ((this: Window, ev: Event) => any) | null;
19811 /**
19812  * Occurs when the end of playback is reached.
19813  * @param ev The event
19814  */
19815 declare var onended: ((this: Window, ev: Event) => any) | null;
19816 /**
19817  * Fires when an error occurs during object loading.
19818  * @param ev The event.
19819  */
19820 declare var onerror: OnErrorEventHandler;
19821 /**
19822  * Fires when the object receives focus.
19823  * @param ev The event.
19824  */
19825 declare var onfocus: ((this: Window, ev: FocusEvent) => any) | null;
19826 declare var ongotpointercapture: ((this: Window, ev: PointerEvent) => any) | null;
19827 declare var oninput: ((this: Window, ev: Event) => any) | null;
19828 declare var oninvalid: ((this: Window, ev: Event) => any) | null;
19829 /**
19830  * Fires when the user presses a key.
19831  * @param ev The keyboard event
19832  */
19833 declare var onkeydown: ((this: Window, ev: KeyboardEvent) => any) | null;
19834 /**
19835  * Fires when the user presses an alphanumeric key.
19836  * @param ev The event.
19837  */
19838 declare var onkeypress: ((this: Window, ev: KeyboardEvent) => any) | null;
19839 /**
19840  * Fires when the user releases a key.
19841  * @param ev The keyboard event
19842  */
19843 declare var onkeyup: ((this: Window, ev: KeyboardEvent) => any) | null;
19844 /**
19845  * Fires immediately after the browser loads the object.
19846  * @param ev The event.
19847  */
19848 declare var onload: ((this: Window, ev: Event) => any) | null;
19849 /**
19850  * Occurs when media data is loaded at the current playback position.
19851  * @param ev The event.
19852  */
19853 declare var onloadeddata: ((this: Window, ev: Event) => any) | null;
19854 /**
19855  * Occurs when the duration and dimensions of the media have been determined.
19856  * @param ev The event.
19857  */
19858 declare var onloadedmetadata: ((this: Window, ev: Event) => any) | null;
19859 /**
19860  * Occurs when Internet Explorer begins looking for media data.
19861  * @param ev The event.
19862  */
19863 declare var onloadstart: ((this: Window, ev: Event) => any) | null;
19864 declare var onlostpointercapture: ((this: Window, ev: PointerEvent) => any) | null;
19865 /**
19866  * Fires when the user clicks the object with either mouse button.
19867  * @param ev The mouse event.
19868  */
19869 declare var onmousedown: ((this: Window, ev: MouseEvent) => any) | null;
19870 declare var onmouseenter: ((this: Window, ev: MouseEvent) => any) | null;
19871 declare var onmouseleave: ((this: Window, ev: MouseEvent) => any) | null;
19872 /**
19873  * Fires when the user moves the mouse over the object.
19874  * @param ev The mouse event.
19875  */
19876 declare var onmousemove: ((this: Window, ev: MouseEvent) => any) | null;
19877 /**
19878  * Fires when the user moves the mouse pointer outside the boundaries of the object.
19879  * @param ev The mouse event.
19880  */
19881 declare var onmouseout: ((this: Window, ev: MouseEvent) => any) | null;
19882 /**
19883  * Fires when the user moves the mouse pointer into the object.
19884  * @param ev The mouse event.
19885  */
19886 declare var onmouseover: ((this: Window, ev: MouseEvent) => any) | null;
19887 /**
19888  * Fires when the user releases a mouse button while the mouse is over the object.
19889  * @param ev The mouse event.
19890  */
19891 declare var onmouseup: ((this: Window, ev: MouseEvent) => any) | null;
19892 /**
19893  * Occurs when playback is paused.
19894  * @param ev The event.
19895  */
19896 declare var onpause: ((this: Window, ev: Event) => any) | null;
19897 /**
19898  * Occurs when the play method is requested.
19899  * @param ev The event.
19900  */
19901 declare var onplay: ((this: Window, ev: Event) => any) | null;
19902 /**
19903  * Occurs when the audio or video has started playing.
19904  * @param ev The event.
19905  */
19906 declare var onplaying: ((this: Window, ev: Event) => any) | null;
19907 declare var onpointercancel: ((this: Window, ev: PointerEvent) => any) | null;
19908 declare var onpointerdown: ((this: Window, ev: PointerEvent) => any) | null;
19909 declare var onpointerenter: ((this: Window, ev: PointerEvent) => any) | null;
19910 declare var onpointerleave: ((this: Window, ev: PointerEvent) => any) | null;
19911 declare var onpointermove: ((this: Window, ev: PointerEvent) => any) | null;
19912 declare var onpointerout: ((this: Window, ev: PointerEvent) => any) | null;
19913 declare var onpointerover: ((this: Window, ev: PointerEvent) => any) | null;
19914 declare var onpointerup: ((this: Window, ev: PointerEvent) => any) | null;
19915 /**
19916  * Occurs to indicate progress while downloading media data.
19917  * @param ev The event.
19918  */
19919 declare var onprogress: ((this: Window, ev: ProgressEvent) => any) | null;
19920 /**
19921  * Occurs when the playback rate is increased or decreased.
19922  * @param ev The event.
19923  */
19924 declare var onratechange: ((this: Window, ev: Event) => any) | null;
19925 /**
19926  * Fires when the user resets a form.
19927  * @param ev The event.
19928  */
19929 declare var onreset: ((this: Window, ev: Event) => any) | null;
19930 declare var onresize: ((this: Window, ev: UIEvent) => any) | null;
19931 /**
19932  * Fires when the user repositions the scroll box in the scroll bar on the object.
19933  * @param ev The event.
19934  */
19935 declare var onscroll: ((this: Window, ev: Event) => any) | null;
19936 declare var onsecuritypolicyviolation: ((this: Window, ev: SecurityPolicyViolationEvent) => any) | null;
19937 /**
19938  * Occurs when the seek operation ends.
19939  * @param ev The event.
19940  */
19941 declare var onseeked: ((this: Window, ev: Event) => any) | null;
19942 /**
19943  * Occurs when the current playback position is moved.
19944  * @param ev The event.
19945  */
19946 declare var onseeking: ((this: Window, ev: Event) => any) | null;
19947 /**
19948  * Fires when the current selection changes.
19949  * @param ev The event.
19950  */
19951 declare var onselect: ((this: Window, ev: Event) => any) | null;
19952 declare var onselectionchange: ((this: Window, ev: Event) => any) | null;
19953 declare var onselectstart: ((this: Window, ev: Event) => any) | null;
19954 /**
19955  * Occurs when the download has stopped.
19956  * @param ev The event.
19957  */
19958 declare var onstalled: ((this: Window, ev: Event) => any) | null;
19959 declare var onsubmit: ((this: Window, ev: Event) => any) | null;
19960 /**
19961  * Occurs if the load operation has been intentionally halted.
19962  * @param ev The event.
19963  */
19964 declare var onsuspend: ((this: Window, ev: Event) => any) | null;
19965 /**
19966  * Occurs to indicate the current playback position.
19967  * @param ev The event.
19968  */
19969 declare var ontimeupdate: ((this: Window, ev: Event) => any) | null;
19970 declare var ontoggle: ((this: Window, ev: Event) => any) | null;
19971 declare var ontouchcancel: ((this: Window, ev: TouchEvent) => any) | null | undefined;
19972 declare var ontouchend: ((this: Window, ev: TouchEvent) => any) | null | undefined;
19973 declare var ontouchmove: ((this: Window, ev: TouchEvent) => any) | null | undefined;
19974 declare var ontouchstart: ((this: Window, ev: TouchEvent) => any) | null | undefined;
19975 declare var ontransitioncancel: ((this: Window, ev: TransitionEvent) => any) | null;
19976 declare var ontransitionend: ((this: Window, ev: TransitionEvent) => any) | null;
19977 declare var ontransitionrun: ((this: Window, ev: TransitionEvent) => any) | null;
19978 declare var ontransitionstart: ((this: Window, ev: TransitionEvent) => any) | null;
19979 /**
19980  * Occurs when the volume is changed, or playback is muted or unmuted.
19981  * @param ev The event.
19982  */
19983 declare var onvolumechange: ((this: Window, ev: Event) => any) | null;
19984 /**
19985  * Occurs when playback stops because the next frame of a video resource is not available.
19986  * @param ev The event.
19987  */
19988 declare var onwaiting: ((this: Window, ev: Event) => any) | null;
19989 declare var onwheel: ((this: Window, ev: WheelEvent) => any) | null;
19990 declare function cancelAnimationFrame(handle: number): void;
19991 declare function requestAnimationFrame(callback: FrameRequestCallback): number;
19992 declare var caches: CacheStorage;
19993 declare var crypto: Crypto;
19994 declare var indexedDB: IDBFactory;
19995 declare var isSecureContext: boolean;
19996 declare var origin: string;
19997 declare var performance: Performance;
19998 declare function atob(data: string): string;
19999 declare function btoa(data: string): string;
20000 declare function clearInterval(handle?: number): void;
20001 declare function clearTimeout(handle?: number): void;
20002 declare function createImageBitmap(image: ImageBitmapSource, options?: ImageBitmapOptions): Promise<ImageBitmap>;
20003 declare function createImageBitmap(image: ImageBitmapSource, sx: number, sy: number, sw: number, sh: number, options?: ImageBitmapOptions): Promise<ImageBitmap>;
20004 declare function fetch(input: RequestInfo, init?: RequestInit): Promise<Response>;
20005 declare function queueMicrotask(callback: VoidFunction): void;
20006 declare function setInterval(handler: TimerHandler, timeout?: number, ...arguments: any[]): number;
20007 declare function setTimeout(handler: TimerHandler, timeout?: number, ...arguments: any[]): number;
20008 declare var onafterprint: ((this: Window, ev: Event) => any) | null;
20009 declare var onbeforeprint: ((this: Window, ev: Event) => any) | null;
20010 declare var onbeforeunload: ((this: Window, ev: BeforeUnloadEvent) => any) | null;
20011 declare var onhashchange: ((this: Window, ev: HashChangeEvent) => any) | null;
20012 declare var onlanguagechange: ((this: Window, ev: Event) => any) | null;
20013 declare var onmessage: ((this: Window, ev: MessageEvent) => any) | null;
20014 declare var onmessageerror: ((this: Window, ev: MessageEvent) => any) | null;
20015 declare var onoffline: ((this: Window, ev: Event) => any) | null;
20016 declare var ononline: ((this: Window, ev: Event) => any) | null;
20017 declare var onpagehide: ((this: Window, ev: PageTransitionEvent) => any) | null;
20018 declare var onpageshow: ((this: Window, ev: PageTransitionEvent) => any) | null;
20019 declare var onpopstate: ((this: Window, ev: PopStateEvent) => any) | null;
20020 declare var onrejectionhandled: ((this: Window, ev: PromiseRejectionEvent) => any) | null;
20021 declare var onstorage: ((this: Window, ev: StorageEvent) => any) | null;
20022 declare var onunhandledrejection: ((this: Window, ev: PromiseRejectionEvent) => any) | null;
20023 declare var onunload: ((this: Window, ev: Event) => any) | null;
20024 declare function addEventListener<K extends keyof WindowEventMap>(type: K, listener: (this: Window, ev: WindowEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
20025 declare function addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
20026 declare function removeEventListener<K extends keyof WindowEventMap>(type: K, listener: (this: Window, ev: WindowEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
20027 declare function removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
20028 type HeadersInit = Headers | string[][] | Record<string, string>;
20029 type BodyInit = Blob | BufferSource | FormData | URLSearchParams | ReadableStream<Uint8Array> | string;
20030 type RequestInfo = Request | string;
20031 type BlobPart = BufferSource | Blob | string;
20032 type DOMHighResTimeStamp = number;
20033 type RenderingContext = CanvasRenderingContext2D | ImageBitmapRenderingContext | WebGLRenderingContext | WebGL2RenderingContext;
20034 type HTMLOrSVGImageElement = HTMLImageElement | SVGImageElement;
20035 type CanvasImageSource = HTMLOrSVGImageElement | HTMLVideoElement | HTMLCanvasElement | ImageBitmap | OffscreenCanvas;
20036 type OffscreenRenderingContext = OffscreenCanvasRenderingContext2D | ImageBitmapRenderingContext | WebGLRenderingContext | WebGL2RenderingContext;
20037 type MessageEventSource = WindowProxy | MessagePort | ServiceWorker;
20038 type HTMLOrSVGScriptElement = HTMLScriptElement | SVGScriptElement;
20039 type ImageBitmapSource = CanvasImageSource | Blob | ImageData;
20040 type MediaProvider = MediaStream | MediaSource | Blob;
20041 type OnErrorEventHandler = OnErrorEventHandlerNonNull | null;
20042 type OnBeforeUnloadEventHandler = OnBeforeUnloadEventHandlerNonNull | null;
20043 type TimerHandler = string | Function;
20044 type ConstrainULong = number | ConstrainULongRange;
20045 type ConstrainDouble = number | ConstrainDoubleRange;
20046 type ConstrainBoolean = boolean | ConstrainBooleanParameters;
20047 type ConstrainDOMString = string | string[] | ConstrainDOMStringParameters;
20048 type PerformanceEntryList = PerformanceEntry[];
20049 type ReadableStreamReader<T> = ReadableStreamDefaultReader<T>;
20050 type ReadableStreamController<T> = ReadableStreamDefaultController<T>;
20051 type VibratePattern = number | number[];
20052 type COSEAlgorithmIdentifier = number;
20053 type UvmEntry = number[];
20054 type UvmEntries = UvmEntry[];
20055 type AlgorithmIdentifier = string | Algorithm;
20056 type HashAlgorithmIdentifier = AlgorithmIdentifier;
20057 type BigInteger = Uint8Array;
20058 type NamedCurve = string;
20059 type GLenum = number;
20060 type GLboolean = boolean;
20061 type GLbitfield = number;
20062 type GLint = number;
20063 type GLsizei = number;
20064 type GLintptr = number;
20065 type GLsizeiptr = number;
20066 type GLuint = number;
20067 type GLfloat = number;
20068 type GLclampf = number;
20069 type TexImageSource = ImageBitmap | ImageData | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement | OffscreenCanvas;
20070 type Float32List = Float32Array | GLfloat[];
20071 type Int32List = Int32Array | GLint[];
20072 type GLint64 = number;
20073 type GLuint64 = number;
20074 type Uint32List = Uint32Array | GLuint[];
20075 type BufferSource = ArrayBufferView | ArrayBuffer;
20076 type DOMTimeStamp = number;
20077 type LineAndPositionSetting = number | AutoKeyword;
20078 type FormDataEntryValue = File | string;
20079 type InsertPosition = "beforebegin" | "afterbegin" | "beforeend" | "afterend";
20080 type IDBValidKey = number | string | Date | BufferSource | IDBArrayKey;
20081 type MutationRecordType = "attributes" | "characterData" | "childList";
20082 type IDBKeyPath = string;
20083 type Transferable = ArrayBuffer | MessagePort | ImageBitmap | OffscreenCanvas;
20084 type RTCIceGatherCandidate = RTCIceCandidateDictionary | RTCIceCandidateComplete;
20085 type RTCTransport = RTCDtlsTransport | RTCSrtpSdesTransport;
20086 /** @deprecated */
20087 type MouseWheelEvent = WheelEvent;
20088 type WindowProxy = Window;
20089 type ReadableStreamDefaultReadResult<T> = ReadableStreamDefaultReadValueResult<T> | ReadableStreamDefaultReadDoneResult;
20090 type AlignSetting = "center" | "end" | "left" | "right" | "start";
20091 type AnimationPlayState = "finished" | "idle" | "paused" | "running";
20092 type AppendMode = "segments" | "sequence";
20093 type AttestationConveyancePreference = "direct" | "enterprise" | "indirect" | "none";
20094 type AudioContextLatencyCategory = "balanced" | "interactive" | "playback";
20095 type AudioContextState = "closed" | "running" | "suspended";
20096 type AuthenticatorAttachment = "cross-platform" | "platform";
20097 type AuthenticatorTransport = "ble" | "internal" | "nfc" | "usb";
20098 type AutoKeyword = "auto";
20099 type AutomationRate = "a-rate" | "k-rate";
20100 type BinaryType = "arraybuffer" | "blob";
20101 type BiquadFilterType = "allpass" | "bandpass" | "highpass" | "highshelf" | "lowpass" | "lowshelf" | "notch" | "peaking";
20102 type CanPlayTypeResult = "" | "maybe" | "probably";
20103 type CanvasDirection = "inherit" | "ltr" | "rtl";
20104 type CanvasFillRule = "evenodd" | "nonzero";
20105 type CanvasLineCap = "butt" | "round" | "square";
20106 type CanvasLineJoin = "bevel" | "miter" | "round";
20107 type CanvasTextAlign = "center" | "end" | "left" | "right" | "start";
20108 type CanvasTextBaseline = "alphabetic" | "bottom" | "hanging" | "ideographic" | "middle" | "top";
20109 type ChannelCountMode = "clamped-max" | "explicit" | "max";
20110 type ChannelInterpretation = "discrete" | "speakers";
20111 type ClientTypes = "all" | "sharedworker" | "window" | "worker";
20112 type ColorSpaceConversion = "default" | "none";
20113 type CompositeOperation = "accumulate" | "add" | "replace";
20114 type CompositeOperationOrAuto = "accumulate" | "add" | "auto" | "replace";
20115 type CredentialMediationRequirement = "optional" | "required" | "silent";
20116 type DOMParserSupportedType = "application/xhtml+xml" | "application/xml" | "image/svg+xml" | "text/html" | "text/xml";
20117 type DirectionSetting = "" | "lr" | "rl";
20118 type DisplayCaptureSurfaceType = "application" | "browser" | "monitor" | "window";
20119 type DistanceModelType = "exponential" | "inverse" | "linear";
20120 type DocumentReadyState = "complete" | "interactive" | "loading";
20121 type EndOfStreamError = "decode" | "network";
20122 type EndingType = "native" | "transparent";
20123 type FillMode = "auto" | "backwards" | "both" | "forwards" | "none";
20124 type FullscreenNavigationUI = "auto" | "hide" | "show";
20125 type GamepadHand = "" | "left" | "right";
20126 type GamepadHapticActuatorType = "vibration";
20127 type GamepadMappingType = "" | "standard";
20128 type IDBCursorDirection = "next" | "nextunique" | "prev" | "prevunique";
20129 type IDBRequestReadyState = "done" | "pending";
20130 type IDBTransactionMode = "readonly" | "readwrite" | "versionchange";
20131 type ImageOrientation = "flipY" | "none";
20132 type ImageSmoothingQuality = "high" | "low" | "medium";
20133 type IterationCompositeOperation = "accumulate" | "replace";
20134 type KeyFormat = "jwk" | "pkcs8" | "raw" | "spki";
20135 type KeyType = "private" | "public" | "secret";
20136 type KeyUsage = "decrypt" | "deriveBits" | "deriveKey" | "encrypt" | "sign" | "unwrapKey" | "verify" | "wrapKey";
20137 type LineAlignSetting = "center" | "end" | "start";
20138 type ListeningState = "active" | "disambiguation" | "inactive";
20139 type MSCredentialType = "FIDO_2_0";
20140 type MSTransportType = "BT" | "Embedded" | "NFC" | "USB";
20141 type MSWebViewPermissionState = "allow" | "defer" | "deny" | "unknown";
20142 type MSWebViewPermissionType = "geolocation" | "media" | "pointerlock" | "unlimitedIndexedDBQuota" | "webnotifications";
20143 type MediaDeviceKind = "audioinput" | "audiooutput" | "videoinput";
20144 type MediaKeyMessageType = "individualization-request" | "license-release" | "license-renewal" | "license-request";
20145 type MediaKeySessionType = "persistent-license" | "temporary";
20146 type MediaKeyStatus = "expired" | "internal-error" | "output-downscaled" | "output-restricted" | "released" | "status-pending" | "usable";
20147 type MediaKeysRequirement = "not-allowed" | "optional" | "required";
20148 type MediaStreamTrackState = "ended" | "live";
20149 type NavigationReason = "down" | "left" | "right" | "up";
20150 type NavigationType = "back_forward" | "navigate" | "prerender" | "reload";
20151 type NotificationDirection = "auto" | "ltr" | "rtl";
20152 type NotificationPermission = "default" | "denied" | "granted";
20153 type OffscreenRenderingContextId = "2d" | "bitmaprenderer" | "webgl" | "webgl2";
20154 type OrientationLockType = "any" | "landscape" | "landscape-primary" | "landscape-secondary" | "natural" | "portrait" | "portrait-primary" | "portrait-secondary";
20155 type OrientationType = "landscape-primary" | "landscape-secondary" | "portrait-primary" | "portrait-secondary";
20156 type OscillatorType = "custom" | "sawtooth" | "sine" | "square" | "triangle";
20157 type OverSampleType = "2x" | "4x" | "none";
20158 type PanningModelType = "HRTF" | "equalpower";
20159 type PaymentComplete = "fail" | "success" | "unknown";
20160 type PaymentShippingType = "delivery" | "pickup" | "shipping";
20161 type PermissionName = "accelerometer" | "ambient-light-sensor" | "background-fetch" | "background-sync" | "bluetooth" | "camera" | "clipboard-read" | "clipboard-write" | "device-info" | "display-capture" | "geolocation" | "gyroscope" | "magnetometer" | "microphone" | "midi" | "nfc" | "notifications" | "persistent-storage" | "push" | "speaker";
20162 type PermissionState = "denied" | "granted" | "prompt";
20163 type PlaybackDirection = "alternate" | "alternate-reverse" | "normal" | "reverse";
20164 type PositionAlignSetting = "auto" | "center" | "line-left" | "line-right";
20165 type PremultiplyAlpha = "default" | "none" | "premultiply";
20166 type PublicKeyCredentialType = "public-key";
20167 type PushEncryptionKeyName = "auth" | "p256dh";
20168 type PushPermissionState = "denied" | "granted" | "prompt";
20169 type RTCBundlePolicy = "balanced" | "max-bundle" | "max-compat";
20170 type RTCDataChannelState = "closed" | "closing" | "connecting" | "open";
20171 type RTCDegradationPreference = "balanced" | "maintain-framerate" | "maintain-resolution";
20172 type RTCDtlsRole = "auto" | "client" | "server";
20173 type RTCDtlsTransportState = "closed" | "connected" | "connecting" | "failed" | "new";
20174 type RTCDtxStatus = "disabled" | "enabled";
20175 type RTCErrorDetailType = "data-channel-failure" | "dtls-failure" | "fingerprint-failure" | "hardware-encoder-error" | "hardware-encoder-not-available" | "idp-bad-script-failure" | "idp-execution-failure" | "idp-load-failure" | "idp-need-login" | "idp-timeout" | "idp-tls-failure" | "idp-token-expired" | "idp-token-invalid" | "sctp-failure" | "sdp-syntax-error";
20176 type RTCIceCandidateType = "host" | "prflx" | "relay" | "srflx";
20177 type RTCIceComponent = "rtcp" | "rtp";
20178 type RTCIceConnectionState = "checking" | "closed" | "completed" | "connected" | "disconnected" | "failed" | "new";
20179 type RTCIceCredentialType = "oauth" | "password";
20180 type RTCIceGatherPolicy = "all" | "nohost" | "relay";
20181 type RTCIceGathererState = "complete" | "gathering" | "new";
20182 type RTCIceGatheringState = "complete" | "gathering" | "new";
20183 type RTCIceProtocol = "tcp" | "udp";
20184 type RTCIceRole = "controlled" | "controlling" | "unknown";
20185 type RTCIceTcpCandidateType = "active" | "passive" | "so";
20186 type RTCIceTransportPolicy = "all" | "relay";
20187 type RTCIceTransportState = "checking" | "closed" | "completed" | "connected" | "disconnected" | "failed" | "new";
20188 type RTCPeerConnectionState = "closed" | "connected" | "connecting" | "disconnected" | "failed" | "new";
20189 type RTCPriorityType = "high" | "low" | "medium" | "very-low";
20190 type RTCRtcpMuxPolicy = "negotiate" | "require";
20191 type RTCRtpTransceiverDirection = "inactive" | "recvonly" | "sendonly" | "sendrecv" | "stopped";
20192 type RTCSctpTransportState = "closed" | "connected" | "connecting";
20193 type RTCSdpType = "answer" | "offer" | "pranswer" | "rollback";
20194 type RTCSignalingState = "closed" | "have-local-offer" | "have-local-pranswer" | "have-remote-offer" | "have-remote-pranswer" | "stable";
20195 type RTCStatsIceCandidatePairState = "failed" | "frozen" | "in-progress" | "succeeded" | "waiting";
20196 type RTCStatsIceCandidateType = "host" | "peerreflexive" | "relayed" | "serverreflexive";
20197 type RTCStatsType = "candidate-pair" | "certificate" | "codec" | "csrc" | "data-channel" | "ice-server" | "inbound-rtp" | "local-candidate" | "media-source" | "outbound-rtp" | "peer-connection" | "receiver" | "remote-candidate" | "remote-inbound-rtp" | "remote-outbound-rtp" | "sctp-transport" | "sender" | "stream" | "track" | "transceiver" | "transport";
20198 type ReadyState = "closed" | "ended" | "open";
20199 type ReferrerPolicy = "" | "no-referrer" | "no-referrer-when-downgrade" | "origin" | "origin-when-cross-origin" | "same-origin" | "strict-origin" | "strict-origin-when-cross-origin" | "unsafe-url";
20200 type RequestCache = "default" | "force-cache" | "no-cache" | "no-store" | "only-if-cached" | "reload";
20201 type RequestCredentials = "include" | "omit" | "same-origin";
20202 type RequestDestination = "" | "audio" | "audioworklet" | "document" | "embed" | "font" | "image" | "manifest" | "object" | "paintworklet" | "report" | "script" | "sharedworker" | "style" | "track" | "video" | "worker" | "xslt";
20203 type RequestMode = "cors" | "navigate" | "no-cors" | "same-origin";
20204 type RequestRedirect = "error" | "follow" | "manual";
20205 type ResidentKeyRequirement = "discouraged" | "preferred" | "required";
20206 type ResizeObserverBoxOptions = "border-box" | "content-box" | "device-pixel-content-box";
20207 type ResizeQuality = "high" | "low" | "medium" | "pixelated";
20208 type ResponseType = "basic" | "cors" | "default" | "error" | "opaque" | "opaqueredirect";
20209 type ScopedCredentialType = "ScopedCred";
20210 type ScrollBehavior = "auto" | "smooth";
20211 type ScrollLogicalPosition = "center" | "end" | "nearest" | "start";
20212 type ScrollRestoration = "auto" | "manual";
20213 type ScrollSetting = "" | "up";
20214 type SelectionMode = "end" | "preserve" | "select" | "start";
20215 type ServiceWorkerState = "activated" | "activating" | "installed" | "installing" | "parsed" | "redundant";
20216 type ServiceWorkerUpdateViaCache = "all" | "imports" | "none";
20217 type ShadowRootMode = "closed" | "open";
20218 type SpeechRecognitionErrorCode = "aborted" | "audio-capture" | "bad-grammar" | "language-not-supported" | "network" | "no-speech" | "not-allowed" | "service-not-allowed";
20219 type SpeechSynthesisErrorCode = "audio-busy" | "audio-hardware" | "canceled" | "interrupted" | "invalid-argument" | "language-unavailable" | "network" | "not-allowed" | "synthesis-failed" | "synthesis-unavailable" | "text-too-long" | "voice-unavailable";
20220 type TextTrackKind = "captions" | "chapters" | "descriptions" | "metadata" | "subtitles";
20221 type TextTrackMode = "disabled" | "hidden" | "showing";
20222 type TouchType = "direct" | "stylus";
20223 type Transport = "ble" | "nfc" | "usb";
20224 type UserVerificationRequirement = "discouraged" | "preferred" | "required";
20225 type VRDisplayEventReason = "mounted" | "navigation" | "requested" | "unmounted";
20226 type VideoFacingModeEnum = "environment" | "left" | "right" | "user";
20227 type VisibilityState = "hidden" | "visible";
20228 type WebGLPowerPreference = "default" | "high-performance" | "low-power";
20229 type WorkerType = "classic" | "module";
20230 type XMLHttpRequestResponseType = "" | "arraybuffer" | "blob" | "document" | "json" | "text";