.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 /// Window APIs
  23 /////////////////////////////
  24
  25 interface AddEventListenerOptions extends EventListenerOptions {
  26     once?: boolean;
  27     passive?: boolean;
  28     signal?: AbortSignal;
  29 }
  30
  31 interface AesCbcParams extends Algorithm {
  32     iv: BufferSource;
  33 }
  34
  35 interface AesCtrParams extends Algorithm {
  36     counter: BufferSource;
  37     length: number;
  38 }
  39
  40 interface AesDerivedKeyParams extends Algorithm {
  41     length: number;
  42 }
  43
  44 interface AesGcmParams extends Algorithm {
  45     additionalData?: BufferSource;
  46     iv: BufferSource;
  47     tagLength?: number;
  48 }
  49
  50 interface AesKeyAlgorithm extends KeyAlgorithm {
  51     length: number;
  52 }
  53
  54 interface AesKeyGenParams extends Algorithm {
  55     length: number;
  56 }
  57
  58 interface Algorithm {
  59     name: string;
  60 }
  61
  62 interface AnalyserOptions extends AudioNodeOptions {
  63     fftSize?: number;
  64     maxDecibels?: number;
  65     minDecibels?: number;
  66     smoothingTimeConstant?: number;
  67 }
  68
  69 interface AnimationEventInit extends EventInit {
  70     animationName?: string;
  71     elapsedTime?: number;
  72     pseudoElement?: string;
  73 }
  74
  75 interface AnimationPlaybackEventInit extends EventInit {
  76     currentTime?: CSSNumberish | null;
  77     timelineTime?: CSSNumberish | null;
  78 }
  79
  80 interface AssignedNodesOptions {
  81     flatten?: boolean;
  82 }
  83
  84 interface AudioBufferOptions {
  85     length: number;
  86     numberOfChannels?: number;
  87     sampleRate: number;
  88 }
  89
  90 interface AudioBufferSourceOptions {
  91     buffer?: AudioBuffer | null;
  92     detune?: number;
  93     loop?: boolean;
  94     loopEnd?: number;
  95     loopStart?: number;
  96     playbackRate?: number;
  97 }
  98
  99 interface AudioConfiguration {
 100     bitrate?: number;
 101     channels?: string;
 102     contentType: string;
 103     samplerate?: number;
 104     spatialRendering?: boolean;
 105 }
 106
 107 interface AudioContextOptions {
 108     latencyHint?: AudioContextLatencyCategory | number;
 109     sampleRate?: number;
 110 }
 111
 112 interface AudioNodeOptions {
 113     channelCount?: number;
 114     channelCountMode?: ChannelCountMode;
 115     channelInterpretation?: ChannelInterpretation;
 116 }
 117
 118 interface AudioProcessingEventInit extends EventInit {
 119     inputBuffer: AudioBuffer;
 120     outputBuffer: AudioBuffer;
 121     playbackTime: number;
 122 }
 123
 124 interface AudioTimestamp {
 125     contextTime?: number;
 126     performanceTime?: DOMHighResTimeStamp;
 127 }
 128
 129 interface AudioWorkletNodeOptions extends AudioNodeOptions {
 130     numberOfInputs?: number;
 131     numberOfOutputs?: number;
 132     outputChannelCount?: number[];
 133     parameterData?: Record<string, number>;
 134     processorOptions?: any;
 135 }
 136
 137 interface AuthenticationExtensionsClientInputs {
 138     appid?: string;
 139     appidExclude?: string;
 140     credProps?: boolean;
 141     uvm?: boolean;
 142 }
 143
 144 interface AuthenticationExtensionsClientOutputs {
 145     appid?: boolean;
 146     credProps?: CredentialPropertiesOutput;
 147     uvm?: UvmEntries;
 148 }
 149
 150 interface AuthenticatorSelectionCriteria {
 151     authenticatorAttachment?: AuthenticatorAttachment;
 152     requireResidentKey?: boolean;
 153     residentKey?: ResidentKeyRequirement;
 154     userVerification?: UserVerificationRequirement;
 155 }
 156
 157 interface BiquadFilterOptions extends AudioNodeOptions {
 158     Q?: number;
 159     detune?: number;
 160     frequency?: number;
 161     gain?: number;
 162     type?: BiquadFilterType;
 163 }
 164
 165 interface BlobEventInit {
 166     data: Blob;
 167     timecode?: DOMHighResTimeStamp;
 168 }
 169
 170 interface BlobPropertyBag {
 171     endings?: EndingType;
 172     type?: string;
 173 }
 174
 175 interface CSSStyleSheetInit {
 176     baseURL?: string;
 177     disabled?: boolean;
 178     media?: MediaList | string;
 179 }
 180
 181 interface CacheQueryOptions {
 182     ignoreMethod?: boolean;
 183     ignoreSearch?: boolean;
 184     ignoreVary?: boolean;
 185 }
 186
 187 interface CanvasRenderingContext2DSettings {
 188     alpha?: boolean;
 189     colorSpace?: PredefinedColorSpace;
 190     desynchronized?: boolean;
 191     willReadFrequently?: boolean;
 192 }
 193
 194 interface ChannelMergerOptions extends AudioNodeOptions {
 195     numberOfInputs?: number;
 196 }
 197
 198 interface ChannelSplitterOptions extends AudioNodeOptions {
 199     numberOfOutputs?: number;
 200 }
 201
 202 interface ClientQueryOptions {
 203     includeUncontrolled?: boolean;
 204     type?: ClientTypes;
 205 }
 206
 207 interface ClipboardEventInit extends EventInit {
 208     clipboardData?: DataTransfer | null;
 209 }
 210
 211 interface ClipboardItemOptions {
 212     presentationStyle?: PresentationStyle;
 213 }
 214
 215 interface CloseEventInit extends EventInit {
 216     code?: number;
 217     reason?: string;
 218     wasClean?: boolean;
 219 }
 220
 221 interface CompositionEventInit extends UIEventInit {
 222     data?: string;
 223 }
 224
 225 interface ComputedEffectTiming extends EffectTiming {
 226     activeDuration?: CSSNumberish;
 227     currentIteration?: number | null;
 228     endTime?: CSSNumberish;
 229     localTime?: CSSNumberish | null;
 230     progress?: CSSNumberish | null;
 231     startTime?: CSSNumberish;
 232 }
 233
 234 interface ComputedKeyframe {
 235     composite: CompositeOperationOrAuto;
 236     computedOffset: number;
 237     easing: string;
 238     offset: number | null;
 239     [property: string]: string | number | null | undefined;
 240 }
 241
 242 interface ConstantSourceOptions {
 243     offset?: number;
 244 }
 245
 246 interface ConstrainBooleanParameters {
 247     exact?: boolean;
 248     ideal?: boolean;
 249 }
 250
 251 interface ConstrainDOMStringParameters {
 252     exact?: string | string[];
 253     ideal?: string | string[];
 254 }
 255
 256 interface ConstrainDoubleRange extends DoubleRange {
 257     exact?: number;
 258     ideal?: number;
 259 }
 260
 261 interface ConstrainULongRange extends ULongRange {
 262     exact?: number;
 263     ideal?: number;
 264 }
 265
 266 interface ConvolverOptions extends AudioNodeOptions {
 267     buffer?: AudioBuffer | null;
 268     disableNormalization?: boolean;
 269 }
 270
 271 interface CredentialCreationOptions {
 272     publicKey?: PublicKeyCredentialCreationOptions;
 273     signal?: AbortSignal;
 274 }
 275
 276 interface CredentialPropertiesOutput {
 277     rk?: boolean;
 278 }
 279
 280 interface CredentialRequestOptions {
 281     mediation?: CredentialMediationRequirement;
 282     publicKey?: PublicKeyCredentialRequestOptions;
 283     signal?: AbortSignal;
 284 }
 285
 286 interface CryptoKeyPair {
 287     privateKey?: CryptoKey;
 288     publicKey?: CryptoKey;
 289 }
 290
 291 interface CustomEventInit<T = any> extends EventInit {
 292     detail?: T;
 293 }
 294
 295 interface DOMMatrix2DInit {
 296     a?: number;
 297     b?: number;
 298     c?: number;
 299     d?: number;
 300     e?: number;
 301     f?: number;
 302     m11?: number;
 303     m12?: number;
 304     m21?: number;
 305     m22?: number;
 306     m41?: number;
 307     m42?: number;
 308 }
 309
 310 interface DOMMatrixInit extends DOMMatrix2DInit {
 311     is2D?: boolean;
 312     m13?: number;
 313     m14?: number;
 314     m23?: number;
 315     m24?: number;
 316     m31?: number;
 317     m32?: number;
 318     m33?: number;
 319     m34?: number;
 320     m43?: number;
 321     m44?: number;
 322 }
 323
 324 interface DOMPointInit {
 325     w?: number;
 326     x?: number;
 327     y?: number;
 328     z?: number;
 329 }
 330
 331 interface DOMQuadInit {
 332     p1?: DOMPointInit;
 333     p2?: DOMPointInit;
 334     p3?: DOMPointInit;
 335     p4?: DOMPointInit;
 336 }
 337
 338 interface DOMRectInit {
 339     height?: number;
 340     width?: number;
 341     x?: number;
 342     y?: number;
 343 }
 344
 345 interface DelayOptions extends AudioNodeOptions {
 346     delayTime?: number;
 347     maxDelayTime?: number;
 348 }
 349
 350 interface DeviceMotionEventAccelerationInit {
 351     x?: number | null;
 352     y?: number | null;
 353     z?: number | null;
 354 }
 355
 356 interface DeviceMotionEventInit extends EventInit {
 357     acceleration?: DeviceMotionEventAccelerationInit;
 358     accelerationIncludingGravity?: DeviceMotionEventAccelerationInit;
 359     interval?: number;
 360     rotationRate?: DeviceMotionEventRotationRateInit;
 361 }
 362
 363 interface DeviceMotionEventRotationRateInit {
 364     alpha?: number | null;
 365     beta?: number | null;
 366     gamma?: number | null;
 367 }
 368
 369 interface DeviceOrientationEventInit extends EventInit {
 370     absolute?: boolean;
 371     alpha?: number | null;
 372     beta?: number | null;
 373     gamma?: number | null;
 374 }
 375
 376 interface DisplayMediaStreamConstraints {
 377     audio?: boolean | MediaTrackConstraints;
 378     video?: boolean | MediaTrackConstraints;
 379 }
 380
 381 interface DocumentTimelineOptions {
 382     originTime?: DOMHighResTimeStamp;
 383 }
 384
 385 interface DoubleRange {
 386     max?: number;
 387     min?: number;
 388 }
 389
 390 interface DragEventInit extends MouseEventInit {
 391     dataTransfer?: DataTransfer | null;
 392 }
 393
 394 interface DynamicsCompressorOptions extends AudioNodeOptions {
 395     attack?: number;
 396     knee?: number;
 397     ratio?: number;
 398     release?: number;
 399     threshold?: number;
 400 }
 401
 402 interface EcKeyAlgorithm extends KeyAlgorithm {
 403     namedCurve: NamedCurve;
 404 }
 405
 406 interface EcKeyGenParams extends Algorithm {
 407     namedCurve: NamedCurve;
 408 }
 409
 410 interface EcKeyImportParams extends Algorithm {
 411     namedCurve: NamedCurve;
 412 }
 413
 414 interface EcdhKeyDeriveParams extends Algorithm {
 415     public: CryptoKey;
 416 }
 417
 418 interface EcdsaParams extends Algorithm {
 419     hash: HashAlgorithmIdentifier;
 420 }
 421
 422 interface EffectTiming {
 423     delay?: number;
 424     direction?: PlaybackDirection;
 425     duration?: number | string;
 426     easing?: string;
 427     endDelay?: number;
 428     fill?: FillMode;
 429     iterationStart?: number;
 430     iterations?: number;
 431     playbackRate?: number;
 432 }
 433
 434 interface ElementCreationOptions {
 435     is?: string;
 436 }
 437
 438 interface ElementDefinitionOptions {
 439     extends?: string;
 440 }
 441
 442 interface ErrorEventInit extends EventInit {
 443     colno?: number;
 444     error?: any;
 445     filename?: string;
 446     lineno?: number;
 447     message?: string;
 448 }
 449
 450 interface EventInit {
 451     bubbles?: boolean;
 452     cancelable?: boolean;
 453     composed?: boolean;
 454 }
 455
 456 interface EventListenerOptions {
 457     capture?: boolean;
 458 }
 459
 460 interface EventModifierInit extends UIEventInit {
 461     altKey?: boolean;
 462     ctrlKey?: boolean;
 463     metaKey?: boolean;
 464     modifierAltGraph?: boolean;
 465     modifierCapsLock?: boolean;
 466     modifierFn?: boolean;
 467     modifierFnLock?: boolean;
 468     modifierHyper?: boolean;
 469     modifierNumLock?: boolean;
 470     modifierScrollLock?: boolean;
 471     modifierSuper?: boolean;
 472     modifierSymbol?: boolean;
 473     modifierSymbolLock?: boolean;
 474     shiftKey?: boolean;
 475 }
 476
 477 interface EventSourceInit {
 478     withCredentials?: boolean;
 479 }
 480
 481 interface FilePropertyBag extends BlobPropertyBag {
 482     lastModified?: number;
 483 }
 484
 485 interface FileSystemFlags {
 486     create?: boolean;
 487     exclusive?: boolean;
 488 }
 489
 490 interface FocusEventInit extends UIEventInit {
 491     relatedTarget?: EventTarget | null;
 492 }
 493
 494 interface FocusOptions {
 495     preventScroll?: boolean;
 496 }
 497
 498 interface FontFaceDescriptors {
 499     display?: string;
 500     featureSettings?: string;
 501     stretch?: string;
 502     style?: string;
 503     unicodeRange?: string;
 504     variant?: string;
 505     weight?: string;
 506 }
 507
 508 interface FontFaceSetLoadEventInit extends EventInit {
 509     fontfaces?: FontFace[];
 510 }
 511
 512 interface FormDataEventInit extends EventInit {
 513     formData: FormData;
 514 }
 515
 516 interface FullscreenOptions {
 517     navigationUI?: FullscreenNavigationUI;
 518 }
 519
 520 interface GainOptions extends AudioNodeOptions {
 521     gain?: number;
 522 }
 523
 524 interface GamepadEventInit extends EventInit {
 525     gamepad: Gamepad;
 526 }
 527
 528 interface GetAnimationsOptions {
 529     subtree?: boolean;
 530 }
 531
 532 interface GetNotificationOptions {
 533     tag?: string;
 534 }
 535
 536 interface GetRootNodeOptions {
 537     composed?: boolean;
 538 }
 539
 540 interface HashChangeEventInit extends EventInit {
 541     newURL?: string;
 542     oldURL?: string;
 543 }
 544
 545 interface HkdfParams extends Algorithm {
 546     hash: HashAlgorithmIdentifier;
 547     info: BufferSource;
 548     salt: BufferSource;
 549 }
 550
 551 interface HmacImportParams extends Algorithm {
 552     hash: HashAlgorithmIdentifier;
 553     length?: number;
 554 }
 555
 556 interface HmacKeyAlgorithm extends KeyAlgorithm {
 557     hash: KeyAlgorithm;
 558     length: number;
 559 }
 560
 561 interface HmacKeyGenParams extends Algorithm {
 562     hash: HashAlgorithmIdentifier;
 563     length?: number;
 564 }
 565
 566 interface IDBDatabaseInfo {
 567     name?: string;
 568     version?: number;
 569 }
 570
 571 interface IDBIndexParameters {
 572     multiEntry?: boolean;
 573     unique?: boolean;
 574 }
 575
 576 interface IDBObjectStoreParameters {
 577     autoIncrement?: boolean;
 578     keyPath?: string | string[] | null;
 579 }
 580
 581 interface IDBVersionChangeEventInit extends EventInit {
 582     newVersion?: number | null;
 583     oldVersion?: number;
 584 }
 585
 586 interface IIRFilterOptions extends AudioNodeOptions {
 587     feedback: number[];
 588     feedforward: number[];
 589 }
 590
 591 interface IdleRequestOptions {
 592     timeout?: number;
 593 }
 594
 595 interface ImageBitmapOptions {
 596     colorSpaceConversion?: ColorSpaceConversion;
 597     imageOrientation?: ImageOrientation;
 598     premultiplyAlpha?: PremultiplyAlpha;
 599     resizeHeight?: number;
 600     resizeQuality?: ResizeQuality;
 601     resizeWidth?: number;
 602 }
 603
 604 interface ImageBitmapRenderingContextSettings {
 605     alpha?: boolean;
 606 }
 607
 608 interface ImageDataSettings {
 609     colorSpace?: PredefinedColorSpace;
 610 }
 611
 612 interface ImportMeta {
 613     url: string;
 614 }
 615
 616 interface InputEventInit extends UIEventInit {
 617     data?: string | null;
 618     dataTransfer?: DataTransfer | null;
 619     inputType?: string;
 620     isComposing?: boolean;
 621     targetRanges?: StaticRange[];
 622 }
 623
 624 interface IntersectionObserverEntryInit {
 625     boundingClientRect: DOMRectInit;
 626     intersectionRatio: number;
 627     intersectionRect: DOMRectInit;
 628     isIntersecting: boolean;
 629     rootBounds: DOMRectInit | null;
 630     target: Element;
 631     time: DOMHighResTimeStamp;
 632 }
 633
 634 interface IntersectionObserverInit {
 635     root?: Element | Document | null;
 636     rootMargin?: string;
 637     threshold?: number | number[];
 638 }
 639
 640 interface JsonWebKey {
 641     alg?: string;
 642     crv?: string;
 643     d?: string;
 644     dp?: string;
 645     dq?: string;
 646     e?: string;
 647     ext?: boolean;
 648     k?: string;
 649     key_ops?: string[];
 650     kty?: string;
 651     n?: string;
 652     oth?: RsaOtherPrimesInfo[];
 653     p?: string;
 654     q?: string;
 655     qi?: string;
 656     use?: string;
 657     x?: string;
 658     y?: string;
 659 }
 660
 661 interface KeyAlgorithm {
 662     name: string;
 663 }
 664
 665 interface KeyboardEventInit extends EventModifierInit {
 666     /** @deprecated */
 667     charCode?: number;
 668     code?: string;
 669     isComposing?: boolean;
 670     key?: string;
 671     /** @deprecated */
 672     keyCode?: number;
 673     location?: number;
 674     repeat?: boolean;
 675 }
 676
 677 interface Keyframe {
 678     composite?: CompositeOperationOrAuto;
 679     easing?: string;
 680     offset?: number | null;
 681     [property: string]: string | number | null | undefined;
 682 }
 683
 684 interface KeyframeAnimationOptions extends KeyframeEffectOptions {
 685     id?: string;
 686 }
 687
 688 interface KeyframeEffectOptions extends EffectTiming {
 689     composite?: CompositeOperation;
 690     iterationComposite?: IterationCompositeOperation;
 691     pseudoElement?: string | null;
 692 }
 693
 694 interface MediaCapabilitiesDecodingInfo extends MediaCapabilitiesInfo {
 695     configuration?: MediaDecodingConfiguration;
 696 }
 697
 698 interface MediaCapabilitiesEncodingInfo extends MediaCapabilitiesInfo {
 699     configuration?: MediaEncodingConfiguration;
 700 }
 701
 702 interface MediaCapabilitiesInfo {
 703     powerEfficient: boolean;
 704     smooth: boolean;
 705     supported: boolean;
 706 }
 707
 708 interface MediaConfiguration {
 709     audio?: AudioConfiguration;
 710     video?: VideoConfiguration;
 711 }
 712
 713 interface MediaDecodingConfiguration extends MediaConfiguration {
 714     type: MediaDecodingType;
 715 }
 716
 717 interface MediaElementAudioSourceOptions {
 718     mediaElement: HTMLMediaElement;
 719 }
 720
 721 interface MediaEncodingConfiguration extends MediaConfiguration {
 722     type: MediaEncodingType;
 723 }
 724
 725 interface MediaEncryptedEventInit extends EventInit {
 726     initData?: ArrayBuffer | null;
 727     initDataType?: string;
 728 }
 729
 730 interface MediaImage {
 731     sizes?: string;
 732     src: string;
 733     type?: string;
 734 }
 735
 736 interface MediaKeyMessageEventInit extends EventInit {
 737     message: ArrayBuffer;
 738     messageType: MediaKeyMessageType;
 739 }
 740
 741 interface MediaKeySystemConfiguration {
 742     audioCapabilities?: MediaKeySystemMediaCapability[];
 743     distinctiveIdentifier?: MediaKeysRequirement;
 744     initDataTypes?: string[];
 745     label?: string;
 746     persistentState?: MediaKeysRequirement;
 747     sessionTypes?: string[];
 748     videoCapabilities?: MediaKeySystemMediaCapability[];
 749 }
 750
 751 interface MediaKeySystemMediaCapability {
 752     contentType?: string;
 753     encryptionScheme?: string | null;
 754     robustness?: string;
 755 }
 756
 757 interface MediaMetadataInit {
 758     album?: string;
 759     artist?: string;
 760     artwork?: MediaImage[];
 761     title?: string;
 762 }
 763
 764 interface MediaPositionState {
 765     duration?: number;
 766     playbackRate?: number;
 767     position?: number;
 768 }
 769
 770 interface MediaQueryListEventInit extends EventInit {
 771     matches?: boolean;
 772     media?: string;
 773 }
 774
 775 interface MediaRecorderErrorEventInit extends EventInit {
 776     error: DOMException;
 777 }
 778
 779 interface MediaRecorderOptions {
 780     audioBitsPerSecond?: number;
 781     bitsPerSecond?: number;
 782     mimeType?: string;
 783     videoBitsPerSecond?: number;
 784 }
 785
 786 interface MediaSessionActionDetails {
 787     action: MediaSessionAction;
 788     fastSeek?: boolean | null;
 789     seekOffset?: number | null;
 790     seekTime?: number | null;
 791 }
 792
 793 interface MediaStreamAudioSourceOptions {
 794     mediaStream: MediaStream;
 795 }
 796
 797 interface MediaStreamConstraints {
 798     audio?: boolean | MediaTrackConstraints;
 799     peerIdentity?: string;
 800     preferCurrentTab?: boolean;
 801     video?: boolean | MediaTrackConstraints;
 802 }
 803
 804 interface MediaStreamTrackEventInit extends EventInit {
 805     track: MediaStreamTrack;
 806 }
 807
 808 interface MediaTrackCapabilities {
 809     aspectRatio?: DoubleRange;
 810     autoGainControl?: boolean[];
 811     channelCount?: ULongRange;
 812     cursor?: string[];
 813     deviceId?: string;
 814     displaySurface?: string;
 815     echoCancellation?: boolean[];
 816     facingMode?: string[];
 817     frameRate?: DoubleRange;
 818     groupId?: string;
 819     height?: ULongRange;
 820     latency?: DoubleRange;
 821     logicalSurface?: boolean;
 822     noiseSuppression?: boolean[];
 823     resizeMode?: string[];
 824     sampleRate?: ULongRange;
 825     sampleSize?: ULongRange;
 826     width?: ULongRange;
 827 }
 828
 829 interface MediaTrackConstraintSet {
 830     aspectRatio?: ConstrainDouble;
 831     autoGainControl?: ConstrainBoolean;
 832     channelCount?: ConstrainULong;
 833     deviceId?: ConstrainDOMString;
 834     echoCancellation?: ConstrainBoolean;
 835     facingMode?: ConstrainDOMString;
 836     frameRate?: ConstrainDouble;
 837     groupId?: ConstrainDOMString;
 838     height?: ConstrainULong;
 839     latency?: ConstrainDouble;
 840     noiseSuppression?: ConstrainBoolean;
 841     sampleRate?: ConstrainULong;
 842     sampleSize?: ConstrainULong;
 843     suppressLocalAudioPlayback?: ConstrainBoolean;
 844     width?: ConstrainULong;
 845 }
 846
 847 interface MediaTrackConstraints extends MediaTrackConstraintSet {
 848     advanced?: MediaTrackConstraintSet[];
 849 }
 850
 851 interface MediaTrackSettings {
 852     aspectRatio?: number;
 853     autoGainControl?: boolean;
 854     deviceId?: string;
 855     echoCancellation?: boolean;
 856     facingMode?: string;
 857     frameRate?: number;
 858     groupId?: string;
 859     height?: number;
 860     noiseSuppression?: boolean;
 861     restrictOwnAudio?: boolean;
 862     sampleRate?: number;
 863     sampleSize?: number;
 864     width?: number;
 865 }
 866
 867 interface MediaTrackSupportedConstraints {
 868     aspectRatio?: boolean;
 869     autoGainControl?: boolean;
 870     deviceId?: boolean;
 871     echoCancellation?: boolean;
 872     facingMode?: boolean;
 873     frameRate?: boolean;
 874     groupId?: boolean;
 875     height?: boolean;
 876     noiseSuppression?: boolean;
 877     sampleRate?: boolean;
 878     sampleSize?: boolean;
 879     suppressLocalAudioPlayback?: boolean;
 880     width?: boolean;
 881 }
 882
 883 interface MessageEventInit<T = any> extends EventInit {
 884     data?: T;
 885     lastEventId?: string;
 886     origin?: string;
 887     ports?: MessagePort[];
 888     source?: MessageEventSource | null;
 889 }
 890
 891 interface MouseEventInit extends EventModifierInit {
 892     button?: number;
 893     buttons?: number;
 894     clientX?: number;
 895     clientY?: number;
 896     movementX?: number;
 897     movementY?: number;
 898     relatedTarget?: EventTarget | null;
 899     screenX?: number;
 900     screenY?: number;
 901 }
 902
 903 interface MultiCacheQueryOptions extends CacheQueryOptions {
 904     cacheName?: string;
 905 }
 906
 907 interface MutationObserverInit {
 908     /** 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. */
 909     attributeFilter?: string[];
 910     /** Set to true if attributes is true or omitted and target's attribute value before the mutation needs to be recorded. */
 911     attributeOldValue?: boolean;
 912     /** Set to true if mutations to target's attributes are to be observed. Can be omitted if attributeOldValue or attributeFilter is specified. */
 913     attributes?: boolean;
 914     /** Set to true if mutations to target's data are to be observed. Can be omitted if characterDataOldValue is specified. */
 915     characterData?: boolean;
 916     /** Set to true if characterData is set to true or omitted and target's data before the mutation needs to be recorded. */
 917     characterDataOldValue?: boolean;
 918     /** Set to true if mutations to target's children are to be observed. */
 919     childList?: boolean;
 920     /** Set to true if mutations to not just target, but also target's descendants are to be observed. */
 921     subtree?: boolean;
 922 }
 923
 924 interface NotificationAction {
 925     action: string;
 926     icon?: string;
 927     title: string;
 928 }
 929
 930 interface NotificationOptions {
 931     actions?: NotificationAction[];
 932     badge?: string;
 933     body?: string;
 934     data?: any;
 935     dir?: NotificationDirection;
 936     icon?: string;
 937     image?: string;
 938     lang?: string;
 939     renotify?: boolean;
 940     requireInteraction?: boolean;
 941     silent?: boolean;
 942     tag?: string;
 943     timestamp?: DOMTimeStamp;
 944     vibrate?: VibratePattern;
 945 }
 946
 947 interface OfflineAudioCompletionEventInit extends EventInit {
 948     renderedBuffer: AudioBuffer;
 949 }
 950
 951 interface OfflineAudioContextOptions {
 952     length: number;
 953     numberOfChannels?: number;
 954     sampleRate: number;
 955 }
 956
 957 interface OptionalEffectTiming {
 958     delay?: number;
 959     direction?: PlaybackDirection;
 960     duration?: number | string;
 961     easing?: string;
 962     endDelay?: number;
 963     fill?: FillMode;
 964     iterationStart?: number;
 965     iterations?: number;
 966     playbackRate?: number;
 967 }
 968
 969 interface OscillatorOptions extends AudioNodeOptions {
 970     detune?: number;
 971     frequency?: number;
 972     periodicWave?: PeriodicWave;
 973     type?: OscillatorType;
 974 }
 975
 976 interface PageTransitionEventInit extends EventInit {
 977     persisted?: boolean;
 978 }
 979
 980 interface PannerOptions extends AudioNodeOptions {
 981     coneInnerAngle?: number;
 982     coneOuterAngle?: number;
 983     coneOuterGain?: number;
 984     distanceModel?: DistanceModelType;
 985     maxDistance?: number;
 986     orientationX?: number;
 987     orientationY?: number;
 988     orientationZ?: number;
 989     panningModel?: PanningModelType;
 990     positionX?: number;
 991     positionY?: number;
 992     positionZ?: number;
 993     refDistance?: number;
 994     rolloffFactor?: number;
 995 }
 996
 997 interface PaymentCurrencyAmount {
 998     currency: string;
 999     value: string;
1000 }
1001
1002 interface PaymentDetailsBase {
1003     displayItems?: PaymentItem[];
1004     modifiers?: PaymentDetailsModifier[];
1005 }
1006
1007 interface PaymentDetailsInit extends PaymentDetailsBase {
1008     id?: string;
1009     total: PaymentItem;
1010 }
1011
1012 interface PaymentDetailsModifier {
1013     additionalDisplayItems?: PaymentItem[];
1014     data?: any;
1015     supportedMethods: string;
1016     total?: PaymentItem;
1017 }
1018
1019 interface PaymentDetailsUpdate extends PaymentDetailsBase {
1020     paymentMethodErrors?: any;
1021     total?: PaymentItem;
1022 }
1023
1024 interface PaymentItem {
1025     amount: PaymentCurrencyAmount;
1026     label: string;
1027     pending?: boolean;
1028 }
1029
1030 interface PaymentMethodChangeEventInit extends PaymentRequestUpdateEventInit {
1031     methodDetails?: any;
1032     methodName?: string;
1033 }
1034
1035 interface PaymentMethodData {
1036     data?: any;
1037     supportedMethods: string;
1038 }
1039
1040 interface PaymentRequestUpdateEventInit extends EventInit {
1041 }
1042
1043 interface PaymentValidationErrors {
1044     error?: string;
1045     paymentMethod?: any;
1046 }
1047
1048 interface Pbkdf2Params extends Algorithm {
1049     hash: HashAlgorithmIdentifier;
1050     iterations: number;
1051     salt: BufferSource;
1052 }
1053
1054 interface PerformanceMarkOptions {
1055     detail?: any;
1056     startTime?: DOMHighResTimeStamp;
1057 }
1058
1059 interface PerformanceMeasureOptions {
1060     detail?: any;
1061     duration?: DOMHighResTimeStamp;
1062     end?: string | DOMHighResTimeStamp;
1063     start?: string | DOMHighResTimeStamp;
1064 }
1065
1066 interface PerformanceObserverInit {
1067     buffered?: boolean;
1068     entryTypes?: string[];
1069     type?: string;
1070 }
1071
1072 interface PeriodicWaveConstraints {
1073     disableNormalization?: boolean;
1074 }
1075
1076 interface PeriodicWaveOptions extends PeriodicWaveConstraints {
1077     imag?: number[] | Float32Array;
1078     real?: number[] | Float32Array;
1079 }
1080
1081 interface PermissionDescriptor {
1082     name: PermissionName;
1083 }
1084
1085 interface PointerEventInit extends MouseEventInit {
1086     coalescedEvents?: PointerEvent[];
1087     height?: number;
1088     isPrimary?: boolean;
1089     pointerId?: number;
1090     pointerType?: string;
1091     predictedEvents?: PointerEvent[];
1092     pressure?: number;
1093     tangentialPressure?: number;
1094     tiltX?: number;
1095     tiltY?: number;
1096     twist?: number;
1097     width?: number;
1098 }
1099
1100 interface PopStateEventInit extends EventInit {
1101     state?: any;
1102 }
1103
1104 interface PositionOptions {
1105     enableHighAccuracy?: boolean;
1106     maximumAge?: number;
1107     timeout?: number;
1108 }
1109
1110 interface ProgressEventInit extends EventInit {
1111     lengthComputable?: boolean;
1112     loaded?: number;
1113     total?: number;
1114 }
1115
1116 interface PromiseRejectionEventInit extends EventInit {
1117     promise: Promise<any>;
1118     reason?: any;
1119 }
1120
1121 interface PropertyIndexedKeyframes {
1122     composite?: CompositeOperationOrAuto | CompositeOperationOrAuto[];
1123     easing?: string | string[];
1124     offset?: number | (number | null)[];
1125     [property: string]: string | string[] | number | null | (number | null)[] | undefined;
1126 }
1127
1128 interface PublicKeyCredentialCreationOptions {
1129     attestation?: AttestationConveyancePreference;
1130     authenticatorSelection?: AuthenticatorSelectionCriteria;
1131     challenge: BufferSource;
1132     excludeCredentials?: PublicKeyCredentialDescriptor[];
1133     extensions?: AuthenticationExtensionsClientInputs;
1134     pubKeyCredParams: PublicKeyCredentialParameters[];
1135     rp: PublicKeyCredentialRpEntity;
1136     timeout?: number;
1137     user: PublicKeyCredentialUserEntity;
1138 }
1139
1140 interface PublicKeyCredentialDescriptor {
1141     id: BufferSource;
1142     transports?: AuthenticatorTransport[];
1143     type: PublicKeyCredentialType;
1144 }
1145
1146 interface PublicKeyCredentialEntity {
1147     name: string;
1148 }
1149
1150 interface PublicKeyCredentialParameters {
1151     alg: COSEAlgorithmIdentifier;
1152     type: PublicKeyCredentialType;
1153 }
1154
1155 interface PublicKeyCredentialRequestOptions {
1156     allowCredentials?: PublicKeyCredentialDescriptor[];
1157     challenge: BufferSource;
1158     extensions?: AuthenticationExtensionsClientInputs;
1159     rpId?: string;
1160     timeout?: number;
1161     userVerification?: UserVerificationRequirement;
1162 }
1163
1164 interface PublicKeyCredentialRpEntity extends PublicKeyCredentialEntity {
1165     id?: string;
1166 }
1167
1168 interface PublicKeyCredentialUserEntity extends PublicKeyCredentialEntity {
1169     displayName: string;
1170     id: BufferSource;
1171 }
1172
1173 interface PushSubscriptionJSON {
1174     endpoint?: string;
1175     expirationTime?: DOMTimeStamp | null;
1176     keys?: Record<string, string>;
1177 }
1178
1179 interface PushSubscriptionOptionsInit {
1180     applicationServerKey?: BufferSource | string | null;
1181     userVisibleOnly?: boolean;
1182 }
1183
1184 interface QueuingStrategy<T = any> {
1185     highWaterMark?: number;
1186     size?: QueuingStrategySize<T>;
1187 }
1188
1189 interface QueuingStrategyInit {
1190     /**
1191      * Creates a new ByteLengthQueuingStrategy with the provided high water mark.
1192      *
1193      * 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.
1194      */
1195     highWaterMark: number;
1196 }
1197
1198 interface RTCAnswerOptions extends RTCOfferAnswerOptions {
1199 }
1200
1201 interface RTCCertificateExpiration {
1202     expires?: DOMTimeStamp;
1203 }
1204
1205 interface RTCConfiguration {
1206     bundlePolicy?: RTCBundlePolicy;
1207     certificates?: RTCCertificate[];
1208     iceCandidatePoolSize?: number;
1209     iceServers?: RTCIceServer[];
1210     iceTransportPolicy?: RTCIceTransportPolicy;
1211     rtcpMuxPolicy?: RTCRtcpMuxPolicy;
1212 }
1213
1214 interface RTCDTMFToneChangeEventInit extends EventInit {
1215     tone?: string;
1216 }
1217
1218 interface RTCDataChannelEventInit extends EventInit {
1219     channel: RTCDataChannel;
1220 }
1221
1222 interface RTCDataChannelInit {
1223     id?: number;
1224     maxPacketLifeTime?: number;
1225     maxRetransmits?: number;
1226     negotiated?: boolean;
1227     ordered?: boolean;
1228     protocol?: string;
1229 }
1230
1231 interface RTCDtlsFingerprint {
1232     algorithm?: string;
1233     value?: string;
1234 }
1235
1236 interface RTCIceCandidateInit {
1237     candidate?: string;
1238     sdpMLineIndex?: number | null;
1239     sdpMid?: string | null;
1240     usernameFragment?: string | null;
1241 }
1242
1243 interface RTCIceCandidatePairStats extends RTCStats {
1244     availableIncomingBitrate?: number;
1245     availableOutgoingBitrate?: number;
1246     bytesReceived?: number;
1247     bytesSent?: number;
1248     currentRoundTripTime?: number;
1249     localCandidateId: string;
1250     nominated?: boolean;
1251     remoteCandidateId: string;
1252     requestsReceived?: number;
1253     requestsSent?: number;
1254     responsesReceived?: number;
1255     responsesSent?: number;
1256     state: RTCStatsIceCandidatePairState;
1257     totalRoundTripTime?: number;
1258     transportId: string;
1259 }
1260
1261 interface RTCIceServer {
1262     credential?: string;
1263     credentialType?: RTCIceCredentialType;
1264     urls: string | string[];
1265     username?: string;
1266 }
1267
1268 interface RTCInboundRtpStreamStats extends RTCReceivedRtpStreamStats {
1269     firCount?: number;
1270     framesDecoded?: number;
1271     nackCount?: number;
1272     pliCount?: number;
1273     qpSum?: number;
1274     remoteId?: string;
1275 }
1276
1277 interface RTCLocalSessionDescriptionInit {
1278     sdp?: string;
1279     type?: RTCSdpType;
1280 }
1281
1282 interface RTCOfferAnswerOptions {
1283 }
1284
1285 interface RTCOfferOptions extends RTCOfferAnswerOptions {
1286     iceRestart?: boolean;
1287     offerToReceiveAudio?: boolean;
1288     offerToReceiveVideo?: boolean;
1289 }
1290
1291 interface RTCOutboundRtpStreamStats extends RTCSentRtpStreamStats {
1292     firCount?: number;
1293     framesEncoded?: number;
1294     nackCount?: number;
1295     pliCount?: number;
1296     qpSum?: number;
1297     remoteId?: string;
1298 }
1299
1300 interface RTCPeerConnectionIceErrorEventInit extends EventInit {
1301     address?: string | null;
1302     errorCode: number;
1303     errorText?: string;
1304     port?: number | null;
1305     url?: string;
1306 }
1307
1308 interface RTCPeerConnectionIceEventInit extends EventInit {
1309     candidate?: RTCIceCandidate | null;
1310     url?: string | null;
1311 }
1312
1313 interface RTCReceivedRtpStreamStats extends RTCRtpStreamStats {
1314     jitter?: number;
1315     packetsDiscarded?: number;
1316     packetsLost?: number;
1317     packetsReceived?: number;
1318 }
1319
1320 interface RTCRtcpParameters {
1321     cname?: string;
1322     reducedSize?: boolean;
1323 }
1324
1325 interface RTCRtpCapabilities {
1326     codecs: RTCRtpCodecCapability[];
1327     headerExtensions: RTCRtpHeaderExtensionCapability[];
1328 }
1329
1330 interface RTCRtpCodecCapability {
1331     channels?: number;
1332     clockRate: number;
1333     mimeType: string;
1334     sdpFmtpLine?: string;
1335 }
1336
1337 interface RTCRtpCodecParameters {
1338     channels?: number;
1339     clockRate: number;
1340     mimeType: string;
1341     payloadType: number;
1342     sdpFmtpLine?: string;
1343 }
1344
1345 interface RTCRtpCodingParameters {
1346     rid?: string;
1347 }
1348
1349 interface RTCRtpContributingSource {
1350     audioLevel?: number;
1351     rtpTimestamp: number;
1352     source: number;
1353     timestamp: DOMHighResTimeStamp;
1354 }
1355
1356 interface RTCRtpEncodingParameters extends RTCRtpCodingParameters {
1357     active?: boolean;
1358     maxBitrate?: number;
1359     priority?: RTCPriorityType;
1360     scaleResolutionDownBy?: number;
1361 }
1362
1363 interface RTCRtpHeaderExtensionCapability {
1364     uri?: string;
1365 }
1366
1367 interface RTCRtpHeaderExtensionParameters {
1368     encrypted?: boolean;
1369     id: number;
1370     uri: string;
1371 }
1372
1373 interface RTCRtpParameters {
1374     codecs: RTCRtpCodecParameters[];
1375     headerExtensions: RTCRtpHeaderExtensionParameters[];
1376     rtcp: RTCRtcpParameters;
1377 }
1378
1379 interface RTCRtpReceiveParameters extends RTCRtpParameters {
1380 }
1381
1382 interface RTCRtpSendParameters extends RTCRtpParameters {
1383     degradationPreference?: RTCDegradationPreference;
1384     encodings: RTCRtpEncodingParameters[];
1385     transactionId: string;
1386 }
1387
1388 interface RTCRtpStreamStats extends RTCStats {
1389     codecId?: string;
1390     kind: string;
1391     ssrc: number;
1392     transportId?: string;
1393 }
1394
1395 interface RTCRtpSynchronizationSource extends RTCRtpContributingSource {
1396 }
1397
1398 interface RTCRtpTransceiverInit {
1399     direction?: RTCRtpTransceiverDirection;
1400     sendEncodings?: RTCRtpEncodingParameters[];
1401     streams?: MediaStream[];
1402 }
1403
1404 interface RTCSentRtpStreamStats extends RTCRtpStreamStats {
1405     bytesSent?: number;
1406     packetsSent?: number;
1407 }
1408
1409 interface RTCSessionDescriptionInit {
1410     sdp?: string;
1411     type: RTCSdpType;
1412 }
1413
1414 interface RTCStats {
1415     id: string;
1416     timestamp: DOMHighResTimeStamp;
1417     type: RTCStatsType;
1418 }
1419
1420 interface RTCTrackEventInit extends EventInit {
1421     receiver: RTCRtpReceiver;
1422     streams?: MediaStream[];
1423     track: MediaStreamTrack;
1424     transceiver: RTCRtpTransceiver;
1425 }
1426
1427 interface RTCTransportStats extends RTCStats {
1428     bytesReceived?: number;
1429     bytesSent?: number;
1430     dtlsCipher?: string;
1431     dtlsState: RTCDtlsTransportState;
1432     localCertificateId?: string;
1433     remoteCertificateId?: string;
1434     rtcpTransportStatsId?: string;
1435     selectedCandidatePairId?: string;
1436     srtpCipher?: string;
1437     tlsVersion?: string;
1438 }
1439
1440 interface ReadableStreamDefaultReadDoneResult {
1441     done: true;
1442     value?: undefined;
1443 }
1444
1445 interface ReadableStreamDefaultReadValueResult<T> {
1446     done: false;
1447     value: T;
1448 }
1449
1450 interface ReadableWritablePair<R = any, W = any> {
1451     readable: ReadableStream<R>;
1452     /**
1453      * 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.
1454      *
1455      * Piping a stream will lock it for the duration of the pipe, preventing any other consumer from acquiring a reader.
1456      */
1457     writable: WritableStream<W>;
1458 }
1459
1460 interface RegistrationOptions {
1461     scope?: string;
1462     type?: WorkerType;
1463     updateViaCache?: ServiceWorkerUpdateViaCache;
1464 }
1465
1466 interface RequestInit {
1467     /** A BodyInit object or null to set request's body. */
1468     body?: BodyInit | null;
1469     /** A string indicating how the request will interact with the browser's cache to set request's cache. */
1470     cache?: RequestCache;
1471     /** 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. */
1472     credentials?: RequestCredentials;
1473     /** A Headers object, an object literal, or an array of two-item arrays to set request's headers. */
1474     headers?: HeadersInit;
1475     /** A cryptographic hash of the resource to be fetched by request. Sets request's integrity. */
1476     integrity?: string;
1477     /** A boolean to set request's keepalive. */
1478     keepalive?: boolean;
1479     /** A string to set request's method. */
1480     method?: string;
1481     /** A string to indicate whether the request will use CORS, or will be restricted to same-origin URLs. Sets request's mode. */
1482     mode?: RequestMode;
1483     /** 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. */
1484     redirect?: RequestRedirect;
1485     /** A string whose value is a same-origin URL, "about:client", or the empty string, to set request's referrer. */
1486     referrer?: string;
1487     /** A referrer policy to set request's referrerPolicy. */
1488     referrerPolicy?: ReferrerPolicy;
1489     /** An AbortSignal to set request's signal. */
1490     signal?: AbortSignal | null;
1491     /** Can only be null. Used to disassociate request from any Window. */
1492     window?: null;
1493 }
1494
1495 interface ResizeObserverOptions {
1496     box?: ResizeObserverBoxOptions;
1497 }
1498
1499 interface ResponseInit {
1500     headers?: HeadersInit;
1501     status?: number;
1502     statusText?: string;
1503 }
1504
1505 interface RsaHashedImportParams extends Algorithm {
1506     hash: HashAlgorithmIdentifier;
1507 }
1508
1509 interface RsaHashedKeyAlgorithm extends RsaKeyAlgorithm {
1510     hash: KeyAlgorithm;
1511 }
1512
1513 interface RsaHashedKeyGenParams extends RsaKeyGenParams {
1514     hash: HashAlgorithmIdentifier;
1515 }
1516
1517 interface RsaKeyAlgorithm extends KeyAlgorithm {
1518     modulusLength: number;
1519     publicExponent: BigInteger;
1520 }
1521
1522 interface RsaKeyGenParams extends Algorithm {
1523     modulusLength: number;
1524     publicExponent: BigInteger;
1525 }
1526
1527 interface RsaOaepParams extends Algorithm {
1528     label?: BufferSource;
1529 }
1530
1531 interface RsaOtherPrimesInfo {
1532     d?: string;
1533     r?: string;
1534     t?: string;
1535 }
1536
1537 interface RsaPssParams extends Algorithm {
1538     saltLength: number;
1539 }
1540
1541 interface SVGBoundingBoxOptions {
1542     clipped?: boolean;
1543     fill?: boolean;
1544     markers?: boolean;
1545     stroke?: boolean;
1546 }
1547
1548 interface ScrollIntoViewOptions extends ScrollOptions {
1549     block?: ScrollLogicalPosition;
1550     inline?: ScrollLogicalPosition;
1551 }
1552
1553 interface ScrollOptions {
1554     behavior?: ScrollBehavior;
1555 }
1556
1557 interface ScrollToOptions extends ScrollOptions {
1558     left?: number;
1559     top?: number;
1560 }
1561
1562 interface SecurityPolicyViolationEventInit extends EventInit {
1563     blockedURI?: string;
1564     columnNumber?: number;
1565     disposition: SecurityPolicyViolationEventDisposition;
1566     documentURI: string;
1567     effectiveDirective: string;
1568     lineNumber?: number;
1569     originalPolicy: string;
1570     referrer?: string;
1571     sample?: string;
1572     sourceFile?: string;
1573     statusCode: number;
1574     violatedDirective: string;
1575 }
1576
1577 interface ShadowRootInit {
1578     delegatesFocus?: boolean;
1579     mode: ShadowRootMode;
1580     slotAssignment?: SlotAssignmentMode;
1581 }
1582
1583 interface ShareData {
1584     files?: File[];
1585     text?: string;
1586     title?: string;
1587     url?: string;
1588 }
1589
1590 interface SpeechSynthesisErrorEventInit extends SpeechSynthesisEventInit {
1591     error: SpeechSynthesisErrorCode;
1592 }
1593
1594 interface SpeechSynthesisEventInit extends EventInit {
1595     charIndex?: number;
1596     charLength?: number;
1597     elapsedTime?: number;
1598     name?: string;
1599     utterance: SpeechSynthesisUtterance;
1600 }
1601
1602 interface StaticRangeInit {
1603     endContainer: Node;
1604     endOffset: number;
1605     startContainer: Node;
1606     startOffset: number;
1607 }
1608
1609 interface StereoPannerOptions extends AudioNodeOptions {
1610     pan?: number;
1611 }
1612
1613 interface StorageEstimate {
1614     quota?: number;
1615     usage?: number;
1616 }
1617
1618 interface StorageEventInit extends EventInit {
1619     key?: string | null;
1620     newValue?: string | null;
1621     oldValue?: string | null;
1622     storageArea?: Storage | null;
1623     url?: string;
1624 }
1625
1626 interface StreamPipeOptions {
1627     preventAbort?: boolean;
1628     preventCancel?: boolean;
1629     /**
1630      * 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.
1631      *
1632      * Piping a stream will lock it for the duration of the pipe, preventing any other consumer from acquiring a reader.
1633      *
1634      * Errors and closures of the source and destination streams propagate as follows:
1635      *
1636      * 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.
1637      *
1638      * 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.
1639      *
1640      * 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.
1641      *
1642      * 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.
1643      *
1644      * 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.
1645      */
1646     preventClose?: boolean;
1647     signal?: AbortSignal;
1648 }
1649
1650 interface StructuredSerializeOptions {
1651     transfer?: any[];
1652 }
1653
1654 interface SubmitEventInit extends EventInit {
1655     submitter?: HTMLElement | null;
1656 }
1657
1658 interface TextDecodeOptions {
1659     stream?: boolean;
1660 }
1661
1662 interface TextDecoderOptions {
1663     fatal?: boolean;
1664     ignoreBOM?: boolean;
1665 }
1666
1667 interface TextEncoderEncodeIntoResult {
1668     read?: number;
1669     written?: number;
1670 }
1671
1672 interface TouchEventInit extends EventModifierInit {
1673     changedTouches?: Touch[];
1674     targetTouches?: Touch[];
1675     touches?: Touch[];
1676 }
1677
1678 interface TouchInit {
1679     altitudeAngle?: number;
1680     azimuthAngle?: number;
1681     clientX?: number;
1682     clientY?: number;
1683     force?: number;
1684     identifier: number;
1685     pageX?: number;
1686     pageY?: number;
1687     radiusX?: number;
1688     radiusY?: number;
1689     rotationAngle?: number;
1690     screenX?: number;
1691     screenY?: number;
1692     target: EventTarget;
1693     touchType?: TouchType;
1694 }
1695
1696 interface TrackEventInit extends EventInit {
1697     track?: TextTrack | null;
1698 }
1699
1700 interface Transformer<I = any, O = any> {
1701     flush?: TransformerFlushCallback<O>;
1702     readableType?: undefined;
1703     start?: TransformerStartCallback<O>;
1704     transform?: TransformerTransformCallback<I, O>;
1705     writableType?: undefined;
1706 }
1707
1708 interface TransitionEventInit extends EventInit {
1709     elapsedTime?: number;
1710     propertyName?: string;
1711     pseudoElement?: string;
1712 }
1713
1714 interface UIEventInit extends EventInit {
1715     detail?: number;
1716     view?: Window | null;
1717     /** @deprecated */
1718     which?: number;
1719 }
1720
1721 interface ULongRange {
1722     max?: number;
1723     min?: number;
1724 }
1725
1726 interface UnderlyingSink<W = any> {
1727     abort?: UnderlyingSinkAbortCallback;
1728     close?: UnderlyingSinkCloseCallback;
1729     start?: UnderlyingSinkStartCallback;
1730     type?: undefined;
1731     write?: UnderlyingSinkWriteCallback<W>;
1732 }
1733
1734 interface UnderlyingSource<R = any> {
1735     cancel?: UnderlyingSourceCancelCallback;
1736     pull?: UnderlyingSourcePullCallback<R>;
1737     start?: UnderlyingSourceStartCallback<R>;
1738     type?: undefined;
1739 }
1740
1741 interface VideoConfiguration {
1742     bitrate: number;
1743     colorGamut?: ColorGamut;
1744     contentType: string;
1745     framerate: number;
1746     hdrMetadataType?: HdrMetadataType;
1747     height: number;
1748     scalabilityMode?: string;
1749     transferFunction?: TransferFunction;
1750     width: number;
1751 }
1752
1753 interface WaveShaperOptions extends AudioNodeOptions {
1754     curve?: number[] | Float32Array;
1755     oversample?: OverSampleType;
1756 }
1757
1758 interface WebGLContextAttributes {
1759     alpha?: boolean;
1760     antialias?: boolean;
1761     depth?: boolean;
1762     desynchronized?: boolean;
1763     failIfMajorPerformanceCaveat?: boolean;
1764     powerPreference?: WebGLPowerPreference;
1765     premultipliedAlpha?: boolean;
1766     preserveDrawingBuffer?: boolean;
1767     stencil?: boolean;
1768 }
1769
1770 interface WebGLContextEventInit extends EventInit {
1771     statusMessage?: string;
1772 }
1773
1774 interface WheelEventInit extends MouseEventInit {
1775     deltaMode?: number;
1776     deltaX?: number;
1777     deltaY?: number;
1778     deltaZ?: number;
1779 }
1780
1781 interface WindowPostMessageOptions extends StructuredSerializeOptions {
1782     targetOrigin?: string;
1783 }
1784
1785 interface WorkerOptions {
1786     credentials?: RequestCredentials;
1787     name?: string;
1788     type?: WorkerType;
1789 }
1790
1791 interface WorkletOptions {
1792     credentials?: RequestCredentials;
1793 }
1794
1795 type NodeFilter = ((node: Node) => number) | { acceptNode(node: Node): number; };
1796
1797 declare var NodeFilter: {
1798     readonly FILTER_ACCEPT: number;
1799     readonly FILTER_REJECT: number;
1800     readonly FILTER_SKIP: number;
1801     readonly SHOW_ALL: number;
1802     readonly SHOW_ATTRIBUTE: number;
1803     readonly SHOW_CDATA_SECTION: number;
1804     readonly SHOW_COMMENT: number;
1805     readonly SHOW_DOCUMENT: number;
1806     readonly SHOW_DOCUMENT_FRAGMENT: number;
1807     readonly SHOW_DOCUMENT_TYPE: number;
1808     readonly SHOW_ELEMENT: number;
1809     readonly SHOW_ENTITY: number;
1810     readonly SHOW_ENTITY_REFERENCE: number;
1811     readonly SHOW_NOTATION: number;
1812     readonly SHOW_PROCESSING_INSTRUCTION: number;
1813     readonly SHOW_TEXT: number;
1814 };
1815
1816 type XPathNSResolver = ((prefix: string | null) => string | null) | { lookupNamespaceURI(prefix: string | null): string | null; };
1817
1818 /** 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. */
1819 interface ANGLE_instanced_arrays {
1820     drawArraysInstancedANGLE(mode: GLenum, first: GLint, count: GLsizei, primcount: GLsizei): void;
1821     drawElementsInstancedANGLE(mode: GLenum, count: GLsizei, type: GLenum, offset: GLintptr, primcount: GLsizei): void;
1822     vertexAttribDivisorANGLE(index: GLuint, divisor: GLuint): void;
1823     readonly VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE: GLenum;
1824 }
1825
1826 interface ARIAMixin {
1827     ariaAtomic: string;
1828     ariaAutoComplete: string;
1829     ariaBusy: string;
1830     ariaChecked: string;
1831     ariaColCount: string;
1832     ariaColIndex: string;
1833     ariaColSpan: string;
1834     ariaCurrent: string;
1835     ariaDisabled: string;
1836     ariaExpanded: string;
1837     ariaHasPopup: string;
1838     ariaHidden: string;
1839     ariaKeyShortcuts: string;
1840     ariaLabel: string;
1841     ariaLevel: string;
1842     ariaLive: string;
1843     ariaModal: string;
1844     ariaMultiLine: string;
1845     ariaMultiSelectable: string;
1846     ariaOrientation: string;
1847     ariaPlaceholder: string;
1848     ariaPosInSet: string;
1849     ariaPressed: string;
1850     ariaReadOnly: string;
1851     ariaRequired: string;
1852     ariaRoleDescription: string;
1853     ariaRowCount: string;
1854     ariaRowIndex: string;
1855     ariaRowSpan: string;
1856     ariaSelected: string;
1857     ariaSetSize: string;
1858     ariaSort: string;
1859     ariaValueMax: string;
1860     ariaValueMin: string;
1861     ariaValueNow: string;
1862     ariaValueText: string;
1863 }
1864
1865 /** A controller object that allows you to abort one or more DOM requests as and when desired. */
1866 interface AbortController {
1867     /** Returns the AbortSignal object associated with this object. */
1868     readonly signal: AbortSignal;
1869     /** 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. */
1870     abort(): void;
1871 }
1872
1873 declare var AbortController: {
1874     prototype: AbortController;
1875     new(): AbortController;
1876 };
1877
1878 interface AbortSignalEventMap {
1879     "abort": Event;
1880 }
1881
1882 /** 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. */
1883 interface AbortSignal extends EventTarget {
1884     /** Returns true if this AbortSignal's AbortController has signaled to abort, and false otherwise. */
1885     readonly aborted: boolean;
1886     onabort: ((this: AbortSignal, ev: Event) => any) | null;
1887     addEventListener<K extends keyof AbortSignalEventMap>(type: K, listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
1888     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
1889     removeEventListener<K extends keyof AbortSignalEventMap>(type: K, listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
1890     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
1891 }
1892
1893 declare var AbortSignal: {
1894     prototype: AbortSignal;
1895     new(): AbortSignal;
1896     // abort(): AbortSignal; - To be re-added in the future
1897 };
1898
1899 interface AbstractRange {
1900     /** Returns true if range is collapsed, and false otherwise. */
1901     readonly collapsed: boolean;
1902     /** Returns range's end node. */
1903     readonly endContainer: Node;
1904     /** Returns range's end offset. */
1905     readonly endOffset: number;
1906     /** Returns range's start node. */
1907     readonly startContainer: Node;
1908     /** Returns range's start offset. */
1909     readonly startOffset: number;
1910 }
1911
1912 declare var AbstractRange: {
1913     prototype: AbstractRange;
1914     new(): AbstractRange;
1915 };
1916
1917 interface AbstractWorkerEventMap {
1918     "error": ErrorEvent;
1919 }
1920
1921 interface AbstractWorker {
1922     onerror: ((this: AbstractWorker, ev: ErrorEvent) => any) | null;
1923     addEventListener<K extends keyof AbstractWorkerEventMap>(type: K, listener: (this: AbstractWorker, ev: AbstractWorkerEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
1924     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
1925     removeEventListener<K extends keyof AbstractWorkerEventMap>(type: K, listener: (this: AbstractWorker, ev: AbstractWorkerEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
1926     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
1927 }
1928
1929 /** 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. */
1930 interface AnalyserNode extends AudioNode {
1931     fftSize: number;
1932     readonly frequencyBinCount: number;
1933     maxDecibels: number;
1934     minDecibels: number;
1935     smoothingTimeConstant: number;
1936     getByteFrequencyData(array: Uint8Array): void;
1937     getByteTimeDomainData(array: Uint8Array): void;
1938     getFloatFrequencyData(array: Float32Array): void;
1939     getFloatTimeDomainData(array: Float32Array): void;
1940 }
1941
1942 declare var AnalyserNode: {
1943     prototype: AnalyserNode;
1944     new(context: BaseAudioContext, options?: AnalyserOptions): AnalyserNode;
1945 };
1946
1947 interface Animatable {
1948     animate(keyframes: Keyframe[] | PropertyIndexedKeyframes | null, options?: number | KeyframeAnimationOptions): Animation;
1949     getAnimations(options?: GetAnimationsOptions): Animation[];
1950 }
1951
1952 interface AnimationEventMap {
1953     "cancel": AnimationPlaybackEvent;
1954     "finish": AnimationPlaybackEvent;
1955     "remove": Event;
1956 }
1957
1958 interface Animation extends EventTarget {
1959     currentTime: CSSNumberish | null;
1960     effect: AnimationEffect | null;
1961     readonly finished: Promise<Animation>;
1962     id: string;
1963     oncancel: ((this: Animation, ev: AnimationPlaybackEvent) => any) | null;
1964     onfinish: ((this: Animation, ev: AnimationPlaybackEvent) => any) | null;
1965     onremove: ((this: Animation, ev: Event) => any) | null;
1966     readonly pending: boolean;
1967     readonly playState: AnimationPlayState;
1968     playbackRate: number;
1969     readonly ready: Promise<Animation>;
1970     readonly replaceState: AnimationReplaceState;
1971     startTime: CSSNumberish | null;
1972     timeline: AnimationTimeline | null;
1973     cancel(): void;
1974     commitStyles(): void;
1975     finish(): void;
1976     pause(): void;
1977     persist(): void;
1978     play(): void;
1979     reverse(): void;
1980     updatePlaybackRate(playbackRate: number): void;
1981     addEventListener<K extends keyof AnimationEventMap>(type: K, listener: (this: Animation, ev: AnimationEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
1982     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
1983     removeEventListener<K extends keyof AnimationEventMap>(type: K, listener: (this: Animation, ev: AnimationEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
1984     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
1985 }
1986
1987 declare var Animation: {
1988     prototype: Animation;
1989     new(effect?: AnimationEffect | null, timeline?: AnimationTimeline | null): Animation;
1990 };
1991
1992 interface AnimationEffect {
1993     getComputedTiming(): ComputedEffectTiming;
1994     getTiming(): EffectTiming;
1995     updateTiming(timing?: OptionalEffectTiming): void;
1996 }
1997
1998 declare var AnimationEffect: {
1999     prototype: AnimationEffect;
2000     new(): AnimationEffect;
2001 };
2002
2003 /** Events providing information related to animations. */
2004 interface AnimationEvent extends Event {
2005     readonly animationName: string;
2006     readonly elapsedTime: number;
2007     readonly pseudoElement: string;
2008 }
2009
2010 declare var AnimationEvent: {
2011     prototype: AnimationEvent;
2012     new(type: string, animationEventInitDict?: AnimationEventInit): AnimationEvent;
2013 };
2014
2015 interface AnimationFrameProvider {
2016     cancelAnimationFrame(handle: number): void;
2017     requestAnimationFrame(callback: FrameRequestCallback): number;
2018 }
2019
2020 interface AnimationPlaybackEvent extends Event {
2021     readonly currentTime: CSSNumberish | null;
2022     readonly timelineTime: CSSNumberish | null;
2023 }
2024
2025 declare var AnimationPlaybackEvent: {
2026     prototype: AnimationPlaybackEvent;
2027     new(type: string, eventInitDict?: AnimationPlaybackEventInit): AnimationPlaybackEvent;
2028 };
2029
2030 interface AnimationTimeline {
2031     readonly currentTime: number | null;
2032 }
2033
2034 declare var AnimationTimeline: {
2035     prototype: AnimationTimeline;
2036     new(): AnimationTimeline;
2037 };
2038
2039 /** 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. */
2040 interface Attr extends Node {
2041     readonly localName: string;
2042     readonly name: string;
2043     readonly namespaceURI: string | null;
2044     readonly ownerDocument: Document;
2045     readonly ownerElement: Element | null;
2046     readonly prefix: string | null;
2047     readonly specified: boolean;
2048     value: string;
2049 }
2050
2051 declare var Attr: {
2052     prototype: Attr;
2053     new(): Attr;
2054 };
2055
2056 /** 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. */
2057 interface AudioBuffer {
2058     readonly duration: number;
2059     readonly length: number;
2060     readonly numberOfChannels: number;
2061     readonly sampleRate: number;
2062     copyFromChannel(destination: Float32Array, channelNumber: number, bufferOffset?: number): void;
2063     copyToChannel(source: Float32Array, channelNumber: number, bufferOffset?: number): void;
2064     getChannelData(channel: number): Float32Array;
2065 }
2066
2067 declare var AudioBuffer: {
2068     prototype: AudioBuffer;
2069     new(options: AudioBufferOptions): AudioBuffer;
2070 };
2071
2072 /** 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. */
2073 interface AudioBufferSourceNode extends AudioScheduledSourceNode {
2074     buffer: AudioBuffer | null;
2075     readonly detune: AudioParam;
2076     loop: boolean;
2077     loopEnd: number;
2078     loopStart: number;
2079     readonly playbackRate: AudioParam;
2080     start(when?: number, offset?: number, duration?: number): void;
2081     addEventListener<K extends keyof AudioScheduledSourceNodeEventMap>(type: K, listener: (this: AudioBufferSourceNode, ev: AudioScheduledSourceNodeEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
2082     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
2083     removeEventListener<K extends keyof AudioScheduledSourceNodeEventMap>(type: K, listener: (this: AudioBufferSourceNode, ev: AudioScheduledSourceNodeEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
2084     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
2085 }
2086
2087 declare var AudioBufferSourceNode: {
2088     prototype: AudioBufferSourceNode;
2089     new(context: BaseAudioContext, options?: AudioBufferSourceOptions): AudioBufferSourceNode;
2090 };
2091
2092 /** An audio-processing graph built from audio modules linked together, each represented by an AudioNode. */
2093 interface AudioContext extends BaseAudioContext {
2094     readonly baseLatency: number;
2095     close(): Promise<void>;
2096     createMediaElementSource(mediaElement: HTMLMediaElement): MediaElementAudioSourceNode;
2097     createMediaStreamDestination(): MediaStreamAudioDestinationNode;
2098     createMediaStreamSource(mediaStream: MediaStream): MediaStreamAudioSourceNode;
2099     getOutputTimestamp(): AudioTimestamp;
2100     resume(): Promise<void>;
2101     suspend(): Promise<void>;
2102     addEventListener<K extends keyof BaseAudioContextEventMap>(type: K, listener: (this: AudioContext, ev: BaseAudioContextEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
2103     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
2104     removeEventListener<K extends keyof BaseAudioContextEventMap>(type: K, listener: (this: AudioContext, ev: BaseAudioContextEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
2105     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
2106 }
2107
2108 declare var AudioContext: {
2109     prototype: AudioContext;
2110     new(contextOptions?: AudioContextOptions): AudioContext;
2111 };
2112
2113 /** 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. */
2114 interface AudioDestinationNode extends AudioNode {
2115     readonly maxChannelCount: number;
2116 }
2117
2118 declare var AudioDestinationNode: {
2119     prototype: AudioDestinationNode;
2120     new(): AudioDestinationNode;
2121 };
2122
2123 /** 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. */
2124 interface AudioListener {
2125     readonly forwardX: AudioParam;
2126     readonly forwardY: AudioParam;
2127     readonly forwardZ: AudioParam;
2128     readonly positionX: AudioParam;
2129     readonly positionY: AudioParam;
2130     readonly positionZ: AudioParam;
2131     readonly upX: AudioParam;
2132     readonly upY: AudioParam;
2133     readonly upZ: AudioParam;
2134     /** @deprecated */
2135     setOrientation(x: number, y: number, z: number, xUp: number, yUp: number, zUp: number): void;
2136     /** @deprecated */
2137     setPosition(x: number, y: number, z: number): void;
2138 }
2139
2140 declare var AudioListener: {
2141     prototype: AudioListener;
2142     new(): AudioListener;
2143 };
2144
2145 /** A generic interface for representing an audio processing module. Examples include: */
2146 interface AudioNode extends EventTarget {
2147     channelCount: number;
2148     channelCountMode: ChannelCountMode;
2149     channelInterpretation: ChannelInterpretation;
2150     readonly context: BaseAudioContext;
2151     readonly numberOfInputs: number;
2152     readonly numberOfOutputs: number;
2153     connect(destinationNode: AudioNode, output?: number, input?: number): AudioNode;
2154     connect(destinationParam: AudioParam, output?: number): void;
2155     disconnect(): void;
2156     disconnect(output: number): void;
2157     disconnect(destinationNode: AudioNode): void;
2158     disconnect(destinationNode: AudioNode, output: number): void;
2159     disconnect(destinationNode: AudioNode, output: number, input: number): void;
2160     disconnect(destinationParam: AudioParam): void;
2161     disconnect(destinationParam: AudioParam, output: number): void;
2162 }
2163
2164 declare var AudioNode: {
2165     prototype: AudioNode;
2166     new(): AudioNode;
2167 };
2168
2169 /** The Web Audio API's AudioParam interface represents an audio-related parameter, usually a parameter of an AudioNode (such as GainNode.gain). */
2170 interface AudioParam {
2171     automationRate: AutomationRate;
2172     readonly defaultValue: number;
2173     readonly maxValue: number;
2174     readonly minValue: number;
2175     value: number;
2176     cancelAndHoldAtTime(cancelTime: number): AudioParam;
2177     cancelScheduledValues(cancelTime: number): AudioParam;
2178     exponentialRampToValueAtTime(value: number, endTime: number): AudioParam;
2179     linearRampToValueAtTime(value: number, endTime: number): AudioParam;
2180     setTargetAtTime(target: number, startTime: number, timeConstant: number): AudioParam;
2181     setValueAtTime(value: number, startTime: number): AudioParam;
2182     setValueCurveAtTime(values: number[] | Float32Array, startTime: number, duration: number): AudioParam;
2183 }
2184
2185 declare var AudioParam: {
2186     prototype: AudioParam;
2187     new(): AudioParam;
2188 };
2189
2190 interface AudioParamMap {
2191     forEach(callbackfn: (value: AudioParam, key: string, parent: AudioParamMap) => void, thisArg?: any): void;
2192 }
2193
2194 declare var AudioParamMap: {
2195     prototype: AudioParamMap;
2196     new(): AudioParamMap;
2197 };
2198
2199 /**
2200  * The Web Audio API events that occur when a ScriptProcessorNode input buffer is ready to be processed.
2201  * @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.
2202  */
2203 interface AudioProcessingEvent extends Event {
2204     /** @deprecated */
2205     readonly inputBuffer: AudioBuffer;
2206     /** @deprecated */
2207     readonly outputBuffer: AudioBuffer;
2208     /** @deprecated */
2209     readonly playbackTime: number;
2210 }
2211
2212 /** @deprecated */
2213 declare var AudioProcessingEvent: {
2214     prototype: AudioProcessingEvent;
2215     new(type: string, eventInitDict: AudioProcessingEventInit): AudioProcessingEvent;
2216 };
2217
2218 interface AudioScheduledSourceNodeEventMap {
2219     "ended": Event;
2220 }
2221
2222 interface AudioScheduledSourceNode extends AudioNode {
2223     onended: ((this: AudioScheduledSourceNode, ev: Event) => any) | null;
2224     start(when?: number): void;
2225     stop(when?: number): void;
2226     addEventListener<K extends keyof AudioScheduledSourceNodeEventMap>(type: K, listener: (this: AudioScheduledSourceNode, ev: AudioScheduledSourceNodeEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
2227     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
2228     removeEventListener<K extends keyof AudioScheduledSourceNodeEventMap>(type: K, listener: (this: AudioScheduledSourceNode, ev: AudioScheduledSourceNodeEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
2229     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
2230 }
2231
2232 declare var AudioScheduledSourceNode: {
2233     prototype: AudioScheduledSourceNode;
2234     new(): AudioScheduledSourceNode;
2235 };
2236
2237 /** Available only in secure contexts. */
2238 interface AudioWorklet extends Worklet {
2239 }
2240
2241 declare var AudioWorklet: {
2242     prototype: AudioWorklet;
2243     new(): AudioWorklet;
2244 };
2245
2246 interface AudioWorkletNodeEventMap {
2247     "processorerror": Event;
2248 }
2249
2250 /** Available only in secure contexts. */
2251 interface AudioWorkletNode extends AudioNode {
2252     onprocessorerror: ((this: AudioWorkletNode, ev: Event) => any) | null;
2253     readonly parameters: AudioParamMap;
2254     readonly port: MessagePort;
2255     addEventListener<K extends keyof AudioWorkletNodeEventMap>(type: K, listener: (this: AudioWorkletNode, ev: AudioWorkletNodeEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
2256     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
2257     removeEventListener<K extends keyof AudioWorkletNodeEventMap>(type: K, listener: (this: AudioWorkletNode, ev: AudioWorkletNodeEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
2258     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
2259 }
2260
2261 declare var AudioWorkletNode: {
2262     prototype: AudioWorkletNode;
2263     new(context: BaseAudioContext, name: string, options?: AudioWorkletNodeOptions): AudioWorkletNode;
2264 };
2265
2266 /** Available only in secure contexts. */
2267 interface AuthenticatorAssertionResponse extends AuthenticatorResponse {
2268     readonly authenticatorData: ArrayBuffer;
2269     readonly signature: ArrayBuffer;
2270     readonly userHandle: ArrayBuffer | null;
2271 }
2272
2273 declare var AuthenticatorAssertionResponse: {
2274     prototype: AuthenticatorAssertionResponse;
2275     new(): AuthenticatorAssertionResponse;
2276 };
2277
2278 /** Available only in secure contexts. */
2279 interface AuthenticatorAttestationResponse extends AuthenticatorResponse {
2280     readonly attestationObject: ArrayBuffer;
2281 }
2282
2283 declare var AuthenticatorAttestationResponse: {
2284     prototype: AuthenticatorAttestationResponse;
2285     new(): AuthenticatorAttestationResponse;
2286 };
2287
2288 /** Available only in secure contexts. */
2289 interface AuthenticatorResponse {
2290     readonly clientDataJSON: ArrayBuffer;
2291 }
2292
2293 declare var AuthenticatorResponse: {
2294     prototype: AuthenticatorResponse;
2295     new(): AuthenticatorResponse;
2296 };
2297
2298 interface BarProp {
2299     readonly visible: boolean;
2300 }
2301
2302 declare var BarProp: {
2303     prototype: BarProp;
2304     new(): BarProp;
2305 };
2306
2307 interface BaseAudioContextEventMap {
2308     "statechange": Event;
2309 }
2310
2311 interface BaseAudioContext extends EventTarget {
2312     /** Available only in secure contexts. */
2313     readonly audioWorklet: AudioWorklet;
2314     readonly currentTime: number;
2315     readonly destination: AudioDestinationNode;
2316     readonly listener: AudioListener;
2317     onstatechange: ((this: BaseAudioContext, ev: Event) => any) | null;
2318     readonly sampleRate: number;
2319     readonly state: AudioContextState;
2320     createAnalyser(): AnalyserNode;
2321     createBiquadFilter(): BiquadFilterNode;
2322     createBuffer(numberOfChannels: number, length: number, sampleRate: number): AudioBuffer;
2323     createBufferSource(): AudioBufferSourceNode;
2324     createChannelMerger(numberOfInputs?: number): ChannelMergerNode;
2325     createChannelSplitter(numberOfOutputs?: number): ChannelSplitterNode;
2326     createConstantSource(): ConstantSourceNode;
2327     createConvolver(): ConvolverNode;
2328     createDelay(maxDelayTime?: number): DelayNode;
2329     createDynamicsCompressor(): DynamicsCompressorNode;
2330     createGain(): GainNode;
2331     createIIRFilter(feedforward: number[], feedback: number[]): IIRFilterNode;
2332     createOscillator(): OscillatorNode;
2333     createPanner(): PannerNode;
2334     createPeriodicWave(real: number[] | Float32Array, imag: number[] | Float32Array, constraints?: PeriodicWaveConstraints): PeriodicWave;
2335     /** @deprecated */
2336     createScriptProcessor(bufferSize?: number, numberOfInputChannels?: number, numberOfOutputChannels?: number): ScriptProcessorNode;
2337     createStereoPanner(): StereoPannerNode;
2338     createWaveShaper(): WaveShaperNode;
2339     decodeAudioData(audioData: ArrayBuffer, successCallback?: DecodeSuccessCallback | null, errorCallback?: DecodeErrorCallback | null): Promise<AudioBuffer>;
2340     addEventListener<K extends keyof BaseAudioContextEventMap>(type: K, listener: (this: BaseAudioContext, ev: BaseAudioContextEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
2341     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
2342     removeEventListener<K extends keyof BaseAudioContextEventMap>(type: K, listener: (this: BaseAudioContext, ev: BaseAudioContextEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
2343     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
2344 }
2345
2346 declare var BaseAudioContext: {
2347     prototype: BaseAudioContext;
2348     new(): BaseAudioContext;
2349 };
2350
2351 /** The beforeunload event is fired when the window, the document and its resources are about to be unloaded. */
2352 interface BeforeUnloadEvent extends Event {
2353     returnValue: any;
2354 }
2355
2356 declare var BeforeUnloadEvent: {
2357     prototype: BeforeUnloadEvent;
2358     new(): BeforeUnloadEvent;
2359 };
2360
2361 /** 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. */
2362 interface BiquadFilterNode extends AudioNode {
2363     readonly Q: AudioParam;
2364     readonly detune: AudioParam;
2365     readonly frequency: AudioParam;
2366     readonly gain: AudioParam;
2367     type: BiquadFilterType;
2368     getFrequencyResponse(frequencyHz: Float32Array, magResponse: Float32Array, phaseResponse: Float32Array): void;
2369 }
2370
2371 declare var BiquadFilterNode: {
2372     prototype: BiquadFilterNode;
2373     new(context: BaseAudioContext, options?: BiquadFilterOptions): BiquadFilterNode;
2374 };
2375
2376 /** 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. */
2377 interface Blob {
2378     readonly size: number;
2379     readonly type: string;
2380     arrayBuffer(): Promise<ArrayBuffer>;
2381     slice(start?: number, end?: number, contentType?: string): Blob;
2382     stream(): ReadableStream;
2383     text(): Promise<string>;
2384 }
2385
2386 declare var Blob: {
2387     prototype: Blob;
2388     new(blobParts?: BlobPart[], options?: BlobPropertyBag): Blob;
2389 };
2390
2391 interface BlobEvent extends Event {
2392     readonly data: Blob;
2393     readonly timecode: DOMHighResTimeStamp;
2394 }
2395
2396 declare var BlobEvent: {
2397     prototype: BlobEvent;
2398     new(type: string, eventInitDict: BlobEventInit): BlobEvent;
2399 };
2400
2401 interface Body {
2402     readonly body: ReadableStream<Uint8Array> | null;
2403     readonly bodyUsed: boolean;
2404     arrayBuffer(): Promise<ArrayBuffer>;
2405     blob(): Promise<Blob>;
2406     formData(): Promise<FormData>;
2407     json(): Promise<any>;
2408     text(): Promise<string>;
2409 }
2410
2411 interface BroadcastChannelEventMap {
2412     "message": MessageEvent;
2413     "messageerror": MessageEvent;
2414 }
2415
2416 interface BroadcastChannel extends EventTarget {
2417     /** Returns the channel name (as passed to the constructor). */
2418     readonly name: string;
2419     onmessage: ((this: BroadcastChannel, ev: MessageEvent) => any) | null;
2420     onmessageerror: ((this: BroadcastChannel, ev: MessageEvent) => any) | null;
2421     /** Closes the BroadcastChannel object, opening it up to garbage collection. */
2422     close(): void;
2423     /** Sends the given message to other BroadcastChannel objects set up for this channel. Messages can be structured objects, e.g. nested objects and arrays. */
2424     postMessage(message: any): void;
2425     addEventListener<K extends keyof BroadcastChannelEventMap>(type: K, listener: (this: BroadcastChannel, ev: BroadcastChannelEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
2426     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
2427     removeEventListener<K extends keyof BroadcastChannelEventMap>(type: K, listener: (this: BroadcastChannel, ev: BroadcastChannelEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
2428     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
2429 }
2430
2431 declare var BroadcastChannel: {
2432     prototype: BroadcastChannel;
2433     new(name: string): BroadcastChannel;
2434 };
2435
2436 /** This Streams API interface provides a built-in byte length queuing strategy that can be used when constructing streams. */
2437 interface ByteLengthQueuingStrategy extends QueuingStrategy<ArrayBufferView> {
2438     readonly highWaterMark: number;
2439     readonly size: QueuingStrategySize<ArrayBufferView>;
2440 }
2441
2442 declare var ByteLengthQueuingStrategy: {
2443     prototype: ByteLengthQueuingStrategy;
2444     new(init: QueuingStrategyInit): ByteLengthQueuingStrategy;
2445 };
2446
2447 /** 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. */
2448 interface CDATASection extends Text {
2449 }
2450
2451 declare var CDATASection: {
2452     prototype: CDATASection;
2453     new(): CDATASection;
2454 };
2455
2456 interface CSSAnimation extends Animation {
2457     readonly animationName: string;
2458     addEventListener<K extends keyof AnimationEventMap>(type: K, listener: (this: CSSAnimation, ev: AnimationEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
2459     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
2460     removeEventListener<K extends keyof AnimationEventMap>(type: K, listener: (this: CSSAnimation, ev: AnimationEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
2461     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
2462 }
2463
2464 declare var CSSAnimation: {
2465     prototype: CSSAnimation;
2466     new(): CSSAnimation;
2467 };
2468
2469 /** A single condition CSS at-rule, which consists of a condition and a statement block. It is a child of CSSGroupingRule. */
2470 interface CSSConditionRule extends CSSGroupingRule {
2471     conditionText: string;
2472 }
2473
2474 declare var CSSConditionRule: {
2475     prototype: CSSConditionRule;
2476     new(): CSSConditionRule;
2477 };
2478
2479 interface CSSCounterStyleRule extends CSSRule {
2480     additiveSymbols: string;
2481     fallback: string;
2482     name: string;
2483     negative: string;
2484     pad: string;
2485     prefix: string;
2486     range: string;
2487     speakAs: string;
2488     suffix: string;
2489     symbols: string;
2490     system: string;
2491 }
2492
2493 declare var CSSCounterStyleRule: {
2494     prototype: CSSCounterStyleRule;
2495     new(): CSSCounterStyleRule;
2496 };
2497
2498 interface CSSFontFaceRule extends CSSRule {
2499     readonly style: CSSStyleDeclaration;
2500 }
2501
2502 declare var CSSFontFaceRule: {
2503     prototype: CSSFontFaceRule;
2504     new(): CSSFontFaceRule;
2505 };
2506
2507 /** Any CSS at-rule that contains other rules nested within it. */
2508 interface CSSGroupingRule extends CSSRule {
2509     readonly cssRules: CSSRuleList;
2510     deleteRule(index: number): void;
2511     insertRule(rule: string, index?: number): number;
2512 }
2513
2514 declare var CSSGroupingRule: {
2515     prototype: CSSGroupingRule;
2516     new(): CSSGroupingRule;
2517 };
2518
2519 interface CSSImportRule extends CSSRule {
2520     readonly href: string;
2521     readonly media: MediaList;
2522     readonly styleSheet: CSSStyleSheet;
2523 }
2524
2525 declare var CSSImportRule: {
2526     prototype: CSSImportRule;
2527     new(): CSSImportRule;
2528 };
2529
2530 /** 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). */
2531 interface CSSKeyframeRule extends CSSRule {
2532     keyText: string;
2533     readonly style: CSSStyleDeclaration;
2534 }
2535
2536 declare var CSSKeyframeRule: {
2537     prototype: CSSKeyframeRule;
2538     new(): CSSKeyframeRule;
2539 };
2540
2541 /** 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). */
2542 interface CSSKeyframesRule extends CSSRule {
2543     readonly cssRules: CSSRuleList;
2544     name: string;
2545     appendRule(rule: string): void;
2546     deleteRule(select: string): void;
2547     findRule(select: string): CSSKeyframeRule | null;
2548 }
2549
2550 declare var CSSKeyframesRule: {
2551     prototype: CSSKeyframesRule;
2552     new(): CSSKeyframesRule;
2553 };
2554
2555 /** 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). */
2556 interface CSSMediaRule extends CSSConditionRule {
2557     readonly media: MediaList;
2558 }
2559
2560 declare var CSSMediaRule: {
2561     prototype: CSSMediaRule;
2562     new(): CSSMediaRule;
2563 };
2564
2565 /** An object representing a single CSS @namespace at-rule. It implements the CSSRule interface, with a type value of 10 (CSSRule.NAMESPACE_RULE). */
2566 interface CSSNamespaceRule extends CSSRule {
2567     readonly namespaceURI: string;
2568     readonly prefix: string;
2569 }
2570
2571 declare var CSSNamespaceRule: {
2572     prototype: CSSNamespaceRule;
2573     new(): CSSNamespaceRule;
2574 };
2575
2576 /** CSSPageRule is an interface representing a single CSS @page rule. It implements the CSSRule interface with a type value of 6 (CSSRule.PAGE_RULE). */
2577 interface CSSPageRule extends CSSGroupingRule {
2578     selectorText: string;
2579     readonly style: CSSStyleDeclaration;
2580 }
2581
2582 declare var CSSPageRule: {
2583     prototype: CSSPageRule;
2584     new(): CSSPageRule;
2585 };
2586
2587 /** A single CSS rule. There are several types of rules, listed in the Type constants section below. */
2588 interface CSSRule {
2589     cssText: string;
2590     readonly parentRule: CSSRule | null;
2591     readonly parentStyleSheet: CSSStyleSheet | null;
2592     /** @deprecated */
2593     readonly type: number;
2594     readonly CHARSET_RULE: number;
2595     readonly FONT_FACE_RULE: number;
2596     readonly IMPORT_RULE: number;
2597     readonly KEYFRAMES_RULE: number;
2598     readonly KEYFRAME_RULE: number;
2599     readonly MEDIA_RULE: number;
2600     readonly NAMESPACE_RULE: number;
2601     readonly PAGE_RULE: number;
2602     readonly STYLE_RULE: number;
2603     readonly SUPPORTS_RULE: number;
2604 }
2605
2606 declare var CSSRule: {
2607     prototype: CSSRule;
2608     new(): CSSRule;
2609     readonly CHARSET_RULE: number;
2610     readonly FONT_FACE_RULE: number;
2611     readonly IMPORT_RULE: number;
2612     readonly KEYFRAMES_RULE: number;
2613     readonly KEYFRAME_RULE: number;
2614     readonly MEDIA_RULE: number;
2615     readonly NAMESPACE_RULE: number;
2616     readonly PAGE_RULE: number;
2617     readonly STYLE_RULE: number;
2618     readonly SUPPORTS_RULE: number;
2619 };
2620
2621 /** A CSSRuleList is an (indirect-modify only) array-like object containing an ordered collection of CSSRule objects. */
2622 interface CSSRuleList {
2623     readonly length: number;
2624     item(index: number): CSSRule | null;
2625     [index: number]: CSSRule;
2626 }
2627
2628 declare var CSSRuleList: {
2629     prototype: CSSRuleList;
2630     new(): CSSRuleList;
2631 };
2632
2633 /** An object that is a CSS declaration block, and exposes style information and various style-related methods and properties. */
2634 interface CSSStyleDeclaration {
2635     accentColor: string;
2636     alignContent: string;
2637     alignItems: string;
2638     alignSelf: string;
2639     alignmentBaseline: string;
2640     all: string;
2641     animation: string;
2642     animationDelay: string;
2643     animationDirection: string;
2644     animationDuration: string;
2645     animationFillMode: string;
2646     animationIterationCount: string;
2647     animationName: string;
2648     animationPlayState: string;
2649     animationTimingFunction: string;
2650     appearance: string;
2651     aspectRatio: string;
2652     backfaceVisibility: string;
2653     background: string;
2654     backgroundAttachment: string;
2655     backgroundBlendMode: string;
2656     backgroundClip: string;
2657     backgroundColor: string;
2658     backgroundImage: string;
2659     backgroundOrigin: string;
2660     backgroundPosition: string;
2661     backgroundPositionX: string;
2662     backgroundPositionY: string;
2663     backgroundRepeat: string;
2664     backgroundSize: string;
2665     baselineShift: string;
2666     blockSize: string;
2667     border: string;
2668     borderBlock: string;
2669     borderBlockColor: string;
2670     borderBlockEnd: string;
2671     borderBlockEndColor: string;
2672     borderBlockEndStyle: string;
2673     borderBlockEndWidth: string;
2674     borderBlockStart: string;
2675     borderBlockStartColor: string;
2676     borderBlockStartStyle: string;
2677     borderBlockStartWidth: string;
2678     borderBlockStyle: string;
2679     borderBlockWidth: string;
2680     borderBottom: string;
2681     borderBottomColor: string;
2682     borderBottomLeftRadius: string;
2683     borderBottomRightRadius: string;
2684     borderBottomStyle: string;
2685     borderBottomWidth: string;
2686     borderCollapse: string;
2687     borderColor: string;
2688     borderEndEndRadius: string;
2689     borderEndStartRadius: string;
2690     borderImage: string;
2691     borderImageOutset: string;
2692     borderImageRepeat: string;
2693     borderImageSlice: string;
2694     borderImageSource: string;
2695     borderImageWidth: string;
2696     borderInline: string;
2697     borderInlineColor: string;
2698     borderInlineEnd: string;
2699     borderInlineEndColor: string;
2700     borderInlineEndStyle: string;
2701     borderInlineEndWidth: string;
2702     borderInlineStart: string;
2703     borderInlineStartColor: string;
2704     borderInlineStartStyle: string;
2705     borderInlineStartWidth: string;
2706     borderInlineStyle: string;
2707     borderInlineWidth: string;
2708     borderLeft: string;
2709     borderLeftColor: string;
2710     borderLeftStyle: string;
2711     borderLeftWidth: string;
2712     borderRadius: string;
2713     borderRight: string;
2714     borderRightColor: string;
2715     borderRightStyle: string;
2716     borderRightWidth: string;
2717     borderSpacing: string;
2718     borderStartEndRadius: string;
2719     borderStartStartRadius: string;
2720     borderStyle: string;
2721     borderTop: string;
2722     borderTopColor: string;
2723     borderTopLeftRadius: string;
2724     borderTopRightRadius: string;
2725     borderTopStyle: string;
2726     borderTopWidth: string;
2727     borderWidth: string;
2728     bottom: string;
2729     boxShadow: string;
2730     boxSizing: string;
2731     breakAfter: string;
2732     breakBefore: string;
2733     breakInside: string;
2734     captionSide: string;
2735     caretColor: string;
2736     clear: string;
2737     /** @deprecated */
2738     clip: string;
2739     clipPath: string;
2740     clipRule: string;
2741     color: string;
2742     colorInterpolation: string;
2743     colorInterpolationFilters: string;
2744     colorScheme: string;
2745     columnCount: string;
2746     columnFill: string;
2747     columnGap: string;
2748     columnRule: string;
2749     columnRuleColor: string;
2750     columnRuleStyle: string;
2751     columnRuleWidth: string;
2752     columnSpan: string;
2753     columnWidth: string;
2754     columns: string;
2755     contain: string;
2756     content: string;
2757     counterIncrement: string;
2758     counterReset: string;
2759     counterSet: string;
2760     cssFloat: string;
2761     cssText: string;
2762     cursor: string;
2763     direction: string;
2764     display: string;
2765     dominantBaseline: string;
2766     emptyCells: string;
2767     fill: string;
2768     fillOpacity: string;
2769     fillRule: string;
2770     filter: string;
2771     flex: string;
2772     flexBasis: string;
2773     flexDirection: string;
2774     flexFlow: string;
2775     flexGrow: string;
2776     flexShrink: string;
2777     flexWrap: string;
2778     float: string;
2779     floodColor: string;
2780     floodOpacity: string;
2781     font: string;
2782     fontFamily: string;
2783     fontFeatureSettings: string;
2784     fontKerning: string;
2785     fontOpticalSizing: string;
2786     fontSize: string;
2787     fontSizeAdjust: string;
2788     fontStretch: string;
2789     fontStyle: string;
2790     fontSynthesis: string;
2791     fontVariant: string;
2792     /** @deprecated */
2793     fontVariantAlternates: string;
2794     fontVariantCaps: string;
2795     fontVariantEastAsian: string;
2796     fontVariantLigatures: string;
2797     fontVariantNumeric: string;
2798     fontVariantPosition: string;
2799     fontVariationSettings: string;
2800     fontWeight: string;
2801     gap: string;
2802     grid: string;
2803     gridArea: string;
2804     gridAutoColumns: string;
2805     gridAutoFlow: string;
2806     gridAutoRows: string;
2807     gridColumn: string;
2808     gridColumnEnd: string;
2809     /** @deprecated This is a legacy alias of `columnGap`. */
2810     gridColumnGap: string;
2811     gridColumnStart: string;
2812     /** @deprecated This is a legacy alias of `gap`. */
2813     gridGap: string;
2814     gridRow: string;
2815     gridRowEnd: string;
2816     /** @deprecated This is a legacy alias of `rowGap`. */
2817     gridRowGap: string;
2818     gridRowStart: string;
2819     gridTemplate: string;
2820     gridTemplateAreas: string;
2821     gridTemplateColumns: string;
2822     gridTemplateRows: string;
2823     height: string;
2824     hyphens: string;
2825     /** @deprecated */
2826     imageOrientation: string;
2827     imageRendering: string;
2828     inlineSize: string;
2829     inset: string;
2830     insetBlock: string;
2831     insetBlockEnd: string;
2832     insetBlockStart: string;
2833     insetInline: string;
2834     insetInlineEnd: string;
2835     insetInlineStart: string;
2836     isolation: string;
2837     justifyContent: string;
2838     justifyItems: string;
2839     justifySelf: string;
2840     left: string;
2841     readonly length: number;
2842     letterSpacing: string;
2843     lightingColor: string;
2844     lineBreak: string;
2845     lineHeight: string;
2846     listStyle: string;
2847     listStyleImage: string;
2848     listStylePosition: string;
2849     listStyleType: string;
2850     margin: string;
2851     marginBlock: string;
2852     marginBlockEnd: string;
2853     marginBlockStart: string;
2854     marginBottom: string;
2855     marginInline: string;
2856     marginInlineEnd: string;
2857     marginInlineStart: string;
2858     marginLeft: string;
2859     marginRight: string;
2860     marginTop: string;
2861     marker: string;
2862     markerEnd: string;
2863     markerMid: string;
2864     markerStart: string;
2865     mask: string;
2866     maskType: string;
2867     maxBlockSize: string;
2868     maxHeight: string;
2869     maxInlineSize: string;
2870     maxWidth: string;
2871     minBlockSize: string;
2872     minHeight: string;
2873     minInlineSize: string;
2874     minWidth: string;
2875     mixBlendMode: string;
2876     objectFit: string;
2877     objectPosition: string;
2878     offset: string;
2879     offsetAnchor: string;
2880     offsetDistance: string;
2881     offsetPath: string;
2882     offsetRotate: string;
2883     opacity: string;
2884     order: string;
2885     orphans: string;
2886     outline: string;
2887     outlineColor: string;
2888     outlineOffset: string;
2889     outlineStyle: string;
2890     outlineWidth: string;
2891     overflow: string;
2892     overflowAnchor: string;
2893     overflowWrap: string;
2894     overflowX: string;
2895     overflowY: string;
2896     overscrollBehavior: string;
2897     overscrollBehaviorBlock: string;
2898     overscrollBehaviorInline: string;
2899     overscrollBehaviorX: string;
2900     overscrollBehaviorY: string;
2901     padding: string;
2902     paddingBlock: string;
2903     paddingBlockEnd: string;
2904     paddingBlockStart: string;
2905     paddingBottom: string;
2906     paddingInline: string;
2907     paddingInlineEnd: string;
2908     paddingInlineStart: string;
2909     paddingLeft: string;
2910     paddingRight: string;
2911     paddingTop: string;
2912     pageBreakAfter: string;
2913     pageBreakBefore: string;
2914     pageBreakInside: string;
2915     paintOrder: string;
2916     readonly parentRule: CSSRule | null;
2917     perspective: string;
2918     perspectiveOrigin: string;
2919     placeContent: string;
2920     placeItems: string;
2921     placeSelf: string;
2922     pointerEvents: string;
2923     position: string;
2924     quotes: string;
2925     resize: string;
2926     right: string;
2927     rotate: string;
2928     rowGap: string;
2929     rubyPosition: string;
2930     scale: string;
2931     scrollBehavior: string;
2932     scrollMargin: string;
2933     scrollMarginBlock: string;
2934     scrollMarginBlockEnd: string;
2935     scrollMarginBlockStart: string;
2936     scrollMarginBottom: string;
2937     scrollMarginInline: string;
2938     scrollMarginInlineEnd: string;
2939     scrollMarginInlineStart: string;
2940     scrollMarginLeft: string;
2941     scrollMarginRight: string;
2942     scrollMarginTop: string;
2943     scrollPadding: string;
2944     scrollPaddingBlock: string;
2945     scrollPaddingBlockEnd: string;
2946     scrollPaddingBlockStart: string;
2947     scrollPaddingBottom: string;
2948     scrollPaddingInline: string;
2949     scrollPaddingInlineEnd: string;
2950     scrollPaddingInlineStart: string;
2951     scrollPaddingLeft: string;
2952     scrollPaddingRight: string;
2953     scrollPaddingTop: string;
2954     scrollSnapAlign: string;
2955     scrollSnapStop: string;
2956     scrollSnapType: string;
2957     shapeImageThreshold: string;
2958     shapeMargin: string;
2959     shapeOutside: string;
2960     shapeRendering: string;
2961     stopColor: string;
2962     stopOpacity: string;
2963     stroke: string;
2964     strokeDasharray: string;
2965     strokeDashoffset: string;
2966     strokeLinecap: string;
2967     strokeLinejoin: string;
2968     strokeMiterlimit: string;
2969     strokeOpacity: string;
2970     strokeWidth: string;
2971     tabSize: string;
2972     tableLayout: string;
2973     textAlign: string;
2974     textAlignLast: string;
2975     textAnchor: string;
2976     textCombineUpright: string;
2977     textDecoration: string;
2978     textDecorationColor: string;
2979     textDecorationLine: string;
2980     textDecorationSkipInk: string;
2981     textDecorationStyle: string;
2982     textDecorationThickness: string;
2983     textEmphasis: string;
2984     textEmphasisColor: string;
2985     textEmphasisPosition: string;
2986     textEmphasisStyle: string;
2987     textIndent: string;
2988     textOrientation: string;
2989     textOverflow: string;
2990     textRendering: string;
2991     textShadow: string;
2992     textTransform: string;
2993     textUnderlineOffset: string;
2994     textUnderlinePosition: string;
2995     top: string;
2996     touchAction: string;
2997     transform: string;
2998     transformBox: string;
2999     transformOrigin: string;
3000     transformStyle: string;
3001     transition: string;
3002     transitionDelay: string;
3003     transitionDuration: string;
3004     transitionProperty: string;
3005     transitionTimingFunction: string;
3006     translate: string;
3007     unicodeBidi: string;
3008     userSelect: string;
3009     verticalAlign: string;
3010     visibility: string;
3011     /** @deprecated This is a legacy alias of `alignContent`. */
3012     webkitAlignContent: string;
3013     /** @deprecated This is a legacy alias of `alignItems`. */
3014     webkitAlignItems: string;
3015     /** @deprecated This is a legacy alias of `alignSelf`. */
3016     webkitAlignSelf: string;
3017     /** @deprecated This is a legacy alias of `animation`. */
3018     webkitAnimation: string;
3019     /** @deprecated This is a legacy alias of `animationDelay`. */
3020     webkitAnimationDelay: string;
3021     /** @deprecated This is a legacy alias of `animationDirection`. */
3022     webkitAnimationDirection: string;
3023     /** @deprecated This is a legacy alias of `animationDuration`. */
3024     webkitAnimationDuration: string;
3025     /** @deprecated This is a legacy alias of `animationFillMode`. */
3026     webkitAnimationFillMode: string;
3027     /** @deprecated This is a legacy alias of `animationIterationCount`. */
3028     webkitAnimationIterationCount: string;
3029     /** @deprecated This is a legacy alias of `animationName`. */
3030     webkitAnimationName: string;
3031     /** @deprecated This is a legacy alias of `animationPlayState`. */
3032     webkitAnimationPlayState: string;
3033     /** @deprecated This is a legacy alias of `animationTimingFunction`. */
3034     webkitAnimationTimingFunction: string;
3035     /** @deprecated This is a legacy alias of `appearance`. */
3036     webkitAppearance: string;
3037     /** @deprecated This is a legacy alias of `backfaceVisibility`. */
3038     webkitBackfaceVisibility: string;
3039     /** @deprecated This is a legacy alias of `backgroundClip`. */
3040     webkitBackgroundClip: string;
3041     /** @deprecated This is a legacy alias of `backgroundOrigin`. */
3042     webkitBackgroundOrigin: string;
3043     /** @deprecated This is a legacy alias of `backgroundSize`. */
3044     webkitBackgroundSize: string;
3045     /** @deprecated This is a legacy alias of `borderBottomLeftRadius`. */
3046     webkitBorderBottomLeftRadius: string;
3047     /** @deprecated This is a legacy alias of `borderBottomRightRadius`. */
3048     webkitBorderBottomRightRadius: string;
3049     /** @deprecated This is a legacy alias of `borderRadius`. */
3050     webkitBorderRadius: string;
3051     /** @deprecated This is a legacy alias of `borderTopLeftRadius`. */
3052     webkitBorderTopLeftRadius: string;
3053     /** @deprecated This is a legacy alias of `borderTopRightRadius`. */
3054     webkitBorderTopRightRadius: string;
3055     /** @deprecated This is a legacy alias of `boxAlign`. */
3056     webkitBoxAlign: string;
3057     /** @deprecated This is a legacy alias of `boxFlex`. */
3058     webkitBoxFlex: string;
3059     /** @deprecated This is a legacy alias of `boxOrdinalGroup`. */
3060     webkitBoxOrdinalGroup: string;
3061     /** @deprecated This is a legacy alias of `boxOrient`. */
3062     webkitBoxOrient: string;
3063     /** @deprecated This is a legacy alias of `boxPack`. */
3064     webkitBoxPack: string;
3065     /** @deprecated This is a legacy alias of `boxShadow`. */
3066     webkitBoxShadow: string;
3067     /** @deprecated This is a legacy alias of `boxSizing`. */
3068     webkitBoxSizing: string;
3069     /** @deprecated This is a legacy alias of `filter`. */
3070     webkitFilter: string;
3071     /** @deprecated This is a legacy alias of `flex`. */
3072     webkitFlex: string;
3073     /** @deprecated This is a legacy alias of `flexBasis`. */
3074     webkitFlexBasis: string;
3075     /** @deprecated This is a legacy alias of `flexDirection`. */
3076     webkitFlexDirection: string;
3077     /** @deprecated This is a legacy alias of `flexFlow`. */
3078     webkitFlexFlow: string;
3079     /** @deprecated This is a legacy alias of `flexGrow`. */
3080     webkitFlexGrow: string;
3081     /** @deprecated This is a legacy alias of `flexShrink`. */
3082     webkitFlexShrink: string;
3083     /** @deprecated This is a legacy alias of `flexWrap`. */
3084     webkitFlexWrap: string;
3085     /** @deprecated This is a legacy alias of `justifyContent`. */
3086     webkitJustifyContent: string;
3087     webkitLineClamp: string;
3088     /** @deprecated This is a legacy alias of `mask`. */
3089     webkitMask: string;
3090     /** @deprecated This is a legacy alias of `maskBorder`. */
3091     webkitMaskBoxImage: string;
3092     /** @deprecated This is a legacy alias of `maskBorderOutset`. */
3093     webkitMaskBoxImageOutset: string;
3094     /** @deprecated This is a legacy alias of `maskBorderRepeat`. */
3095     webkitMaskBoxImageRepeat: string;
3096     /** @deprecated This is a legacy alias of `maskBorderSlice`. */
3097     webkitMaskBoxImageSlice: string;
3098     /** @deprecated This is a legacy alias of `maskBorderSource`. */
3099     webkitMaskBoxImageSource: string;
3100     /** @deprecated This is a legacy alias of `maskBorderWidth`. */
3101     webkitMaskBoxImageWidth: string;
3102     /** @deprecated This is a legacy alias of `maskClip`. */
3103     webkitMaskClip: string;
3104     webkitMaskComposite: string;
3105     /** @deprecated This is a legacy alias of `maskImage`. */
3106     webkitMaskImage: string;
3107     /** @deprecated This is a legacy alias of `maskOrigin`. */
3108     webkitMaskOrigin: string;
3109     /** @deprecated This is a legacy alias of `maskPosition`. */
3110     webkitMaskPosition: string;
3111     /** @deprecated This is a legacy alias of `maskRepeat`. */
3112     webkitMaskRepeat: string;
3113     /** @deprecated This is a legacy alias of `maskSize`. */
3114     webkitMaskSize: string;
3115     /** @deprecated This is a legacy alias of `order`. */
3116     webkitOrder: string;
3117     /** @deprecated This is a legacy alias of `perspective`. */
3118     webkitPerspective: string;
3119     /** @deprecated This is a legacy alias of `perspectiveOrigin`. */
3120     webkitPerspectiveOrigin: string;
3121     webkitTextFillColor: string;
3122     webkitTextStroke: string;
3123     webkitTextStrokeColor: string;
3124     webkitTextStrokeWidth: string;
3125     /** @deprecated This is a legacy alias of `transform`. */
3126     webkitTransform: string;
3127     /** @deprecated This is a legacy alias of `transformOrigin`. */
3128     webkitTransformOrigin: string;
3129     /** @deprecated This is a legacy alias of `transformStyle`. */
3130     webkitTransformStyle: string;
3131     /** @deprecated This is a legacy alias of `transition`. */
3132     webkitTransition: string;
3133     /** @deprecated This is a legacy alias of `transitionDelay`. */
3134     webkitTransitionDelay: string;
3135     /** @deprecated This is a legacy alias of `transitionDuration`. */
3136     webkitTransitionDuration: string;
3137     /** @deprecated This is a legacy alias of `transitionProperty`. */
3138     webkitTransitionProperty: string;
3139     /** @deprecated This is a legacy alias of `transitionTimingFunction`. */
3140     webkitTransitionTimingFunction: string;
3141     /** @deprecated This is a legacy alias of `userSelect`. */
3142     webkitUserSelect: string;
3143     whiteSpace: string;
3144     widows: string;
3145     width: string;
3146     willChange: string;
3147     wordBreak: string;
3148     wordSpacing: string;
3149     /** @deprecated */
3150     wordWrap: string;
3151     writingMode: string;
3152     zIndex: string;
3153     getPropertyPriority(property: string): string;
3154     getPropertyValue(property: string): string;
3155     item(index: number): string;
3156     removeProperty(property: string): string;
3157     setProperty(property: string, value: string | null, priority?: string): void;
3158     [index: number]: string;
3159 }
3160
3161 declare var CSSStyleDeclaration: {
3162     prototype: CSSStyleDeclaration;
3163     new(): CSSStyleDeclaration;
3164 };
3165
3166 /** CSSStyleRule represents a single CSS style rule. It implements the CSSRule interface with a type value of 1 (CSSRule.STYLE_RULE). */
3167 interface CSSStyleRule extends CSSRule {
3168     selectorText: string;
3169     readonly style: CSSStyleDeclaration;
3170 }
3171
3172 declare var CSSStyleRule: {
3173     prototype: CSSStyleRule;
3174     new(): CSSStyleRule;
3175 };
3176
3177 /** A single CSS style sheet. It inherits properties and methods from its parent, StyleSheet. */
3178 interface CSSStyleSheet extends StyleSheet {
3179     readonly cssRules: CSSRuleList;
3180     readonly ownerRule: CSSRule | null;
3181     /** @deprecated */
3182     readonly rules: CSSRuleList;
3183     /** @deprecated */
3184     addRule(selector?: string, style?: string, index?: number): number;
3185     deleteRule(index: number): void;
3186     insertRule(rule: string, index?: number): number;
3187     /** @deprecated */
3188     removeRule(index?: number): void;
3189 }
3190
3191 declare var CSSStyleSheet: {
3192     prototype: CSSStyleSheet;
3193     new(options?: CSSStyleSheetInit): CSSStyleSheet;
3194 };
3195
3196 /** 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). */
3197 interface CSSSupportsRule extends CSSConditionRule {
3198 }
3199
3200 declare var CSSSupportsRule: {
3201     prototype: CSSSupportsRule;
3202     new(): CSSSupportsRule;
3203 };
3204
3205 interface CSSTransition extends Animation {
3206     readonly transitionProperty: string;
3207     addEventListener<K extends keyof AnimationEventMap>(type: K, listener: (this: CSSTransition, ev: AnimationEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
3208     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
3209     removeEventListener<K extends keyof AnimationEventMap>(type: K, listener: (this: CSSTransition, ev: AnimationEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
3210     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
3211 }
3212
3213 declare var CSSTransition: {
3214     prototype: CSSTransition;
3215     new(): CSSTransition;
3216 };
3217
3218 /**
3219  * 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.
3220  * Available only in secure contexts.
3221  */
3222 interface Cache {
3223     add(request: RequestInfo): Promise<void>;
3224     addAll(requests: RequestInfo[]): Promise<void>;
3225     delete(request: RequestInfo, options?: CacheQueryOptions): Promise<boolean>;
3226     keys(request?: RequestInfo, options?: CacheQueryOptions): Promise<ReadonlyArray<Request>>;
3227     match(request: RequestInfo, options?: CacheQueryOptions): Promise<Response | undefined>;
3228     matchAll(request?: RequestInfo, options?: CacheQueryOptions): Promise<ReadonlyArray<Response>>;
3229     put(request: RequestInfo, response: Response): Promise<void>;
3230 }
3231
3232 declare var Cache: {
3233     prototype: Cache;
3234     new(): Cache;
3235 };
3236
3237 /**
3238  * The storage for Cache objects.
3239  * Available only in secure contexts.
3240  */
3241 interface CacheStorage {
3242     delete(cacheName: string): Promise<boolean>;
3243     has(cacheName: string): Promise<boolean>;
3244     keys(): Promise<string[]>;
3245     match(request: RequestInfo, options?: MultiCacheQueryOptions): Promise<Response | undefined>;
3246     open(cacheName: string): Promise<Cache>;
3247 }
3248
3249 declare var CacheStorage: {
3250     prototype: CacheStorage;
3251     new(): CacheStorage;
3252 };
3253
3254 interface CanvasCompositing {
3255     globalAlpha: number;
3256     globalCompositeOperation: string;
3257 }
3258
3259 interface CanvasDrawImage {
3260     drawImage(image: CanvasImageSource, dx: number, dy: number): void;
3261     drawImage(image: CanvasImageSource, dx: number, dy: number, dw: number, dh: number): void;
3262     drawImage(image: CanvasImageSource, sx: number, sy: number, sw: number, sh: number, dx: number, dy: number, dw: number, dh: number): void;
3263 }
3264
3265 interface CanvasDrawPath {
3266     beginPath(): void;
3267     clip(fillRule?: CanvasFillRule): void;
3268     clip(path: Path2D, fillRule?: CanvasFillRule): void;
3269     fill(fillRule?: CanvasFillRule): void;
3270     fill(path: Path2D, fillRule?: CanvasFillRule): void;
3271     isPointInPath(x: number, y: number, fillRule?: CanvasFillRule): boolean;
3272     isPointInPath(path: Path2D, x: number, y: number, fillRule?: CanvasFillRule): boolean;
3273     isPointInStroke(x: number, y: number): boolean;
3274     isPointInStroke(path: Path2D, x: number, y: number): boolean;
3275     stroke(): void;
3276     stroke(path: Path2D): void;
3277 }
3278
3279 interface CanvasFillStrokeStyles {
3280     fillStyle: string | CanvasGradient | CanvasPattern;
3281     strokeStyle: string | CanvasGradient | CanvasPattern;
3282     createLinearGradient(x0: number, y0: number, x1: number, y1: number): CanvasGradient;
3283     createPattern(image: CanvasImageSource, repetition: string | null): CanvasPattern | null;
3284     createRadialGradient(x0: number, y0: number, r0: number, x1: number, y1: number, r1: number): CanvasGradient;
3285 }
3286
3287 interface CanvasFilters {
3288     filter: string;
3289 }
3290
3291 /** An opaque object describing a gradient. It is returned by the methods CanvasRenderingContext2D.createLinearGradient() or CanvasRenderingContext2D.createRadialGradient(). */
3292 interface CanvasGradient {
3293     /**
3294      * 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.
3295      *
3296      * Throws an "IndexSizeError" DOMException if the offset is out of range. Throws a "SyntaxError" DOMException if the color cannot be parsed.
3297      */
3298     addColorStop(offset: number, color: string): void;
3299 }
3300
3301 declare var CanvasGradient: {
3302     prototype: CanvasGradient;
3303     new(): CanvasGradient;
3304 };
3305
3306 interface CanvasImageData {
3307     createImageData(sw: number, sh: number, settings?: ImageDataSettings): ImageData;
3308     createImageData(imagedata: ImageData): ImageData;
3309     getImageData(sx: number, sy: number, sw: number, sh: number, settings?: ImageDataSettings): ImageData;
3310     putImageData(imagedata: ImageData, dx: number, dy: number): void;
3311     putImageData(imagedata: ImageData, dx: number, dy: number, dirtyX: number, dirtyY: number, dirtyWidth: number, dirtyHeight: number): void;
3312 }
3313
3314 interface CanvasImageSmoothing {
3315     imageSmoothingEnabled: boolean;
3316     imageSmoothingQuality: ImageSmoothingQuality;
3317 }
3318
3319 interface CanvasPath {
3320     arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, counterclockwise?: boolean): void;
3321     arcTo(x1: number, y1: number, x2: number, y2: number, radius: number): void;
3322     bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number): void;
3323     closePath(): void;
3324     ellipse(x: number, y: number, radiusX: number, radiusY: number, rotation: number, startAngle: number, endAngle: number, counterclockwise?: boolean): void;
3325     lineTo(x: number, y: number): void;
3326     moveTo(x: number, y: number): void;
3327     quadraticCurveTo(cpx: number, cpy: number, x: number, y: number): void;
3328     rect(x: number, y: number, w: number, h: number): void;
3329 }
3330
3331 interface CanvasPathDrawingStyles {
3332     lineCap: CanvasLineCap;
3333     lineDashOffset: number;
3334     lineJoin: CanvasLineJoin;
3335     lineWidth: number;
3336     miterLimit: number;
3337     getLineDash(): number[];
3338     setLineDash(segments: number[]): void;
3339 }
3340
3341 /** An opaque object describing a pattern, based on an image, a canvas, or a video, created by the CanvasRenderingContext2D.createPattern() method. */
3342 interface CanvasPattern {
3343     /** Sets the transformation matrix that will be used when rendering the pattern during a fill or stroke painting operation. */
3344     setTransform(transform?: DOMMatrix2DInit): void;
3345 }
3346
3347 declare var CanvasPattern: {
3348     prototype: CanvasPattern;
3349     new(): CanvasPattern;
3350 };
3351
3352 interface CanvasRect {
3353     clearRect(x: number, y: number, w: number, h: number): void;
3354     fillRect(x: number, y: number, w: number, h: number): void;
3355     strokeRect(x: number, y: number, w: number, h: number): void;
3356 }
3357
3358 /** 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. */
3359 interface CanvasRenderingContext2D extends CanvasCompositing, CanvasDrawImage, CanvasDrawPath, CanvasFillStrokeStyles, CanvasFilters, CanvasImageData, CanvasImageSmoothing, CanvasPath, CanvasPathDrawingStyles, CanvasRect, CanvasShadowStyles, CanvasState, CanvasText, CanvasTextDrawingStyles, CanvasTransform, CanvasUserInterface {
3360     readonly canvas: HTMLCanvasElement;
3361     getContextAttributes(): CanvasRenderingContext2DSettings;
3362 }
3363
3364 declare var CanvasRenderingContext2D: {
3365     prototype: CanvasRenderingContext2D;
3366     new(): CanvasRenderingContext2D;
3367 };
3368
3369 interface CanvasShadowStyles {
3370     shadowBlur: number;
3371     shadowColor: string;
3372     shadowOffsetX: number;
3373     shadowOffsetY: number;
3374 }
3375
3376 interface CanvasState {
3377     restore(): void;
3378     save(): void;
3379 }
3380
3381 interface CanvasText {
3382     fillText(text: string, x: number, y: number, maxWidth?: number): void;
3383     measureText(text: string): TextMetrics;
3384     strokeText(text: string, x: number, y: number, maxWidth?: number): void;
3385 }
3386
3387 interface CanvasTextDrawingStyles {
3388     direction: CanvasDirection;
3389     font: string;
3390     textAlign: CanvasTextAlign;
3391     textBaseline: CanvasTextBaseline;
3392 }
3393
3394 interface CanvasTransform {
3395     getTransform(): DOMMatrix;
3396     resetTransform(): void;
3397     rotate(angle: number): void;
3398     scale(x: number, y: number): void;
3399     setTransform(a: number, b: number, c: number, d: number, e: number, f: number): void;
3400     setTransform(transform?: DOMMatrix2DInit): void;
3401     transform(a: number, b: number, c: number, d: number, e: number, f: number): void;
3402     translate(x: number, y: number): void;
3403 }
3404
3405 interface CanvasUserInterface {
3406     drawFocusIfNeeded(element: Element): void;
3407     drawFocusIfNeeded(path: Path2D, element: Element): void;
3408 }
3409
3410 /** 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. */
3411 interface ChannelMergerNode extends AudioNode {
3412 }
3413
3414 declare var ChannelMergerNode: {
3415     prototype: ChannelMergerNode;
3416     new(context: BaseAudioContext, options?: ChannelMergerOptions): ChannelMergerNode;
3417 };
3418
3419 /** 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. */
3420 interface ChannelSplitterNode extends AudioNode {
3421 }
3422
3423 declare var ChannelSplitterNode: {
3424     prototype: ChannelSplitterNode;
3425     new(context: BaseAudioContext, options?: ChannelSplitterOptions): ChannelSplitterNode;
3426 };
3427
3428 /** 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. */
3429 interface CharacterData extends Node, ChildNode, NonDocumentTypeChildNode {
3430     data: string;
3431     readonly length: number;
3432     readonly ownerDocument: Document;
3433     appendData(data: string): void;
3434     deleteData(offset: number, count: number): void;
3435     insertData(offset: number, data: string): void;
3436     replaceData(offset: number, count: number, data: string): void;
3437     substringData(offset: number, count: number): string;
3438 }
3439
3440 declare var CharacterData: {
3441     prototype: CharacterData;
3442     new(): CharacterData;
3443 };
3444
3445 interface ChildNode extends Node {
3446     /**
3447      * Inserts nodes just after node, while replacing strings in nodes with equivalent Text nodes.
3448      *
3449      * Throws a "HierarchyRequestError" DOMException if the constraints of the node tree are violated.
3450      */
3451     after(...nodes: (Node | string)[]): void;
3452     /**
3453      * Inserts nodes just before node, while replacing strings in nodes with equivalent Text nodes.
3454      *
3455      * Throws a "HierarchyRequestError" DOMException if the constraints of the node tree are violated.
3456      */
3457     before(...nodes: (Node | string)[]): void;
3458     /** Removes node. */
3459     remove(): void;
3460     /**
3461      * Replaces node with nodes, while replacing strings in nodes with equivalent Text nodes.
3462      *
3463      * Throws a "HierarchyRequestError" DOMException if the constraints of the node tree are violated.
3464      */
3465     replaceWith(...nodes: (Node | string)[]): void;
3466 }
3467
3468 /** @deprecated */
3469 interface ClientRect extends DOMRect {
3470 }
3471
3472 /** Available only in secure contexts. */
3473 interface Clipboard extends EventTarget {
3474     read(): Promise<ClipboardItems>;
3475     readText(): Promise<string>;
3476     write(data: ClipboardItems): Promise<void>;
3477     writeText(data: string): Promise<void>;
3478 }
3479
3480 declare var Clipboard: {
3481     prototype: Clipboard;
3482     new(): Clipboard;
3483 };
3484
3485 /** Events providing information related to modification of the clipboard, that is cut, copy, and paste events. */
3486 interface ClipboardEvent extends Event {
3487     readonly clipboardData: DataTransfer | null;
3488 }
3489
3490 declare var ClipboardEvent: {
3491     prototype: ClipboardEvent;
3492     new(type: string, eventInitDict?: ClipboardEventInit): ClipboardEvent;
3493 };
3494
3495 interface ClipboardItem {
3496     readonly types: ReadonlyArray<string>;
3497     getType(type: string): Promise<Blob>;
3498 }
3499
3500 declare var ClipboardItem: {
3501     prototype: ClipboardItem;
3502     new(items: Record<string, ClipboardItemDataType | PromiseLike<ClipboardItemDataType>>, options?: ClipboardItemOptions): ClipboardItem;
3503 };
3504
3505 /** 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. */
3506 interface CloseEvent extends Event {
3507     /** Returns the WebSocket connection close code provided by the server. */
3508     readonly code: number;
3509     /** Returns the WebSocket connection close reason provided by the server. */
3510     readonly reason: string;
3511     /** Returns true if the connection closed cleanly; false otherwise. */
3512     readonly wasClean: boolean;
3513 }
3514
3515 declare var CloseEvent: {
3516     prototype: CloseEvent;
3517     new(type: string, eventInitDict?: CloseEventInit): CloseEvent;
3518 };
3519
3520 /** Textual notations within markup; although it is generally not visually shown, such comments are available to be read in the source view. */
3521 interface Comment extends CharacterData {
3522 }
3523
3524 declare var Comment: {
3525     prototype: Comment;
3526     new(data?: string): Comment;
3527 };
3528
3529 /** The DOM CompositionEvent represents events that occur due to the user indirectly entering text. */
3530 interface CompositionEvent extends UIEvent {
3531     readonly data: string;
3532     /** @deprecated */
3533     initCompositionEvent(typeArg: string, bubblesArg?: boolean, cancelableArg?: boolean, viewArg?: WindowProxy | null, dataArg?: string): void;
3534 }
3535
3536 declare var CompositionEvent: {
3537     prototype: CompositionEvent;
3538     new(type: string, eventInitDict?: CompositionEventInit): CompositionEvent;
3539 };
3540
3541 interface ConstantSourceNode extends AudioScheduledSourceNode {
3542     readonly offset: AudioParam;
3543     addEventListener<K extends keyof AudioScheduledSourceNodeEventMap>(type: K, listener: (this: ConstantSourceNode, ev: AudioScheduledSourceNodeEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
3544     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
3545     removeEventListener<K extends keyof AudioScheduledSourceNodeEventMap>(type: K, listener: (this: ConstantSourceNode, ev: AudioScheduledSourceNodeEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
3546     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
3547 }
3548
3549 declare var ConstantSourceNode: {
3550     prototype: ConstantSourceNode;
3551     new(context: BaseAudioContext, options?: ConstantSourceOptions): ConstantSourceNode;
3552 };
3553
3554 /** 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. */
3555 interface ConvolverNode extends AudioNode {
3556     buffer: AudioBuffer | null;
3557     normalize: boolean;
3558 }
3559
3560 declare var ConvolverNode: {
3561     prototype: ConvolverNode;
3562     new(context: BaseAudioContext, options?: ConvolverOptions): ConvolverNode;
3563 };
3564
3565 /** This Streams API interface provides a built-in byte length queuing strategy that can be used when constructing streams. */
3566 interface CountQueuingStrategy extends QueuingStrategy {
3567     readonly highWaterMark: number;
3568     readonly size: QueuingStrategySize;
3569 }
3570
3571 declare var CountQueuingStrategy: {
3572     prototype: CountQueuingStrategy;
3573     new(init: QueuingStrategyInit): CountQueuingStrategy;
3574 };
3575
3576 /** Available only in secure contexts. */
3577 interface Credential {
3578     readonly id: string;
3579     readonly type: string;
3580 }
3581
3582 declare var Credential: {
3583     prototype: Credential;
3584     new(): Credential;
3585 };
3586
3587 /** Available only in secure contexts. */
3588 interface CredentialsContainer {
3589     create(options?: CredentialCreationOptions): Promise<Credential | null>;
3590     get(options?: CredentialRequestOptions): Promise<Credential | null>;
3591     preventSilentAccess(): Promise<void>;
3592     store(credential: Credential): Promise<Credential>;
3593 }
3594
3595 declare var CredentialsContainer: {
3596     prototype: CredentialsContainer;
3597     new(): CredentialsContainer;
3598 };
3599
3600 /** Basic cryptography features available in the current context. It allows access to a cryptographically strong random number generator and to cryptographic primitives. */
3601 interface Crypto {
3602     /** Available only in secure contexts. */
3603     readonly subtle: SubtleCrypto;
3604     getRandomValues<T extends ArrayBufferView | null>(array: T): T;
3605 }
3606
3607 declare var Crypto: {
3608     prototype: Crypto;
3609     new(): Crypto;
3610 };
3611
3612 /**
3613  * The CryptoKey dictionary of the Web Crypto API represents a cryptographic key.
3614  * Available only in secure contexts.
3615  */
3616 interface CryptoKey {
3617     readonly algorithm: KeyAlgorithm;
3618     readonly extractable: boolean;
3619     readonly type: KeyType;
3620     readonly usages: KeyUsage[];
3621 }
3622
3623 declare var CryptoKey: {
3624     prototype: CryptoKey;
3625     new(): CryptoKey;
3626 };
3627
3628 interface CustomElementRegistry {
3629     define(name: string, constructor: CustomElementConstructor, options?: ElementDefinitionOptions): void;
3630     get(name: string): CustomElementConstructor | undefined;
3631     upgrade(root: Node): void;
3632     whenDefined(name: string): Promise<CustomElementConstructor>;
3633 }
3634
3635 declare var CustomElementRegistry: {
3636     prototype: CustomElementRegistry;
3637     new(): CustomElementRegistry;
3638 };
3639
3640 interface CustomEvent<T = any> extends Event {
3641     /** Returns any custom data event was created with. Typically used for synthetic events. */
3642     readonly detail: T;
3643     /** @deprecated */
3644     initCustomEvent(type: string, bubbles?: boolean, cancelable?: boolean, detail?: T): void;
3645 }
3646
3647 declare var CustomEvent: {
3648     prototype: CustomEvent;
3649     new<T>(type: string, eventInitDict?: CustomEventInit<T>): CustomEvent<T>;
3650 };
3651
3652 /** An abnormal event (called an exception) which occurs as a result of calling a method or accessing a property of a web API. */
3653 interface DOMException extends Error {
3654     readonly code: number;
3655     readonly message: string;
3656     readonly name: string;
3657     readonly ABORT_ERR: number;
3658     readonly DATA_CLONE_ERR: number;
3659     readonly DOMSTRING_SIZE_ERR: number;
3660     readonly HIERARCHY_REQUEST_ERR: number;
3661     readonly INDEX_SIZE_ERR: number;
3662     readonly INUSE_ATTRIBUTE_ERR: number;
3663     readonly INVALID_ACCESS_ERR: number;
3664     readonly INVALID_CHARACTER_ERR: number;
3665     readonly INVALID_MODIFICATION_ERR: number;
3666     readonly INVALID_NODE_TYPE_ERR: number;
3667     readonly INVALID_STATE_ERR: number;
3668     readonly NAMESPACE_ERR: number;
3669     readonly NETWORK_ERR: number;
3670     readonly NOT_FOUND_ERR: number;
3671     readonly NOT_SUPPORTED_ERR: number;
3672     readonly NO_DATA_ALLOWED_ERR: number;
3673     readonly NO_MODIFICATION_ALLOWED_ERR: number;
3674     readonly QUOTA_EXCEEDED_ERR: number;
3675     readonly SECURITY_ERR: number;
3676     readonly SYNTAX_ERR: number;
3677     readonly TIMEOUT_ERR: number;
3678     readonly TYPE_MISMATCH_ERR: number;
3679     readonly URL_MISMATCH_ERR: number;
3680     readonly VALIDATION_ERR: number;
3681     readonly WRONG_DOCUMENT_ERR: number;
3682 }
3683
3684 declare var DOMException: {
3685     prototype: DOMException;
3686     new(message?: string, name?: string): DOMException;
3687     readonly ABORT_ERR: number;
3688     readonly DATA_CLONE_ERR: number;
3689     readonly DOMSTRING_SIZE_ERR: number;
3690     readonly HIERARCHY_REQUEST_ERR: number;
3691     readonly INDEX_SIZE_ERR: number;
3692     readonly INUSE_ATTRIBUTE_ERR: number;
3693     readonly INVALID_ACCESS_ERR: number;
3694     readonly INVALID_CHARACTER_ERR: number;
3695     readonly INVALID_MODIFICATION_ERR: number;
3696     readonly INVALID_NODE_TYPE_ERR: number;
3697     readonly INVALID_STATE_ERR: number;
3698     readonly NAMESPACE_ERR: number;
3699     readonly NETWORK_ERR: number;
3700     readonly NOT_FOUND_ERR: number;
3701     readonly NOT_SUPPORTED_ERR: number;
3702     readonly NO_DATA_ALLOWED_ERR: number;
3703     readonly NO_MODIFICATION_ALLOWED_ERR: number;
3704     readonly QUOTA_EXCEEDED_ERR: number;
3705     readonly SECURITY_ERR: number;
3706     readonly SYNTAX_ERR: number;
3707     readonly TIMEOUT_ERR: number;
3708     readonly TYPE_MISMATCH_ERR: number;
3709     readonly URL_MISMATCH_ERR: number;
3710     readonly VALIDATION_ERR: number;
3711     readonly WRONG_DOCUMENT_ERR: number;
3712 };
3713
3714 /** An object providing methods which are not dependent on any particular document. Such an object is returned by the Document.implementation property. */
3715 interface DOMImplementation {
3716     createDocument(namespace: string | null, qualifiedName: string | null, doctype?: DocumentType | null): XMLDocument;
3717     createDocumentType(qualifiedName: string, publicId: string, systemId: string): DocumentType;
3718     createHTMLDocument(title?: string): Document;
3719     /** @deprecated */
3720     hasFeature(...args: any[]): true;
3721 }
3722
3723 declare var DOMImplementation: {
3724     prototype: DOMImplementation;
3725     new(): DOMImplementation;
3726 };
3727
3728 interface DOMMatrix extends DOMMatrixReadOnly {
3729     a: number;
3730     b: number;
3731     c: number;
3732     d: number;
3733     e: number;
3734     f: number;
3735     m11: number;
3736     m12: number;
3737     m13: number;
3738     m14: number;
3739     m21: number;
3740     m22: number;
3741     m23: number;
3742     m24: number;
3743     m31: number;
3744     m32: number;
3745     m33: number;
3746     m34: number;
3747     m41: number;
3748     m42: number;
3749     m43: number;
3750     m44: number;
3751     invertSelf(): DOMMatrix;
3752     multiplySelf(other?: DOMMatrixInit): DOMMatrix;
3753     preMultiplySelf(other?: DOMMatrixInit): DOMMatrix;
3754     rotateAxisAngleSelf(x?: number, y?: number, z?: number, angle?: number): DOMMatrix;
3755     rotateFromVectorSelf(x?: number, y?: number): DOMMatrix;
3756     rotateSelf(rotX?: number, rotY?: number, rotZ?: number): DOMMatrix;
3757     scale3dSelf(scale?: number, originX?: number, originY?: number, originZ?: number): DOMMatrix;
3758     scaleSelf(scaleX?: number, scaleY?: number, scaleZ?: number, originX?: number, originY?: number, originZ?: number): DOMMatrix;
3759     setMatrixValue(transformList: string): DOMMatrix;
3760     skewXSelf(sx?: number): DOMMatrix;
3761     skewYSelf(sy?: number): DOMMatrix;
3762     translateSelf(tx?: number, ty?: number, tz?: number): DOMMatrix;
3763 }
3764
3765 declare var DOMMatrix: {
3766     prototype: DOMMatrix;
3767     new(init?: string | number[]): DOMMatrix;
3768     fromFloat32Array(array32: Float32Array): DOMMatrix;
3769     fromFloat64Array(array64: Float64Array): DOMMatrix;
3770     fromMatrix(other?: DOMMatrixInit): DOMMatrix;
3771 };
3772
3773 type SVGMatrix = DOMMatrix;
3774 declare var SVGMatrix: typeof DOMMatrix;
3775
3776 type WebKitCSSMatrix = DOMMatrix;
3777 declare var WebKitCSSMatrix: typeof DOMMatrix;
3778
3779 interface DOMMatrixReadOnly {
3780     readonly a: number;
3781     readonly b: number;
3782     readonly c: number;
3783     readonly d: number;
3784     readonly e: number;
3785     readonly f: number;
3786     readonly is2D: boolean;
3787     readonly isIdentity: boolean;
3788     readonly m11: number;
3789     readonly m12: number;
3790     readonly m13: number;
3791     readonly m14: number;
3792     readonly m21: number;
3793     readonly m22: number;
3794     readonly m23: number;
3795     readonly m24: number;
3796     readonly m31: number;
3797     readonly m32: number;
3798     readonly m33: number;
3799     readonly m34: number;
3800     readonly m41: number;
3801     readonly m42: number;
3802     readonly m43: number;
3803     readonly m44: number;
3804     flipX(): DOMMatrix;
3805     flipY(): DOMMatrix;
3806     inverse(): DOMMatrix;
3807     multiply(other?: DOMMatrixInit): DOMMatrix;
3808     rotate(rotX?: number, rotY?: number, rotZ?: number): DOMMatrix;
3809     rotateAxisAngle(x?: number, y?: number, z?: number, angle?: number): DOMMatrix;
3810     rotateFromVector(x?: number, y?: number): DOMMatrix;
3811     scale(scaleX?: number, scaleY?: number, scaleZ?: number, originX?: number, originY?: number, originZ?: number): DOMMatrix;
3812     scale3d(scale?: number, originX?: number, originY?: number, originZ?: number): DOMMatrix;
3813     /** @deprecated */
3814     scaleNonUniform(scaleX?: number, scaleY?: number): DOMMatrix;
3815     skewX(sx?: number): DOMMatrix;
3816     skewY(sy?: number): DOMMatrix;
3817     toFloat32Array(): Float32Array;
3818     toFloat64Array(): Float64Array;
3819     toJSON(): any;
3820     transformPoint(point?: DOMPointInit): DOMPoint;
3821     translate(tx?: number, ty?: number, tz?: number): DOMMatrix;
3822     toString(): string;
3823 }
3824
3825 declare var DOMMatrixReadOnly: {
3826     prototype: DOMMatrixReadOnly;
3827     new(init?: string | number[]): DOMMatrixReadOnly;
3828     fromFloat32Array(array32: Float32Array): DOMMatrixReadOnly;
3829     fromFloat64Array(array64: Float64Array): DOMMatrixReadOnly;
3830     fromMatrix(other?: DOMMatrixInit): DOMMatrixReadOnly;
3831     toString(): string;
3832 };
3833
3834 /** Provides the ability to parse XML or HTML source code from a string into a DOM Document. */
3835 interface DOMParser {
3836     /**
3837      * 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).
3838      *
3839      * For the XML parser, if string cannot be parsed, then the returned Document will contain elements describing the resulting error.
3840      *
3841      * Note that script elements are not evaluated during parsing, and the resulting document's encoding will always be UTF-8.
3842      *
3843      * Values other than the above for type will cause a TypeError exception to be thrown.
3844      */
3845     parseFromString(string: string, type: DOMParserSupportedType): Document;
3846 }
3847
3848 declare var DOMParser: {
3849     prototype: DOMParser;
3850     new(): DOMParser;
3851 };
3852
3853 interface DOMPoint extends DOMPointReadOnly {
3854     w: number;
3855     x: number;
3856     y: number;
3857     z: number;
3858 }
3859
3860 declare var DOMPoint: {
3861     prototype: DOMPoint;
3862     new(x?: number, y?: number, z?: number, w?: number): DOMPoint;
3863     fromPoint(other?: DOMPointInit): DOMPoint;
3864 };
3865
3866 type SVGPoint = DOMPoint;
3867 declare var SVGPoint: typeof DOMPoint;
3868
3869 interface DOMPointReadOnly {
3870     readonly w: number;
3871     readonly x: number;
3872     readonly y: number;
3873     readonly z: number;
3874     matrixTransform(matrix?: DOMMatrixInit): DOMPoint;
3875     toJSON(): any;
3876 }
3877
3878 declare var DOMPointReadOnly: {
3879     prototype: DOMPointReadOnly;
3880     new(x?: number, y?: number, z?: number, w?: number): DOMPointReadOnly;
3881     fromPoint(other?: DOMPointInit): DOMPointReadOnly;
3882 };
3883
3884 interface DOMQuad {
3885     readonly p1: DOMPoint;
3886     readonly p2: DOMPoint;
3887     readonly p3: DOMPoint;
3888     readonly p4: DOMPoint;
3889     getBounds(): DOMRect;
3890     toJSON(): any;
3891 }
3892
3893 declare var DOMQuad: {
3894     prototype: DOMQuad;
3895     new(p1?: DOMPointInit, p2?: DOMPointInit, p3?: DOMPointInit, p4?: DOMPointInit): DOMQuad;
3896     fromQuad(other?: DOMQuadInit): DOMQuad;
3897     fromRect(other?: DOMRectInit): DOMQuad;
3898 };
3899
3900 interface DOMRect extends DOMRectReadOnly {
3901     height: number;
3902     width: number;
3903     x: number;
3904     y: number;
3905 }
3906
3907 declare var DOMRect: {
3908     prototype: DOMRect;
3909     new(x?: number, y?: number, width?: number, height?: number): DOMRect;
3910     fromRect(other?: DOMRectInit): DOMRect;
3911 };
3912
3913 type SVGRect = DOMRect;
3914 declare var SVGRect: typeof DOMRect;
3915
3916 interface DOMRectList {
3917     readonly length: number;
3918     item(index: number): DOMRect | null;
3919     [index: number]: DOMRect;
3920 }
3921
3922 declare var DOMRectList: {
3923     prototype: DOMRectList;
3924     new(): DOMRectList;
3925 };
3926
3927 interface DOMRectReadOnly {
3928     readonly bottom: number;
3929     readonly height: number;
3930     readonly left: number;
3931     readonly right: number;
3932     readonly top: number;
3933     readonly width: number;
3934     readonly x: number;
3935     readonly y: number;
3936     toJSON(): any;
3937 }
3938
3939 declare var DOMRectReadOnly: {
3940     prototype: DOMRectReadOnly;
3941     new(x?: number, y?: number, width?: number, height?: number): DOMRectReadOnly;
3942     fromRect(other?: DOMRectInit): DOMRectReadOnly;
3943 };
3944
3945 /** A type returned by some APIs which contains a list of DOMString (strings). */
3946 interface DOMStringList {
3947     /** Returns the number of strings in strings. */
3948     readonly length: number;
3949     /** Returns true if strings contains string, and false otherwise. */
3950     contains(string: string): boolean;
3951     /** Returns the string with index index from strings. */
3952     item(index: number): string | null;
3953     [index: number]: string;
3954 }
3955
3956 declare var DOMStringList: {
3957     prototype: DOMStringList;
3958     new(): DOMStringList;
3959 };
3960
3961 /** Used by the dataset HTML attribute to represent data for custom attributes added to elements. */
3962 interface DOMStringMap {
3963     [name: string]: string | undefined;
3964 }
3965
3966 declare var DOMStringMap: {
3967     prototype: DOMStringMap;
3968     new(): DOMStringMap;
3969 };
3970
3971 /** 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. */
3972 interface DOMTokenList {
3973     /** Returns the number of tokens. */
3974     readonly length: number;
3975     /**
3976      * Returns the associated set as string.
3977      *
3978      * Can be set, to change the associated attribute.
3979      */
3980     value: string;
3981     toString(): string;
3982     /**
3983      * Adds all arguments passed, except those already present.
3984      *
3985      * Throws a "SyntaxError" DOMException if one of the arguments is the empty string.
3986      *
3987      * Throws an "InvalidCharacterError" DOMException if one of the arguments contains any ASCII whitespace.
3988      */
3989     add(...tokens: string[]): void;
3990     /** Returns true if token is present, and false otherwise. */
3991     contains(token: string): boolean;
3992     /** Returns the token with index index. */
3993     item(index: number): string | null;
3994     /**
3995      * Removes arguments passed, if they are present.
3996      *
3997      * Throws a "SyntaxError" DOMException if one of the arguments is the empty string.
3998      *
3999      * Throws an "InvalidCharacterError" DOMException if one of the arguments contains any ASCII whitespace.
4000      */
4001     remove(...tokens: string[]): void;
4002     /**
4003      * Replaces token with newToken.
4004      *
4005      * Returns true if token was replaced with newToken, and false otherwise.
4006      *
4007      * Throws a "SyntaxError" DOMException if one of the arguments is the empty string.
4008      *
4009      * Throws an "InvalidCharacterError" DOMException if one of the arguments contains any ASCII whitespace.
4010      */
4011     replace(token: string, newToken: string): boolean;
4012     /**
4013      * Returns true if token is in the associated attribute's supported tokens. Returns false otherwise.
4014      *
4015      * Throws a TypeError if the associated attribute has no supported tokens defined.
4016      */
4017     supports(token: string): boolean;
4018     /**
4019      * 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()).
4020      *
4021      * Returns true if token is now present, and false otherwise.
4022      *
4023      * Throws a "SyntaxError" DOMException if token is empty.
4024      *
4025      * Throws an "InvalidCharacterError" DOMException if token contains any spaces.
4026      */
4027     toggle(token: string, force?: boolean): boolean;
4028     forEach(callbackfn: (value: string, key: number, parent: DOMTokenList) => void, thisArg?: any): void;
4029     [index: number]: string;
4030 }
4031
4032 declare var DOMTokenList: {
4033     prototype: DOMTokenList;
4034     new(): DOMTokenList;
4035 };
4036
4037 /** 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. */
4038 interface DataTransfer {
4039     /**
4040      * 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.
4041      *
4042      * Can be set, to change the selected operation.
4043      *
4044      * The possible values are "none", "copy", "link", and "move".
4045      */
4046     dropEffect: "none" | "copy" | "link" | "move";
4047     /**
4048      * Returns the kinds of operations that are to be allowed.
4049      *
4050      * Can be set (during the dragstart event), to change the allowed operations.
4051      *
4052      * The possible values are "none", "copy", "copyLink", "copyMove", "link", "linkMove", "move", "all", and "uninitialized",
4053      */
4054     effectAllowed: "none" | "copy" | "copyLink" | "copyMove" | "link" | "linkMove" | "move" | "all" | "uninitialized";
4055     /** Returns a FileList of the files being dragged, if any. */
4056     readonly files: FileList;
4057     /** Returns a DataTransferItemList object, with the drag data. */
4058     readonly items: DataTransferItemList;
4059     /** 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". */
4060     readonly types: ReadonlyArray<string>;
4061     /** Removes the data of the specified formats. Removes all data if the argument is omitted. */
4062     clearData(format?: string): void;
4063     /** Returns the specified data. If there is no such data, returns the empty string. */
4064     getData(format: string): string;
4065     /** Adds the specified data. */
4066     setData(format: string, data: string): void;
4067     /** Uses the given element to update the drag feedback, replacing any previously specified feedback. */
4068     setDragImage(image: Element, x: number, y: number): void;
4069 }
4070
4071 declare var DataTransfer: {
4072     prototype: DataTransfer;
4073     new(): DataTransfer;
4074 };
4075
4076 /** 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. */
4077 interface DataTransferItem {
4078     /** Returns the drag data item kind, one of: "string", "file". */
4079     readonly kind: string;
4080     /** Returns the drag data item type string. */
4081     readonly type: string;
4082     /** Returns a File object, if the drag data item kind is File. */
4083     getAsFile(): File | null;
4084     /** Invokes the callback with the string data as the argument, if the drag data item kind is text. */
4085     getAsString(callback: FunctionStringCallback | null): void;
4086     webkitGetAsEntry(): FileSystemEntry | null;
4087 }
4088
4089 declare var DataTransferItem: {
4090     prototype: DataTransferItem;
4091     new(): DataTransferItem;
4092 };
4093
4094 /** 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. */
4095 interface DataTransferItemList {
4096     /** Returns the number of items in the drag data store. */
4097     readonly length: number;
4098     /** 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. */
4099     add(data: string, type: string): DataTransferItem | null;
4100     add(data: File): DataTransferItem | null;
4101     /** Removes all the entries in the drag data store. */
4102     clear(): void;
4103     /** Removes the indexth entry in the drag data store. */
4104     remove(index: number): void;
4105     [index: number]: DataTransferItem;
4106 }
4107
4108 declare var DataTransferItemList: {
4109     prototype: DataTransferItemList;
4110     new(): DataTransferItemList;
4111 };
4112
4113 /** 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. */
4114 interface DelayNode extends AudioNode {
4115     readonly delayTime: AudioParam;
4116 }
4117
4118 declare var DelayNode: {
4119     prototype: DelayNode;
4120     new(context: BaseAudioContext, options?: DelayOptions): DelayNode;
4121 };
4122
4123 /**
4124  * The DeviceMotionEvent provides web developers with information about the speed of changes for the device's position and orientation.
4125  * Available only in secure contexts.
4126  */
4127 interface DeviceMotionEvent extends Event {
4128     readonly acceleration: DeviceMotionEventAcceleration | null;
4129     readonly accelerationIncludingGravity: DeviceMotionEventAcceleration | null;
4130     readonly interval: number;
4131     readonly rotationRate: DeviceMotionEventRotationRate | null;
4132 }
4133
4134 declare var DeviceMotionEvent: {
4135     prototype: DeviceMotionEvent;
4136     new(type: string, eventInitDict?: DeviceMotionEventInit): DeviceMotionEvent;
4137 };
4138
4139 /** Available only in secure contexts. */
4140 interface DeviceMotionEventAcceleration {
4141     readonly x: number | null;
4142     readonly y: number | null;
4143     readonly z: number | null;
4144 }
4145
4146 /** Available only in secure contexts. */
4147 interface DeviceMotionEventRotationRate {
4148     readonly alpha: number | null;
4149     readonly beta: number | null;
4150     readonly gamma: number | null;
4151 }
4152
4153 /**
4154  * The DeviceOrientationEvent provides web developers with information from the physical orientation of the device running the web page.
4155  * Available only in secure contexts.
4156  */
4157 interface DeviceOrientationEvent extends Event {
4158     readonly absolute: boolean;
4159     readonly alpha: number | null;
4160     readonly beta: number | null;
4161     readonly gamma: number | null;
4162 }
4163
4164 declare var DeviceOrientationEvent: {
4165     prototype: DeviceOrientationEvent;
4166     new(type: string, eventInitDict?: DeviceOrientationEventInit): DeviceOrientationEvent;
4167 };
4168
4169 interface DocumentEventMap extends DocumentAndElementEventHandlersEventMap, GlobalEventHandlersEventMap {
4170     "fullscreenchange": Event;
4171     "fullscreenerror": Event;
4172     "pointerlockchange": Event;
4173     "pointerlockerror": Event;
4174     "readystatechange": Event;
4175     "visibilitychange": Event;
4176 }
4177
4178 /** Any web page loaded in the browser and serves as an entry point into the web page's content, which is the DOM tree. */
4179 interface Document extends Node, DocumentAndElementEventHandlers, DocumentOrShadowRoot, FontFaceSource, GlobalEventHandlers, NonElementParentNode, ParentNode, XPathEvaluatorBase {
4180     /** Sets or gets the URL for the current document. */
4181     readonly URL: string;
4182     /**
4183      * Sets or gets the color of all active links in the document.
4184      * @deprecated
4185      */
4186     alinkColor: string;
4187     /**
4188      * Returns a reference to the collection of elements contained by the object.
4189      * @deprecated
4190      */
4191     readonly all: HTMLAllCollection;
4192     /**
4193      * Retrieves a collection of all a objects that have a name and/or id property. Objects in this collection are in HTML source order.
4194      * @deprecated
4195      */
4196     readonly anchors: HTMLCollectionOf<HTMLAnchorElement>;
4197     /**
4198      * Retrieves a collection of all applet objects in the document.
4199      * @deprecated
4200      */
4201     readonly applets: HTMLCollection;
4202     /**
4203      * Deprecated. Sets or retrieves a value that indicates the background color behind the object.
4204      * @deprecated
4205      */
4206     bgColor: string;
4207     /** Specifies the beginning and end of the document body. */
4208     body: HTMLElement;
4209     /** Returns document's encoding. */
4210     readonly characterSet: string;
4211     /**
4212      * Gets or sets the character set used to encode the object.
4213      * @deprecated This is a legacy alias of `characterSet`.
4214      */
4215     readonly charset: string;
4216     /** Gets a value that indicates whether standards-compliant mode is switched on for the object. */
4217     readonly compatMode: string;
4218     /** Returns document's content type. */
4219     readonly contentType: string;
4220     /**
4221      * 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.
4222      *
4223      * Can be set, to add a new cookie to the element's set of HTTP cookies.
4224      *
4225      * 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.
4226      */
4227     cookie: string;
4228     /**
4229      * 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.
4230      *
4231      * 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.
4232      */
4233     readonly currentScript: HTMLOrSVGScriptElement | null;
4234     /** Returns the Window object of the active document. */
4235     readonly defaultView: (WindowProxy & typeof globalThis) | null;
4236     /** Sets or gets a value that indicates whether the document can be edited. */
4237     designMode: string;
4238     /** Sets or retrieves a value that indicates the reading order of the object. */
4239     dir: string;
4240     /** Gets an object representing the document type declaration associated with the current document. */
4241     readonly doctype: DocumentType | null;
4242     /** Gets a reference to the root node of the document. */
4243     readonly documentElement: HTMLElement;
4244     /** Returns document's URL. */
4245     readonly documentURI: string;
4246     /** Sets or gets the security domain of the document. */
4247     domain: string;
4248     /** Retrieves a collection of all embed objects in the document. */
4249     readonly embeds: HTMLCollectionOf<HTMLEmbedElement>;
4250     /**
4251      * Sets or gets the foreground (text) color of the document.
4252      * @deprecated
4253      */
4254     fgColor: string;
4255     /** Retrieves a collection, in source order, of all form objects in the document. */
4256     readonly forms: HTMLCollectionOf<HTMLFormElement>;
4257     /** @deprecated */
4258     readonly fullscreen: boolean;
4259     /** Returns true if document has the ability to display elements fullscreen and fullscreen is supported, or false otherwise. */
4260     readonly fullscreenEnabled: boolean;
4261     /** Returns the head element. */
4262     readonly head: HTMLHeadElement;
4263     readonly hidden: boolean;
4264     /** Retrieves a collection, in source order, of img objects in the document. */
4265     readonly images: HTMLCollectionOf<HTMLImageElement>;
4266     /** Gets the implementation object of the current document. */
4267     readonly implementation: DOMImplementation;
4268     /**
4269      * Returns the character encoding used to create the webpage that is loaded into the document object.
4270      * @deprecated This is a legacy alias of `characterSet`.
4271      */
4272     readonly inputEncoding: string;
4273     /** Gets the date that the page was last modified, if the page supplies one. */
4274     readonly lastModified: string;
4275     /**
4276      * Sets or gets the color of the document links.
4277      * @deprecated
4278      */
4279     linkColor: string;
4280     /** Retrieves a collection of all a objects that specify the href property and all area objects in the document. */
4281     readonly links: HTMLCollectionOf<HTMLAnchorElement | HTMLAreaElement>;
4282     /** Contains information about the current URL. */
4283     get location(): Location;
4284     set location(href: string | Location);
4285     onfullscreenchange: ((this: Document, ev: Event) => any) | null;
4286     onfullscreenerror: ((this: Document, ev: Event) => any) | null;
4287     onpointerlockchange: ((this: Document, ev: Event) => any) | null;
4288     onpointerlockerror: ((this: Document, ev: Event) => any) | null;
4289     /**
4290      * Fires when the state of the object has changed.
4291      * @param ev The event
4292      */
4293     onreadystatechange: ((this: Document, ev: Event) => any) | null;
4294     onvisibilitychange: ((this: Document, ev: Event) => any) | null;
4295     readonly ownerDocument: null;
4296     readonly pictureInPictureEnabled: boolean;
4297     /** Return an HTMLCollection of the embed elements in the Document. */
4298     readonly plugins: HTMLCollectionOf<HTMLEmbedElement>;
4299     /** Retrieves a value that indicates the current state of the object. */
4300     readonly readyState: DocumentReadyState;
4301     /** Gets the URL of the location that referred the user to the current page. */
4302     readonly referrer: string;
4303     /** @deprecated */
4304     readonly rootElement: SVGSVGElement | null;
4305     /** Retrieves a collection of all script objects in the document. */
4306     readonly scripts: HTMLCollectionOf<HTMLScriptElement>;
4307     readonly scrollingElement: Element | null;
4308     readonly timeline: DocumentTimeline;
4309     /** Contains the title of the document. */
4310     title: string;
4311     readonly visibilityState: VisibilityState;
4312     /**
4313      * Sets or gets the color of the links that the user has visited.
4314      * @deprecated
4315      */
4316     vlinkColor: string;
4317     /**
4318      * Moves node from another document and returns it.
4319      *
4320      * If node is a document, throws a "NotSupportedError" DOMException or, if node is a shadow root, throws a "HierarchyRequestError" DOMException.
4321      */
4322     adoptNode<T extends Node>(node: T): T;
4323     /** @deprecated */
4324     captureEvents(): void;
4325     /** @deprecated */
4326     caretRangeFromPoint(x: number, y: number): Range | null;
4327     /** @deprecated */
4328     clear(): void;
4329     /** Closes an output stream and forces the sent data to display. */
4330     close(): void;
4331     /**
4332      * Creates an attribute object with a specified name.
4333      * @param name String that sets the attribute object's name.
4334      */
4335     createAttribute(localName: string): Attr;
4336     createAttributeNS(namespace: string | null, qualifiedName: string): Attr;
4337     /** Returns a CDATASection node whose data is data. */
4338     createCDATASection(data: string): CDATASection;
4339     /**
4340      * Creates a comment object with the specified data.
4341      * @param data Sets the comment object's data.
4342      */
4343     createComment(data: string): Comment;
4344     /** Creates a new document. */
4345     createDocumentFragment(): DocumentFragment;
4346     /**
4347      * Creates an instance of the element for the specified tag.
4348      * @param tagName The name of an element.
4349      */
4350     createElement<K extends keyof HTMLElementTagNameMap>(tagName: K, options?: ElementCreationOptions): HTMLElementTagNameMap[K];
4351     /** @deprecated */
4352     createElement<K extends keyof HTMLElementDeprecatedTagNameMap>(tagName: K, options?: ElementCreationOptions): HTMLElementDeprecatedTagNameMap[K];
4353     createElement(tagName: string, options?: ElementCreationOptions): HTMLElement;
4354     /**
4355      * 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.
4356      *
4357      * If localName does not match the Name production an "InvalidCharacterError" DOMException will be thrown.
4358      *
4359      * If one of the following conditions is true a "NamespaceError" DOMException will be thrown:
4360      *
4361      * localName does not match the QName production.
4362      * Namespace prefix is not null and namespace is the empty string.
4363      * Namespace prefix is "xml" and namespace is not the XML namespace.
4364      * qualifiedName or namespace prefix is "xmlns" and namespace is not the XMLNS namespace.
4365      * namespace is the XMLNS namespace and neither qualifiedName nor namespace prefix is "xmlns".
4366      *
4367      * When supplied, options's is can be used to create a customized built-in element.
4368      */
4369     createElementNS(namespaceURI: "http://www.w3.org/1999/xhtml", qualifiedName: string): HTMLElement;
4370     createElementNS<K extends keyof SVGElementTagNameMap>(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: K): SVGElementTagNameMap[K];
4371     createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: string): SVGElement;
4372     createElementNS(namespaceURI: string | null, qualifiedName: string, options?: ElementCreationOptions): Element;
4373     createElementNS(namespace: string | null, qualifiedName: string, options?: string | ElementCreationOptions): Element;
4374     createEvent(eventInterface: "AnimationEvent"): AnimationEvent;
4375     createEvent(eventInterface: "AnimationPlaybackEvent"): AnimationPlaybackEvent;
4376     createEvent(eventInterface: "AudioProcessingEvent"): AudioProcessingEvent;
4377     createEvent(eventInterface: "BeforeUnloadEvent"): BeforeUnloadEvent;
4378     createEvent(eventInterface: "BlobEvent"): BlobEvent;
4379     createEvent(eventInterface: "ClipboardEvent"): ClipboardEvent;
4380     createEvent(eventInterface: "CloseEvent"): CloseEvent;
4381     createEvent(eventInterface: "CompositionEvent"): CompositionEvent;
4382     createEvent(eventInterface: "CustomEvent"): CustomEvent;
4383     createEvent(eventInterface: "DeviceMotionEvent"): DeviceMotionEvent;
4384     createEvent(eventInterface: "DeviceOrientationEvent"): DeviceOrientationEvent;
4385     createEvent(eventInterface: "DragEvent"): DragEvent;
4386     createEvent(eventInterface: "ErrorEvent"): ErrorEvent;
4387     createEvent(eventInterface: "FocusEvent"): FocusEvent;
4388     createEvent(eventInterface: "FontFaceSetLoadEvent"): FontFaceSetLoadEvent;
4389     createEvent(eventInterface: "FormDataEvent"): FormDataEvent;
4390     createEvent(eventInterface: "GamepadEvent"): GamepadEvent;
4391     createEvent(eventInterface: "HashChangeEvent"): HashChangeEvent;
4392     createEvent(eventInterface: "IDBVersionChangeEvent"): IDBVersionChangeEvent;
4393     createEvent(eventInterface: "InputEvent"): InputEvent;
4394     createEvent(eventInterface: "KeyboardEvent"): KeyboardEvent;
4395     createEvent(eventInterface: "MediaEncryptedEvent"): MediaEncryptedEvent;
4396     createEvent(eventInterface: "MediaKeyMessageEvent"): MediaKeyMessageEvent;
4397     createEvent(eventInterface: "MediaQueryListEvent"): MediaQueryListEvent;
4398     createEvent(eventInterface: "MediaRecorderErrorEvent"): MediaRecorderErrorEvent;
4399     createEvent(eventInterface: "MediaStreamTrackEvent"): MediaStreamTrackEvent;
4400     createEvent(eventInterface: "MessageEvent"): MessageEvent;
4401     createEvent(eventInterface: "MouseEvent"): MouseEvent;
4402     createEvent(eventInterface: "MouseEvents"): MouseEvent;
4403     createEvent(eventInterface: "MutationEvent"): MutationEvent;
4404     createEvent(eventInterface: "MutationEvents"): MutationEvent;
4405     createEvent(eventInterface: "OfflineAudioCompletionEvent"): OfflineAudioCompletionEvent;
4406     createEvent(eventInterface: "PageTransitionEvent"): PageTransitionEvent;
4407     createEvent(eventInterface: "PaymentMethodChangeEvent"): PaymentMethodChangeEvent;
4408     createEvent(eventInterface: "PaymentRequestUpdateEvent"): PaymentRequestUpdateEvent;
4409     createEvent(eventInterface: "PointerEvent"): PointerEvent;
4410     createEvent(eventInterface: "PopStateEvent"): PopStateEvent;
4411     createEvent(eventInterface: "ProgressEvent"): ProgressEvent;
4412     createEvent(eventInterface: "PromiseRejectionEvent"): PromiseRejectionEvent;
4413     createEvent(eventInterface: "RTCDTMFToneChangeEvent"): RTCDTMFToneChangeEvent;
4414     createEvent(eventInterface: "RTCDataChannelEvent"): RTCDataChannelEvent;
4415     createEvent(eventInterface: "RTCPeerConnectionIceErrorEvent"): RTCPeerConnectionIceErrorEvent;
4416     createEvent(eventInterface: "RTCPeerConnectionIceEvent"): RTCPeerConnectionIceEvent;
4417     createEvent(eventInterface: "RTCTrackEvent"): RTCTrackEvent;
4418     createEvent(eventInterface: "SecurityPolicyViolationEvent"): SecurityPolicyViolationEvent;
4419     createEvent(eventInterface: "SpeechSynthesisErrorEvent"): SpeechSynthesisErrorEvent;
4420     createEvent(eventInterface: "SpeechSynthesisEvent"): SpeechSynthesisEvent;
4421     createEvent(eventInterface: "StorageEvent"): StorageEvent;
4422     createEvent(eventInterface: "SubmitEvent"): SubmitEvent;
4423     createEvent(eventInterface: "TouchEvent"): TouchEvent;
4424     createEvent(eventInterface: "TrackEvent"): TrackEvent;
4425     createEvent(eventInterface: "TransitionEvent"): TransitionEvent;
4426     createEvent(eventInterface: "UIEvent"): UIEvent;
4427     createEvent(eventInterface: "UIEvents"): UIEvent;
4428     createEvent(eventInterface: "WebGLContextEvent"): WebGLContextEvent;
4429     createEvent(eventInterface: "WheelEvent"): WheelEvent;
4430     createEvent(eventInterface: string): Event;
4431     /**
4432      * Creates a NodeIterator object that you can use to traverse filtered lists of nodes or elements in a document.
4433      * @param root The root element or node to start traversing on.
4434      * @param whatToShow The type of nodes or elements to appear in the node list
4435      * @param filter A custom NodeFilter function to use. For more information, see filter. Use null for no filter.
4436      */
4437     createNodeIterator(root: Node, whatToShow?: number, filter?: NodeFilter | null): NodeIterator;
4438     /** 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. */
4439     createProcessingInstruction(target: string, data: string): ProcessingInstruction;
4440     /**  Returns an empty range object that has both of its boundary points positioned at the beginning of the document. */
4441     createRange(): Range;
4442     /**
4443      * Creates a text string from the specified value.
4444      * @param data String that specifies the nodeValue property of the text node.
4445      */
4446     createTextNode(data: string): Text;
4447     /**
4448      * Creates a TreeWalker object that you can use to traverse filtered lists of nodes or elements in a document.
4449      * @param root The root element or node to start traversing on.
4450      * @param whatToShow The type of nodes or elements to appear in the node list. For more information, see whatToShow.
4451      * @param filter A custom NodeFilter function to use.
4452      */
4453     createTreeWalker(root: Node, whatToShow?: number, filter?: NodeFilter | null): TreeWalker;
4454     /**
4455      * Executes a command on the current document, current selection, or the given range.
4456      * @param commandId String that specifies the command to execute. This command can be any of the command identifiers that can be executed in script.
4457      * @param showUI Display the user interface, defaults to false.
4458      * @param value Value to assign.
4459      * @deprecated
4460      */
4461     execCommand(commandId: string, showUI?: boolean, value?: string): boolean;
4462     /** Stops document's fullscreen element from being displayed fullscreen and resolves promise when done. */
4463     exitFullscreen(): Promise<void>;
4464     exitPictureInPicture(): Promise<void>;
4465     exitPointerLock(): void;
4466     /**
4467      * Returns a reference to the first object with the specified value of the ID attribute.
4468      * @param elementId String that specifies the ID value.
4469      */
4470     getElementById(elementId: string): HTMLElement | null;
4471     /** 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. */
4472     getElementsByClassName(classNames: string): HTMLCollectionOf<Element>;
4473     /**
4474      * Gets a collection of objects based on the value of the NAME or ID attribute.
4475      * @param elementName Gets a collection of objects based on the value of the NAME or ID attribute.
4476      */
4477     getElementsByName(elementName: string): NodeListOf<HTMLElement>;
4478     /**
4479      * Retrieves a collection of objects based on the specified element name.
4480      * @param name Specifies the name of an element.
4481      */
4482     getElementsByTagName<K extends keyof HTMLElementTagNameMap>(qualifiedName: K): HTMLCollectionOf<HTMLElementTagNameMap[K]>;
4483     getElementsByTagName<K extends keyof SVGElementTagNameMap>(qualifiedName: K): HTMLCollectionOf<SVGElementTagNameMap[K]>;
4484     getElementsByTagName(qualifiedName: string): HTMLCollectionOf<Element>;
4485     /**
4486      * If namespace and localName are "*" returns a HTMLCollection of all descendant elements.
4487      *
4488      * If only namespace is "*" returns a HTMLCollection of all descendant elements whose local name is localName.
4489      *
4490      * If only localName is "*" returns a HTMLCollection of all descendant elements whose namespace is namespace.
4491      *
4492      * Otherwise, returns a HTMLCollection of all descendant elements whose namespace is namespace and local name is localName.
4493      */
4494     getElementsByTagNameNS(namespaceURI: "http://www.w3.org/1999/xhtml", localName: string): HTMLCollectionOf<HTMLElement>;
4495     getElementsByTagNameNS(namespaceURI: "http://www.w3.org/2000/svg", localName: string): HTMLCollectionOf<SVGElement>;
4496     getElementsByTagNameNS(namespace: string | null, localName: string): HTMLCollectionOf<Element>;
4497     /** Returns an object representing the current selection of the document that is loaded into the object displaying a webpage. */
4498     getSelection(): Selection | null;
4499     /** Gets a value indicating whether the object currently has focus. */
4500     hasFocus(): boolean;
4501     hasStorageAccess(): Promise<boolean>;
4502     /**
4503      * Returns a copy of node. If deep is true, the copy also includes the node's descendants.
4504      *
4505      * If node is a document or a shadow root, throws a "NotSupportedError" DOMException.
4506      */
4507     importNode<T extends Node>(node: T, deep?: boolean): T;
4508     /**
4509      * 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.
4510      * @param url Specifies a MIME type for the document.
4511      * @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.
4512      * @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.
4513      * @param replace Specifies whether the existing entry for the document is replaced in the history list.
4514      */
4515     open(unused1?: string, unused2?: string): Document;
4516     open(url: string | URL, name: string, features: string): WindowProxy | null;
4517     /**
4518      * Returns a Boolean value that indicates whether a specified command can be successfully executed using execCommand, given the current state of the document.
4519      * @param commandId Specifies a command identifier.
4520      * @deprecated
4521      */
4522     queryCommandEnabled(commandId: string): boolean;
4523     /**
4524      * Returns a Boolean value that indicates whether the specified command is in the indeterminate state.
4525      * @param commandId String that specifies a command identifier.
4526      */
4527     queryCommandIndeterm(commandId: string): boolean;
4528     /**
4529      * Returns a Boolean value that indicates the current state of the command.
4530      * @param commandId String that specifies a command identifier.
4531      * @deprecated
4532      */
4533     queryCommandState(commandId: string): boolean;
4534     /**
4535      * Returns a Boolean value that indicates whether the current command is supported on the current range.
4536      * @param commandId Specifies a command identifier.
4537      * @deprecated
4538      */
4539     queryCommandSupported(commandId: string): boolean;
4540     /**
4541      * Returns the current value of the document, range, or current selection for the given command.
4542      * @param commandId String that specifies a command identifier.
4543      */
4544     queryCommandValue(commandId: string): string;
4545     /** @deprecated */
4546     releaseEvents(): void;
4547     requestStorageAccess(): Promise<void>;
4548     /**
4549      * Writes one or more HTML expressions to a document in the specified window.
4550      * @param content Specifies the text and HTML tags to write.
4551      */
4552     write(...text: string[]): void;
4553     /**
4554      * Writes one or more HTML expressions, followed by a carriage return, to a document in the specified window.
4555      * @param content The text and HTML tags to write.
4556      */
4557     writeln(...text: string[]): void;
4558     addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
4559     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
4560     removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
4561     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
4562 }
4563
4564 declare var Document: {
4565     prototype: Document;
4566     new(): Document;
4567 };
4568
4569 interface DocumentAndElementEventHandlersEventMap {
4570     "copy": ClipboardEvent;
4571     "cut": ClipboardEvent;
4572     "paste": ClipboardEvent;
4573 }
4574
4575 interface DocumentAndElementEventHandlers {
4576     oncopy: ((this: DocumentAndElementEventHandlers, ev: ClipboardEvent) => any) | null;
4577     oncut: ((this: DocumentAndElementEventHandlers, ev: ClipboardEvent) => any) | null;
4578     onpaste: ((this: DocumentAndElementEventHandlers, ev: ClipboardEvent) => any) | null;
4579     addEventListener<K extends keyof DocumentAndElementEventHandlersEventMap>(type: K, listener: (this: DocumentAndElementEventHandlers, ev: DocumentAndElementEventHandlersEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
4580     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
4581     removeEventListener<K extends keyof DocumentAndElementEventHandlersEventMap>(type: K, listener: (this: DocumentAndElementEventHandlers, ev: DocumentAndElementEventHandlersEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
4582     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
4583 }
4584
4585 /** 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. */
4586 interface DocumentFragment extends Node, NonElementParentNode, ParentNode {
4587     readonly ownerDocument: Document;
4588     getElementById(elementId: string): HTMLElement | null;
4589 }
4590
4591 declare var DocumentFragment: {
4592     prototype: DocumentFragment;
4593     new(): DocumentFragment;
4594 };
4595
4596 interface DocumentOrShadowRoot {
4597     /**
4598      * Returns the deepest element in the document through which or to which key events are being routed. This is, roughly speaking, the focused element in the document.
4599      *
4600      * For the purposes of this API, when a child browsing context is focused, its container is focused in the parent browsing context. For example, if the user moves the focus to a text control in an iframe, the iframe is the element returned by the activeElement API in the iframe's node document.
4601      *
4602      * Similarly, when the focused element is in a different node tree than documentOrShadowRoot, the element returned will be the host that's located in the same node tree as documentOrShadowRoot if documentOrShadowRoot is a shadow-including inclusive ancestor of the focused element, and null if not.
4603      */
4604     readonly activeElement: Element | null;
4605     /** Returns document's fullscreen element. */
4606     readonly fullscreenElement: Element | null;
4607     readonly pictureInPictureElement: Element | null;
4608     readonly pointerLockElement: Element | null;
4609     /** Retrieves a collection of styleSheet objects representing the style sheets that correspond to each instance of a link or style object in the document. */
4610     readonly styleSheets: StyleSheetList;
4611     /**
4612      * Returns the element for the specified x coordinate and the specified y coordinate.
4613      * @param x The x-offset
4614      * @param y The y-offset
4615      */
4616     elementFromPoint(x: number, y: number): Element | null;
4617     elementsFromPoint(x: number, y: number): Element[];
4618     getAnimations(): Animation[];
4619 }
4620
4621 interface DocumentTimeline extends AnimationTimeline {
4622 }
4623
4624 declare var DocumentTimeline: {
4625     prototype: DocumentTimeline;
4626     new(options?: DocumentTimelineOptions): DocumentTimeline;
4627 };
4628
4629 /** A Node containing a doctype. */
4630 interface DocumentType extends Node, ChildNode {
4631     readonly name: string;
4632     readonly ownerDocument: Document;
4633     readonly publicId: string;
4634     readonly systemId: string;
4635 }
4636
4637 declare var DocumentType: {
4638     prototype: DocumentType;
4639     new(): DocumentType;
4640 };
4641
4642 /** 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. */
4643 interface DragEvent extends MouseEvent {
4644     /** Returns the DataTransfer object for the event. */
4645     readonly dataTransfer: DataTransfer | null;
4646 }
4647
4648 declare var DragEvent: {
4649     prototype: DragEvent;
4650     new(type: string, eventInitDict?: DragEventInit): DragEvent;
4651 };
4652
4653 /** Inherits properties from its parent, AudioNode. */
4654 interface DynamicsCompressorNode extends AudioNode {
4655     readonly attack: AudioParam;
4656     readonly knee: AudioParam;
4657     readonly ratio: AudioParam;
4658     readonly reduction: number;
4659     readonly release: AudioParam;
4660     readonly threshold: AudioParam;
4661 }
4662
4663 declare var DynamicsCompressorNode: {
4664     prototype: DynamicsCompressorNode;
4665     new(context: BaseAudioContext, options?: DynamicsCompressorOptions): DynamicsCompressorNode;
4666 };
4667
4668 interface EXT_blend_minmax {
4669     readonly MAX_EXT: GLenum;
4670     readonly MIN_EXT: GLenum;
4671 }
4672
4673 interface EXT_color_buffer_float {
4674 }
4675
4676 interface EXT_color_buffer_half_float {
4677     readonly FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE_EXT: GLenum;
4678     readonly RGB16F_EXT: GLenum;
4679     readonly RGBA16F_EXT: GLenum;
4680     readonly UNSIGNED_NORMALIZED_EXT: GLenum;
4681 }
4682
4683 interface EXT_float_blend {
4684 }
4685
4686 /** 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. */
4687 interface EXT_frag_depth {
4688 }
4689
4690 interface EXT_sRGB {
4691     readonly FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT: GLenum;
4692     readonly SRGB8_ALPHA8_EXT: GLenum;
4693     readonly SRGB_ALPHA_EXT: GLenum;
4694     readonly SRGB_EXT: GLenum;
4695 }
4696
4697 interface EXT_shader_texture_lod {
4698 }
4699
4700 interface EXT_texture_compression_rgtc {
4701     readonly COMPRESSED_RED_GREEN_RGTC2_EXT: GLenum;
4702     readonly COMPRESSED_RED_RGTC1_EXT: GLenum;
4703     readonly COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT: GLenum;
4704     readonly COMPRESSED_SIGNED_RED_RGTC1_EXT: GLenum;
4705 }
4706
4707 /** The EXT_texture_filter_anisotropic extension is part of the WebGL API and exposes two constants for anisotropic filtering (AF). */
4708 interface EXT_texture_filter_anisotropic {
4709     readonly MAX_TEXTURE_MAX_ANISOTROPY_EXT: GLenum;
4710     readonly TEXTURE_MAX_ANISOTROPY_EXT: GLenum;
4711 }
4712
4713 interface ElementEventMap {
4714     "fullscreenchange": Event;
4715     "fullscreenerror": Event;
4716 }
4717
4718 /** 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. */
4719 interface Element extends Node, ARIAMixin, Animatable, ChildNode, InnerHTML, NonDocumentTypeChildNode, ParentNode, Slottable {
4720     readonly attributes: NamedNodeMap;
4721     /** Allows for manipulation of element's class content attribute as a set of whitespace-separated tokens through a DOMTokenList object. */
4722     readonly classList: DOMTokenList;
4723     /** Returns the value of element's class content attribute. Can be set to change it. */
4724     className: string;
4725     readonly clientHeight: number;
4726     readonly clientLeft: number;
4727     readonly clientTop: number;
4728     readonly clientWidth: number;
4729     /** Returns the value of element's id content attribute. Can be set to change it. */
4730     id: string;
4731     /** Returns the local name. */
4732     readonly localName: string;
4733     /** Returns the namespace. */
4734     readonly namespaceURI: string | null;
4735     onfullscreenchange: ((this: Element, ev: Event) => any) | null;
4736     onfullscreenerror: ((this: Element, ev: Event) => any) | null;
4737     outerHTML: string;
4738     readonly ownerDocument: Document;
4739     readonly part: DOMTokenList;
4740     /** Returns the namespace prefix. */
4741     readonly prefix: string | null;
4742     readonly scrollHeight: number;
4743     scrollLeft: number;
4744     scrollTop: number;
4745     readonly scrollWidth: number;
4746     /** Returns element's shadow root, if any, and if shadow root's mode is "open", and null otherwise. */
4747     readonly shadowRoot: ShadowRoot | null;
4748     /** Returns the value of element's slot content attribute. Can be set to change it. */
4749     slot: string;
4750     /** Returns the HTML-uppercased qualified name. */
4751     readonly tagName: string;
4752     /** Creates a shadow root for element and returns it. */
4753     attachShadow(init: ShadowRootInit): ShadowRoot;
4754     /** Returns the first (starting at element) inclusive ancestor that matches selectors, and null otherwise. */
4755     closest<K extends keyof HTMLElementTagNameMap>(selector: K): HTMLElementTagNameMap[K] | null;
4756     closest<K extends keyof SVGElementTagNameMap>(selector: K): SVGElementTagNameMap[K] | null;
4757     closest<E extends Element = Element>(selectors: string): E | null;
4758     /** Returns element's first attribute whose qualified name is qualifiedName, and null if there is no such attribute otherwise. */
4759     getAttribute(qualifiedName: string): string | null;
4760     /** Returns element's attribute whose namespace is namespace and local name is localName, and null if there is no such attribute otherwise. */
4761     getAttributeNS(namespace: string | null, localName: string): string | null;
4762     /** Returns the qualified names of all element's attributes. Can contain duplicates. */
4763     getAttributeNames(): string[];
4764     getAttributeNode(qualifiedName: string): Attr | null;
4765     getAttributeNodeNS(namespace: string | null, localName: string): Attr | null;
4766     getBoundingClientRect(): DOMRect;
4767     getClientRects(): DOMRectList;
4768     /** 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. */
4769     getElementsByClassName(classNames: string): HTMLCollectionOf<Element>;
4770     getElementsByTagName<K extends keyof HTMLElementTagNameMap>(qualifiedName: K): HTMLCollectionOf<HTMLElementTagNameMap[K]>;
4771     getElementsByTagName<K extends keyof SVGElementTagNameMap>(qualifiedName: K): HTMLCollectionOf<SVGElementTagNameMap[K]>;
4772     getElementsByTagName(qualifiedName: string): HTMLCollectionOf<Element>;
4773     getElementsByTagNameNS(namespaceURI: "http://www.w3.org/1999/xhtml", localName: string): HTMLCollectionOf<HTMLElement>;
4774     getElementsByTagNameNS(namespaceURI: "http://www.w3.org/2000/svg", localName: string): HTMLCollectionOf<SVGElement>;
4775     getElementsByTagNameNS(namespace: string | null, localName: string): HTMLCollectionOf<Element>;
4776     /** Returns true if element has an attribute whose qualified name is qualifiedName, and false otherwise. */
4777     hasAttribute(qualifiedName: string): boolean;
4778     /** Returns true if element has an attribute whose namespace is namespace and local name is localName. */
4779     hasAttributeNS(namespace: string | null, localName: string): boolean;
4780     /** Returns true if element has attributes, and false otherwise. */
4781     hasAttributes(): boolean;
4782     hasPointerCapture(pointerId: number): boolean;
4783     insertAdjacentElement(where: InsertPosition, element: Element): Element | null;
4784     insertAdjacentHTML(position: InsertPosition, text: string): void;
4785     insertAdjacentText(where: InsertPosition, data: string): void;
4786     /** Returns true if matching selectors against element's root yields element, and false otherwise. */
4787     matches(selectors: string): boolean;
4788     releasePointerCapture(pointerId: number): void;
4789     /** Removes element's first attribute whose qualified name is qualifiedName. */
4790     removeAttribute(qualifiedName: string): void;
4791     /** Removes element's attribute whose namespace is namespace and local name is localName. */
4792     removeAttributeNS(namespace: string | null, localName: string): void;
4793     removeAttributeNode(attr: Attr): Attr;
4794     /**
4795      * Displays element fullscreen and resolves promise when done.
4796      *
4797      * 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.
4798      */
4799     requestFullscreen(options?: FullscreenOptions): Promise<void>;
4800     requestPointerLock(): void;
4801     scroll(options?: ScrollToOptions): void;
4802     scroll(x: number, y: number): void;
4803     scrollBy(options?: ScrollToOptions): void;
4804     scrollBy(x: number, y: number): void;
4805     scrollIntoView(arg?: boolean | ScrollIntoViewOptions): void;
4806     scrollTo(options?: ScrollToOptions): void;
4807     scrollTo(x: number, y: number): void;
4808     /** Sets the value of element's first attribute whose qualified name is qualifiedName to value. */
4809     setAttribute(qualifiedName: string, value: string): void;
4810     /** Sets the value of element's attribute whose namespace is namespace and local name is localName to value. */
4811     setAttributeNS(namespace: string | null, qualifiedName: string, value: string): void;
4812     setAttributeNode(attr: Attr): Attr | null;
4813     setAttributeNodeNS(attr: Attr): Attr | null;
4814     setPointerCapture(pointerId: number): void;
4815     /**
4816      * 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.
4817      *
4818      * Returns true if qualifiedName is now present, and false otherwise.
4819      */
4820     toggleAttribute(qualifiedName: string, force?: boolean): boolean;
4821     /** @deprecated This is a legacy alias of `matches`. */
4822     webkitMatchesSelector(selectors: string): boolean;
4823     addEventListener<K extends keyof ElementEventMap>(type: K, listener: (this: Element, ev: ElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
4824     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
4825     removeEventListener<K extends keyof ElementEventMap>(type: K, listener: (this: Element, ev: ElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
4826     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
4827 }
4828
4829 declare var Element: {
4830     prototype: Element;
4831     new(): Element;
4832 };
4833
4834 interface ElementCSSInlineStyle {
4835     readonly style: CSSStyleDeclaration;
4836 }
4837
4838 interface ElementContentEditable {
4839     contentEditable: string;
4840     enterKeyHint: string;
4841     inputMode: string;
4842     readonly isContentEditable: boolean;
4843 }
4844
4845 interface ElementInternals extends ARIAMixin {
4846     /** Returns the ShadowRoot for internals's target element, if the target element is a shadow host, or null otherwise. */
4847     readonly shadowRoot: ShadowRoot | null;
4848 }
4849
4850 declare var ElementInternals: {
4851     prototype: ElementInternals;
4852     new(): ElementInternals;
4853 };
4854
4855 /** Events providing information related to errors in scripts or in files. */
4856 interface ErrorEvent extends Event {
4857     readonly colno: number;
4858     readonly error: any;
4859     readonly filename: string;
4860     readonly lineno: number;
4861     readonly message: string;
4862 }
4863
4864 declare var ErrorEvent: {
4865     prototype: ErrorEvent;
4866     new(type: string, eventInitDict?: ErrorEventInit): ErrorEvent;
4867 };
4868
4869 /** An event which takes place in the DOM. */
4870 interface Event {
4871     /** 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. */
4872     readonly bubbles: boolean;
4873     cancelBubble: boolean;
4874     /** 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. */
4875     readonly cancelable: boolean;
4876     /** 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. */
4877     readonly composed: boolean;
4878     /** Returns the object whose event listener's callback is currently being invoked. */
4879     readonly currentTarget: EventTarget | null;
4880     /** Returns true if preventDefault() was invoked successfully to indicate cancelation, and false otherwise. */
4881     readonly defaultPrevented: boolean;
4882     /** Returns the event's phase, which is one of NONE, CAPTURING_PHASE, AT_TARGET, and BUBBLING_PHASE. */
4883     readonly eventPhase: number;
4884     /** Returns true if event was dispatched by the user agent, and false otherwise. */
4885     readonly isTrusted: boolean;
4886     /** @deprecated */
4887     returnValue: boolean;
4888     /** @deprecated */
4889     readonly srcElement: EventTarget | null;
4890     /** Returns the object to which event is dispatched (its target). */
4891     readonly target: EventTarget | null;
4892     /** Returns the event's timestamp as the number of milliseconds measured relative to the time origin. */
4893     readonly timeStamp: DOMHighResTimeStamp;
4894     /** Returns the type of event, e.g. "click", "hashchange", or "submit". */
4895     readonly type: string;
4896     /** 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. */
4897     composedPath(): EventTarget[];
4898     /** @deprecated */
4899     initEvent(type: string, bubbles?: boolean, cancelable?: boolean): void;
4900     /** 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. */
4901     preventDefault(): void;
4902     /** 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. */
4903     stopImmediatePropagation(): void;
4904     /** When dispatched in a tree, invoking this method prevents event from reaching any objects other than the current object. */
4905     stopPropagation(): void;
4906     readonly AT_TARGET: number;
4907     readonly BUBBLING_PHASE: number;
4908     readonly CAPTURING_PHASE: number;
4909     readonly NONE: number;
4910 }
4911
4912 declare var Event: {
4913     prototype: Event;
4914     new(type: string, eventInitDict?: EventInit): Event;
4915     readonly AT_TARGET: number;
4916     readonly BUBBLING_PHASE: number;
4917     readonly CAPTURING_PHASE: number;
4918     readonly NONE: number;
4919 };
4920
4921 interface EventListener {
4922     (evt: Event): void;
4923 }
4924
4925 interface EventListenerObject {
4926     handleEvent(object: Event): void;
4927 }
4928
4929 interface EventSourceEventMap {
4930     "error": Event;
4931     "message": MessageEvent;
4932     "open": Event;
4933 }
4934
4935 interface EventSource extends EventTarget {
4936     onerror: ((this: EventSource, ev: Event) => any) | null;
4937     onmessage: ((this: EventSource, ev: MessageEvent) => any) | null;
4938     onopen: ((this: EventSource, ev: Event) => any) | null;
4939     /** Returns the state of this EventSource object's connection. It can have the values described below. */
4940     readonly readyState: number;
4941     /** Returns the URL providing the event stream. */
4942     readonly url: string;
4943     /** Returns true if the credentials mode for connection requests to the URL providing the event stream is set to "include", and false otherwise. */
4944     readonly withCredentials: boolean;
4945     /** Aborts any instances of the fetch algorithm started for this EventSource object, and sets the readyState attribute to CLOSED. */
4946     close(): void;
4947     readonly CLOSED: number;
4948     readonly CONNECTING: number;
4949     readonly OPEN: number;
4950     addEventListener<K extends keyof EventSourceEventMap>(type: K, listener: (this: EventSource, ev: EventSourceEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
4951     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
4952     removeEventListener<K extends keyof EventSourceEventMap>(type: K, listener: (this: EventSource, ev: EventSourceEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
4953     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
4954 }
4955
4956 declare var EventSource: {
4957     prototype: EventSource;
4958     new(url: string | URL, eventSourceInitDict?: EventSourceInit): EventSource;
4959     readonly CLOSED: number;
4960     readonly CONNECTING: number;
4961     readonly OPEN: number;
4962 };
4963
4964 /** EventTarget is a DOM interface implemented by objects that can receive events and may have listeners for them. */
4965 interface EventTarget {
4966     /**
4967      * 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.
4968      *
4969      * 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.
4970      *
4971      * 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.
4972      *
4973      * 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.
4974      *
4975      * When set to true, options's once indicates that the callback will only be invoked once after which the event listener will be removed.
4976      *
4977      * If an AbortSignal is passed for options's signal, then the event listener will be removed when signal is aborted.
4978      *
4979      * The event listener is appended to target's event listener list and is not appended if it has the same type, callback, and capture.
4980      */
4981     addEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean): void;
4982     /** 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. */
4983     dispatchEvent(event: Event): boolean;
4984     /** Removes the event listener in target's event listener list with the same type, callback, and options. */
4985     removeEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
4986 }
4987
4988 declare var EventTarget: {
4989     prototype: EventTarget;
4990     new(): EventTarget;
4991 };
4992
4993 /** @deprecated */
4994 interface External {
4995     /** @deprecated */
4996     AddSearchProvider(): void;
4997     /** @deprecated */
4998     IsSearchProviderInstalled(): void;
4999 }
5000
5001 /** @deprecated */
5002 declare var External: {
5003     prototype: External;
5004     new(): External;
5005 };
5006
5007 /** Provides information about files and allows JavaScript in a web page to access their content. */
5008 interface File extends Blob {
5009     readonly lastModified: number;
5010     readonly name: string;
5011     readonly webkitRelativePath: string;
5012 }
5013
5014 declare var File: {
5015     prototype: File;
5016     new(fileBits: BlobPart[], fileName: string, options?: FilePropertyBag): File;
5017 };
5018
5019 /** 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. */
5020 interface FileList {
5021     readonly length: number;
5022     item(index: number): File | null;
5023     [index: number]: File;
5024 }
5025
5026 declare var FileList: {
5027     prototype: FileList;
5028     new(): FileList;
5029 };
5030
5031 interface FileReaderEventMap {
5032     "abort": ProgressEvent<FileReader>;
5033     "error": ProgressEvent<FileReader>;
5034     "load": ProgressEvent<FileReader>;
5035     "loadend": ProgressEvent<FileReader>;
5036     "loadstart": ProgressEvent<FileReader>;
5037     "progress": ProgressEvent<FileReader>;
5038 }
5039
5040 /** 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. */
5041 interface FileReader extends EventTarget {
5042     readonly error: DOMException | null;
5043     onabort: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
5044     onerror: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
5045     onload: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
5046     onloadend: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
5047     onloadstart: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
5048     onprogress: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
5049     readonly readyState: number;
5050     readonly result: string | ArrayBuffer | null;
5051     abort(): void;
5052     readAsArrayBuffer(blob: Blob): void;
5053     readAsBinaryString(blob: Blob): void;
5054     readAsDataURL(blob: Blob): void;
5055     readAsText(blob: Blob, encoding?: string): void;
5056     readonly DONE: number;
5057     readonly EMPTY: number;
5058     readonly LOADING: number;
5059     addEventListener<K extends keyof FileReaderEventMap>(type: K, listener: (this: FileReader, ev: FileReaderEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
5060     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
5061     removeEventListener<K extends keyof FileReaderEventMap>(type: K, listener: (this: FileReader, ev: FileReaderEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
5062     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
5063 }
5064
5065 declare var FileReader: {
5066     prototype: FileReader;
5067     new(): FileReader;
5068     readonly DONE: number;
5069     readonly EMPTY: number;
5070     readonly LOADING: number;
5071 };
5072
5073 interface FileSystem {
5074     readonly name: string;
5075     readonly root: FileSystemDirectoryEntry;
5076 }
5077
5078 declare var FileSystem: {
5079     prototype: FileSystem;
5080     new(): FileSystem;
5081 };
5082
5083 interface FileSystemDirectoryEntry extends FileSystemEntry {
5084     createReader(): FileSystemDirectoryReader;
5085     getDirectory(path?: string | null, options?: FileSystemFlags, successCallback?: FileSystemEntryCallback, errorCallback?: ErrorCallback): void;
5086     getFile(path?: string | null, options?: FileSystemFlags, successCallback?: FileSystemEntryCallback, errorCallback?: ErrorCallback): void;
5087 }
5088
5089 declare var FileSystemDirectoryEntry: {
5090     prototype: FileSystemDirectoryEntry;
5091     new(): FileSystemDirectoryEntry;
5092 };
5093
5094 interface FileSystemDirectoryReader {
5095     readEntries(successCallback: FileSystemEntriesCallback, errorCallback?: ErrorCallback): void;
5096 }
5097
5098 declare var FileSystemDirectoryReader: {
5099     prototype: FileSystemDirectoryReader;
5100     new(): FileSystemDirectoryReader;
5101 };
5102
5103 interface FileSystemEntry {
5104     readonly filesystem: FileSystem;
5105     readonly fullPath: string;
5106     readonly isDirectory: boolean;
5107     readonly isFile: boolean;
5108     readonly name: string;
5109     getParent(successCallback?: FileSystemEntryCallback, errorCallback?: ErrorCallback): void;
5110 }
5111
5112 declare var FileSystemEntry: {
5113     prototype: FileSystemEntry;
5114     new(): FileSystemEntry;
5115 };
5116
5117 interface FileSystemFileEntry extends FileSystemEntry {
5118     file(successCallback: FileCallback, errorCallback?: ErrorCallback): void;
5119 }
5120
5121 declare var FileSystemFileEntry: {
5122     prototype: FileSystemFileEntry;
5123     new(): FileSystemFileEntry;
5124 };
5125
5126 /** Focus-related events like focus, blur, focusin, or focusout. */
5127 interface FocusEvent extends UIEvent {
5128     readonly relatedTarget: EventTarget | null;
5129 }
5130
5131 declare var FocusEvent: {
5132     prototype: FocusEvent;
5133     new(type: string, eventInitDict?: FocusEventInit): FocusEvent;
5134 };
5135
5136 interface FontFace {
5137     ascentOverride: string;
5138     descentOverride: string;
5139     display: string;
5140     family: string;
5141     featureSettings: string;
5142     lineGapOverride: string;
5143     readonly loaded: Promise<FontFace>;
5144     readonly status: FontFaceLoadStatus;
5145     stretch: string;
5146     style: string;
5147     unicodeRange: string;
5148     variant: string;
5149     variationSettings: string;
5150     weight: string;
5151     load(): Promise<FontFace>;
5152 }
5153
5154 declare var FontFace: {
5155     prototype: FontFace;
5156     new(family: string, source: string | BinaryData, descriptors?: FontFaceDescriptors): FontFace;
5157 };
5158
5159 interface FontFaceSetEventMap {
5160     "loading": Event;
5161     "loadingdone": Event;
5162     "loadingerror": Event;
5163 }
5164
5165 interface FontFaceSet extends EventTarget {
5166     onloading: ((this: FontFaceSet, ev: Event) => any) | null;
5167     onloadingdone: ((this: FontFaceSet, ev: Event) => any) | null;
5168     onloadingerror: ((this: FontFaceSet, ev: Event) => any) | null;
5169     readonly ready: Promise<FontFaceSet>;
5170     readonly status: FontFaceSetLoadStatus;
5171     check(font: string, text?: string): boolean;
5172     load(font: string, text?: string): Promise<FontFace[]>;
5173     forEach(callbackfn: (value: FontFace, key: FontFace, parent: FontFaceSet) => void, thisArg?: any): void;
5174     addEventListener<K extends keyof FontFaceSetEventMap>(type: K, listener: (this: FontFaceSet, ev: FontFaceSetEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
5175     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
5176     removeEventListener<K extends keyof FontFaceSetEventMap>(type: K, listener: (this: FontFaceSet, ev: FontFaceSetEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
5177     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
5178 }
5179
5180 declare var FontFaceSet: {
5181     prototype: FontFaceSet;
5182     new(initialFaces: FontFace[]): FontFaceSet;
5183 };
5184
5185 interface FontFaceSetLoadEvent extends Event {
5186     readonly fontfaces: ReadonlyArray<FontFace>;
5187 }
5188
5189 declare var FontFaceSetLoadEvent: {
5190     prototype: FontFaceSetLoadEvent;
5191     new(type: string, eventInitDict?: FontFaceSetLoadEventInit): FontFaceSetLoadEvent;
5192 };
5193
5194 interface FontFaceSource {
5195     readonly fonts: FontFaceSet;
5196 }
5197
5198 /** 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". */
5199 interface FormData {
5200     append(name: string, value: string | Blob, fileName?: string): void;
5201     delete(name: string): void;
5202     get(name: string): FormDataEntryValue | null;
5203     getAll(name: string): FormDataEntryValue[];
5204     has(name: string): boolean;
5205     set(name: string, value: string | Blob, fileName?: string): void;
5206     forEach(callbackfn: (value: FormDataEntryValue, key: string, parent: FormData) => void, thisArg?: any): void;
5207 }
5208
5209 declare var FormData: {
5210     prototype: FormData;
5211     new(form?: HTMLFormElement): FormData;
5212 };
5213
5214 interface FormDataEvent extends Event {
5215     /** Returns a FormData object representing names and values of elements associated to the target form. Operations on the FormData object will affect form data to be submitted. */
5216     readonly formData: FormData;
5217 }
5218
5219 declare var FormDataEvent: {
5220     prototype: FormDataEvent;
5221     new(type: string, eventInitDict: FormDataEventInit): FormDataEvent;
5222 };
5223
5224 /** 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. */
5225 interface GainNode extends AudioNode {
5226     readonly gain: AudioParam;
5227 }
5228
5229 declare var GainNode: {
5230     prototype: GainNode;
5231     new(context: BaseAudioContext, options?: GainOptions): GainNode;
5232 };
5233
5234 /**
5235  * This Gamepad API interface defines an individual gamepad or other controller, allowing access to information such as button presses, axis positions, and id.
5236  * Available only in secure contexts.
5237  */
5238 interface Gamepad {
5239     readonly axes: ReadonlyArray<number>;
5240     readonly buttons: ReadonlyArray<GamepadButton>;
5241     readonly connected: boolean;
5242     readonly hapticActuators: ReadonlyArray<GamepadHapticActuator>;
5243     readonly id: string;
5244     readonly index: number;
5245     readonly mapping: GamepadMappingType;
5246     readonly timestamp: DOMHighResTimeStamp;
5247 }
5248
5249 declare var Gamepad: {
5250     prototype: Gamepad;
5251     new(): Gamepad;
5252 };
5253
5254 /**
5255  * 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.
5256  * Available only in secure contexts.
5257  */
5258 interface GamepadButton {
5259     readonly pressed: boolean;
5260     readonly touched: boolean;
5261     readonly value: number;
5262 }
5263
5264 declare var GamepadButton: {
5265     prototype: GamepadButton;
5266     new(): GamepadButton;
5267 };
5268
5269 /**
5270  * 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.
5271  * Available only in secure contexts.
5272  */
5273 interface GamepadEvent extends Event {
5274     readonly gamepad: Gamepad;
5275 }
5276
5277 declare var GamepadEvent: {
5278     prototype: GamepadEvent;
5279     new(type: string, eventInitDict: GamepadEventInit): GamepadEvent;
5280 };
5281
5282 /** This Gamepad API interface represents hardware in the controller designed to provide haptic feedback to the user (if available), most commonly vibration hardware. */
5283 interface GamepadHapticActuator {
5284     readonly type: GamepadHapticActuatorType;
5285 }
5286
5287 declare var GamepadHapticActuator: {
5288     prototype: GamepadHapticActuator;
5289     new(): GamepadHapticActuator;
5290 };
5291
5292 interface GenericTransformStream {
5293     readonly readable: ReadableStream;
5294     readonly writable: WritableStream;
5295 }
5296
5297 /** 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. */
5298 interface Geolocation {
5299     clearWatch(watchId: number): void;
5300     getCurrentPosition(successCallback: PositionCallback, errorCallback?: PositionErrorCallback | null, options?: PositionOptions): void;
5301     watchPosition(successCallback: PositionCallback, errorCallback?: PositionErrorCallback | null, options?: PositionOptions): number;
5302 }
5303
5304 declare var Geolocation: {
5305     prototype: Geolocation;
5306     new(): Geolocation;
5307 };
5308
5309 /** Available only in secure contexts. */
5310 interface GeolocationCoordinates {
5311     readonly accuracy: number;
5312     readonly altitude: number | null;
5313     readonly altitudeAccuracy: number | null;
5314     readonly heading: number | null;
5315     readonly latitude: number;
5316     readonly longitude: number;
5317     readonly speed: number | null;
5318 }
5319
5320 declare var GeolocationCoordinates: {
5321     prototype: GeolocationCoordinates;
5322     new(): GeolocationCoordinates;
5323 };
5324
5325 /** Available only in secure contexts. */
5326 interface GeolocationPosition {
5327     readonly coords: GeolocationCoordinates;
5328     readonly timestamp: DOMTimeStamp;
5329 }
5330
5331 declare var GeolocationPosition: {
5332     prototype: GeolocationPosition;
5333     new(): GeolocationPosition;
5334 };
5335
5336 interface GeolocationPositionError {
5337     readonly code: number;
5338     readonly message: string;
5339     readonly PERMISSION_DENIED: number;
5340     readonly POSITION_UNAVAILABLE: number;
5341     readonly TIMEOUT: number;
5342 }
5343
5344 declare var GeolocationPositionError: {
5345     prototype: GeolocationPositionError;
5346     new(): GeolocationPositionError;
5347     readonly PERMISSION_DENIED: number;
5348     readonly POSITION_UNAVAILABLE: number;
5349     readonly TIMEOUT: number;
5350 };
5351
5352 interface GlobalEventHandlersEventMap {
5353     "abort": UIEvent;
5354     "animationcancel": AnimationEvent;
5355     "animationend": AnimationEvent;
5356     "animationiteration": AnimationEvent;
5357     "animationstart": AnimationEvent;
5358     "auxclick": MouseEvent;
5359     "beforeinput": InputEvent;
5360     "blur": FocusEvent;
5361     "canplay": Event;
5362     "canplaythrough": Event;
5363     "change": Event;
5364     "click": MouseEvent;
5365     "close": Event;
5366     "compositionend": CompositionEvent;
5367     "compositionstart": CompositionEvent;
5368     "compositionupdate": CompositionEvent;
5369     "contextmenu": MouseEvent;
5370     "cuechange": Event;
5371     "dblclick": MouseEvent;
5372     "drag": DragEvent;
5373     "dragend": DragEvent;
5374     "dragenter": DragEvent;
5375     "dragleave": DragEvent;
5376     "dragover": DragEvent;
5377     "dragstart": DragEvent;
5378     "drop": DragEvent;
5379     "durationchange": Event;
5380     "emptied": Event;
5381     "ended": Event;
5382     "error": ErrorEvent;
5383     "focus": FocusEvent;
5384     "focusin": FocusEvent;
5385     "focusout": FocusEvent;
5386     "formdata": FormDataEvent;
5387     "gotpointercapture": PointerEvent;
5388     "input": Event;
5389     "invalid": Event;
5390     "keydown": KeyboardEvent;
5391     "keypress": KeyboardEvent;
5392     "keyup": KeyboardEvent;
5393     "load": Event;
5394     "loadeddata": Event;
5395     "loadedmetadata": Event;
5396     "loadstart": Event;
5397     "lostpointercapture": PointerEvent;
5398     "mousedown": MouseEvent;
5399     "mouseenter": MouseEvent;
5400     "mouseleave": MouseEvent;
5401     "mousemove": MouseEvent;
5402     "mouseout": MouseEvent;
5403     "mouseover": MouseEvent;
5404     "mouseup": MouseEvent;
5405     "pause": Event;
5406     "play": Event;
5407     "playing": Event;
5408     "pointercancel": PointerEvent;
5409     "pointerdown": PointerEvent;
5410     "pointerenter": PointerEvent;
5411     "pointerleave": PointerEvent;
5412     "pointermove": PointerEvent;
5413     "pointerout": PointerEvent;
5414     "pointerover": PointerEvent;
5415     "pointerup": PointerEvent;
5416     "progress": ProgressEvent;
5417     "ratechange": Event;
5418     "reset": Event;
5419     "resize": UIEvent;
5420     "scroll": Event;
5421     "securitypolicyviolation": SecurityPolicyViolationEvent;
5422     "seeked": Event;
5423     "seeking": Event;
5424     "select": Event;
5425     "selectionchange": Event;
5426     "selectstart": Event;
5427     "stalled": Event;
5428     "submit": SubmitEvent;
5429     "suspend": Event;
5430     "timeupdate": Event;
5431     "toggle": Event;
5432     "touchcancel": TouchEvent;
5433     "touchend": TouchEvent;
5434     "touchmove": TouchEvent;
5435     "touchstart": TouchEvent;
5436     "transitioncancel": TransitionEvent;
5437     "transitionend": TransitionEvent;
5438     "transitionrun": TransitionEvent;
5439     "transitionstart": TransitionEvent;
5440     "volumechange": Event;
5441     "waiting": Event;
5442     "webkitanimationend": Event;
5443     "webkitanimationiteration": Event;
5444     "webkitanimationstart": Event;
5445     "webkittransitionend": Event;
5446     "wheel": WheelEvent;
5447 }
5448
5449 interface GlobalEventHandlers {
5450     /**
5451      * Fires when the user aborts the download.
5452      * @param ev The event.
5453      */
5454     onabort: ((this: GlobalEventHandlers, ev: UIEvent) => any) | null;
5455     onanimationcancel: ((this: GlobalEventHandlers, ev: AnimationEvent) => any) | null;
5456     onanimationend: ((this: GlobalEventHandlers, ev: AnimationEvent) => any) | null;
5457     onanimationiteration: ((this: GlobalEventHandlers, ev: AnimationEvent) => any) | null;
5458     onanimationstart: ((this: GlobalEventHandlers, ev: AnimationEvent) => any) | null;
5459     onauxclick: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
5460     /**
5461      * Fires when the object loses the input focus.
5462      * @param ev The focus event.
5463      */
5464     onblur: ((this: GlobalEventHandlers, ev: FocusEvent) => any) | null;
5465     /**
5466      * Occurs when playback is possible, but would require further buffering.
5467      * @param ev The event.
5468      */
5469     oncanplay: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5470     oncanplaythrough: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5471     /**
5472      * Fires when the contents of the object or selection have changed.
5473      * @param ev The event.
5474      */
5475     onchange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5476     /**
5477      * Fires when the user clicks the left mouse button on the object
5478      * @param ev The mouse event.
5479      */
5480     onclick: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
5481     onclose: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5482     /**
5483      * Fires when the user clicks the right mouse button in the client area, opening the context menu.
5484      * @param ev The mouse event.
5485      */
5486     oncontextmenu: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
5487     oncuechange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5488     /**
5489      * Fires when the user double-clicks the object.
5490      * @param ev The mouse event.
5491      */
5492     ondblclick: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
5493     /**
5494      * Fires on the source object continuously during a drag operation.
5495      * @param ev The event.
5496      */
5497     ondrag: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
5498     /**
5499      * Fires on the source object when the user releases the mouse at the close of a drag operation.
5500      * @param ev The event.
5501      */
5502     ondragend: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
5503     /**
5504      * Fires on the target element when the user drags the object to a valid drop target.
5505      * @param ev The drag event.
5506      */
5507     ondragenter: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
5508     /**
5509      * Fires on the target object when the user moves the mouse out of a valid drop target during a drag operation.
5510      * @param ev The drag event.
5511      */
5512     ondragleave: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
5513     /**
5514      * Fires on the target element continuously while the user drags the object over a valid drop target.
5515      * @param ev The event.
5516      */
5517     ondragover: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
5518     /**
5519      * Fires on the source object when the user starts to drag a text selection or selected object.
5520      * @param ev The event.
5521      */
5522     ondragstart: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
5523     ondrop: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
5524     /**
5525      * Occurs when the duration attribute is updated.
5526      * @param ev The event.
5527      */
5528     ondurationchange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5529     /**
5530      * Occurs when the media element is reset to its initial state.
5531      * @param ev The event.
5532      */
5533     onemptied: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5534     /**
5535      * Occurs when the end of playback is reached.
5536      * @param ev The event
5537      */
5538     onended: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5539     /**
5540      * Fires when an error occurs during object loading.
5541      * @param ev The event.
5542      */
5543     onerror: OnErrorEventHandler;
5544     /**
5545      * Fires when the object receives focus.
5546      * @param ev The event.
5547      */
5548     onfocus: ((this: GlobalEventHandlers, ev: FocusEvent) => any) | null;
5549     onformdata: ((this: GlobalEventHandlers, ev: FormDataEvent) => any) | null;
5550     ongotpointercapture: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
5551     oninput: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5552     oninvalid: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5553     /**
5554      * Fires when the user presses a key.
5555      * @param ev The keyboard event
5556      */
5557     onkeydown: ((this: GlobalEventHandlers, ev: KeyboardEvent) => any) | null;
5558     /**
5559      * Fires when the user presses an alphanumeric key.
5560      * @param ev The event.
5561      * @deprecated
5562      */
5563     onkeypress: ((this: GlobalEventHandlers, ev: KeyboardEvent) => any) | null;
5564     /**
5565      * Fires when the user releases a key.
5566      * @param ev The keyboard event
5567      */
5568     onkeyup: ((this: GlobalEventHandlers, ev: KeyboardEvent) => any) | null;
5569     /**
5570      * Fires immediately after the browser loads the object.
5571      * @param ev The event.
5572      */
5573     onload: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5574     /**
5575      * Occurs when media data is loaded at the current playback position.
5576      * @param ev The event.
5577      */
5578     onloadeddata: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5579     /**
5580      * Occurs when the duration and dimensions of the media have been determined.
5581      * @param ev The event.
5582      */
5583     onloadedmetadata: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5584     /**
5585      * Occurs when Internet Explorer begins looking for media data.
5586      * @param ev The event.
5587      */
5588     onloadstart: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5589     onlostpointercapture: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
5590     /**
5591      * Fires when the user clicks the object with either mouse button.
5592      * @param ev The mouse event.
5593      */
5594     onmousedown: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
5595     onmouseenter: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
5596     onmouseleave: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
5597     /**
5598      * Fires when the user moves the mouse over the object.
5599      * @param ev The mouse event.
5600      */
5601     onmousemove: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
5602     /**
5603      * Fires when the user moves the mouse pointer outside the boundaries of the object.
5604      * @param ev The mouse event.
5605      */
5606     onmouseout: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
5607     /**
5608      * Fires when the user moves the mouse pointer into the object.
5609      * @param ev The mouse event.
5610      */
5611     onmouseover: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
5612     /**
5613      * Fires when the user releases a mouse button while the mouse is over the object.
5614      * @param ev The mouse event.
5615      */
5616     onmouseup: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
5617     /**
5618      * Occurs when playback is paused.
5619      * @param ev The event.
5620      */
5621     onpause: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5622     /**
5623      * Occurs when the play method is requested.
5624      * @param ev The event.
5625      */
5626     onplay: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5627     /**
5628      * Occurs when the audio or video has started playing.
5629      * @param ev The event.
5630      */
5631     onplaying: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5632     onpointercancel: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
5633     onpointerdown: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
5634     onpointerenter: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
5635     onpointerleave: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
5636     onpointermove: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
5637     onpointerout: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
5638     onpointerover: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
5639     onpointerup: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
5640     /**
5641      * Occurs to indicate progress while downloading media data.
5642      * @param ev The event.
5643      */
5644     onprogress: ((this: GlobalEventHandlers, ev: ProgressEvent) => any) | null;
5645     /**
5646      * Occurs when the playback rate is increased or decreased.
5647      * @param ev The event.
5648      */
5649     onratechange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5650     /**
5651      * Fires when the user resets a form.
5652      * @param ev The event.
5653      */
5654     onreset: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5655     onresize: ((this: GlobalEventHandlers, ev: UIEvent) => any) | null;
5656     /**
5657      * Fires when the user repositions the scroll box in the scroll bar on the object.
5658      * @param ev The event.
5659      */
5660     onscroll: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5661     /**
5662      * Occurs when the seek operation ends.
5663      * @param ev The event.
5664      */
5665     onseeked: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5666     /**
5667      * Occurs when the current playback position is moved.
5668      * @param ev The event.
5669      */
5670     onseeking: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5671     /**
5672      * Fires when the current selection changes.
5673      * @param ev The event.
5674      */
5675     onselect: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5676     onselectionchange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5677     onselectstart: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5678     /**
5679      * Occurs when the download has stopped.
5680      * @param ev The event.
5681      */
5682     onstalled: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5683     onsubmit: ((this: GlobalEventHandlers, ev: SubmitEvent) => any) | null;
5684     /**
5685      * Occurs if the load operation has been intentionally halted.
5686      * @param ev The event.
5687      */
5688     onsuspend: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5689     /**
5690      * Occurs to indicate the current playback position.
5691      * @param ev The event.
5692      */
5693     ontimeupdate: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5694     ontoggle: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5695     ontouchcancel?: ((this: GlobalEventHandlers, ev: TouchEvent) => any) | null | undefined;
5696     ontouchend?: ((this: GlobalEventHandlers, ev: TouchEvent) => any) | null | undefined;
5697     ontouchmove?: ((this: GlobalEventHandlers, ev: TouchEvent) => any) | null | undefined;
5698     ontouchstart?: ((this: GlobalEventHandlers, ev: TouchEvent) => any) | null | undefined;
5699     ontransitioncancel: ((this: GlobalEventHandlers, ev: TransitionEvent) => any) | null;
5700     ontransitionend: ((this: GlobalEventHandlers, ev: TransitionEvent) => any) | null;
5701     ontransitionrun: ((this: GlobalEventHandlers, ev: TransitionEvent) => any) | null;
5702     ontransitionstart: ((this: GlobalEventHandlers, ev: TransitionEvent) => any) | null;
5703     /**
5704      * Occurs when the volume is changed, or playback is muted or unmuted.
5705      * @param ev The event.
5706      */
5707     onvolumechange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5708     /**
5709      * Occurs when playback stops because the next frame of a video resource is not available.
5710      * @param ev The event.
5711      */
5712     onwaiting: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5713     /** @deprecated This is a legacy alias of `onanimationend`. */
5714     onwebkitanimationend: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5715     /** @deprecated This is a legacy alias of `onanimationiteration`. */
5716     onwebkitanimationiteration: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5717     /** @deprecated This is a legacy alias of `onanimationstart`. */
5718     onwebkitanimationstart: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5719     /** @deprecated This is a legacy alias of `ontransitionend`. */
5720     onwebkittransitionend: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5721     onwheel: ((this: GlobalEventHandlers, ev: WheelEvent) => any) | null;
5722     addEventListener<K extends keyof GlobalEventHandlersEventMap>(type: K, listener: (this: GlobalEventHandlers, ev: GlobalEventHandlersEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
5723     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
5724     removeEventListener<K extends keyof GlobalEventHandlersEventMap>(type: K, listener: (this: GlobalEventHandlers, ev: GlobalEventHandlersEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
5725     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
5726 }
5727
5728 interface HTMLAllCollection {
5729     /** Returns the number of elements in the collection. */
5730     readonly length: number;
5731     /** Returns the item with index index from the collection (determined by tree order). */
5732     item(nameOrIndex?: string): HTMLCollection | Element | null;
5733     /**
5734      * Returns the item with ID or name name from the collection.
5735      *
5736      * If there are multiple matching items, then an HTMLCollection object containing all those elements is returned.
5737      *
5738      * 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.
5739      */
5740     namedItem(name: string): HTMLCollection | Element | null;
5741     [index: number]: Element;
5742 }
5743
5744 declare var HTMLAllCollection: {
5745     prototype: HTMLAllCollection;
5746     new(): HTMLAllCollection;
5747 };
5748
5749 /** 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. */
5750 interface HTMLAnchorElement extends HTMLElement, HTMLHyperlinkElementUtils {
5751     /**
5752      * Sets or retrieves the character set used to encode the object.
5753      * @deprecated
5754      */
5755     charset: string;
5756     /**
5757      * Sets or retrieves the coordinates of the object.
5758      * @deprecated
5759      */
5760     coords: string;
5761     download: string;
5762     /** Sets or retrieves the language code of the object. */
5763     hreflang: string;
5764     /**
5765      * Sets or retrieves the shape of the object.
5766      * @deprecated
5767      */
5768     name: string;
5769     ping: string;
5770     referrerPolicy: string;
5771     /** Sets or retrieves the relationship between the object and the destination of the link. */
5772     rel: string;
5773     readonly relList: DOMTokenList;
5774     /**
5775      * Sets or retrieves the relationship between the object and the destination of the link.
5776      * @deprecated
5777      */
5778     rev: string;
5779     /**
5780      * Sets or retrieves the shape of the object.
5781      * @deprecated
5782      */
5783     shape: string;
5784     /** Sets or retrieves the window or frame at which to target content. */
5785     target: string;
5786     /** Retrieves or sets the text of the object as a string. */
5787     text: string;
5788     type: string;
5789     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLAnchorElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
5790     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
5791     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLAnchorElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
5792     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
5793 }
5794
5795 declare var HTMLAnchorElement: {
5796     prototype: HTMLAnchorElement;
5797     new(): HTMLAnchorElement;
5798 };
5799
5800 /** 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. */
5801 interface HTMLAreaElement extends HTMLElement, HTMLHyperlinkElementUtils {
5802     /** Sets or retrieves a text alternative to the graphic. */
5803     alt: string;
5804     /** Sets or retrieves the coordinates of the object. */
5805     coords: string;
5806     download: string;
5807     /**
5808      * Sets or gets whether clicks in this region cause action.
5809      * @deprecated
5810      */
5811     noHref: boolean;
5812     ping: string;
5813     referrerPolicy: string;
5814     rel: string;
5815     readonly relList: DOMTokenList;
5816     /** Sets or retrieves the shape of the object. */
5817     shape: string;
5818     /** Sets or retrieves the window or frame at which to target content. */
5819     target: string;
5820     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLAreaElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
5821     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
5822     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLAreaElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
5823     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
5824 }
5825
5826 declare var HTMLAreaElement: {
5827     prototype: HTMLAreaElement;
5828     new(): HTMLAreaElement;
5829 };
5830
5831 /** Provides access to the properties of <audio> elements, as well as methods to manipulate them. It derives from the HTMLMediaElement interface. */
5832 interface HTMLAudioElement extends HTMLMediaElement {
5833     addEventListener<K extends keyof HTMLMediaElementEventMap>(type: K, listener: (this: HTMLAudioElement, ev: HTMLMediaElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
5834     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
5835     removeEventListener<K extends keyof HTMLMediaElementEventMap>(type: K, listener: (this: HTMLAudioElement, ev: HTMLMediaElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
5836     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
5837 }
5838
5839 declare var HTMLAudioElement: {
5840     prototype: HTMLAudioElement;
5841     new(): HTMLAudioElement;
5842 };
5843
5844 /** A HTML line break element (<br>). It inherits from HTMLElement. */
5845 interface HTMLBRElement extends HTMLElement {
5846     /**
5847      * Sets or retrieves the side on which floating objects are not to be positioned when any IHTMLBlockElement is inserted into the document.
5848      * @deprecated
5849      */
5850     clear: string;
5851     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLBRElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
5852     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
5853     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLBRElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
5854     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
5855 }
5856
5857 declare var HTMLBRElement: {
5858     prototype: HTMLBRElement;
5859     new(): HTMLBRElement;
5860 };
5861
5862 /** Contains the base URI for a document. This object inherits all of the properties and methods as described in the HTMLElement interface. */
5863 interface HTMLBaseElement extends HTMLElement {
5864     /** Gets or sets the baseline URL on which relative links are based. */
5865     href: string;
5866     /** Sets or retrieves the window or frame at which to target content. */
5867     target: string;
5868     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLBaseElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
5869     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
5870     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLBaseElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
5871     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
5872 }
5873
5874 declare var HTMLBaseElement: {
5875     prototype: HTMLBaseElement;
5876     new(): HTMLBaseElement;
5877 };
5878
5879 interface HTMLBodyElementEventMap extends HTMLElementEventMap, WindowEventHandlersEventMap {
5880     "orientationchange": Event;
5881 }
5882
5883 /** Provides special properties (beyond those inherited from the regular HTMLElement interface) for manipulating <body> elements. */
5884 interface HTMLBodyElement extends HTMLElement, WindowEventHandlers {
5885     /** @deprecated */
5886     aLink: string;
5887     /** @deprecated */
5888     background: string;
5889     /** @deprecated */
5890     bgColor: string;
5891     /** @deprecated */
5892     link: string;
5893     /** @deprecated */
5894     onorientationchange: ((this: HTMLBodyElement, ev: Event) => any) | null;
5895     /** @deprecated */
5896     text: string;
5897     /** @deprecated */
5898     vLink: string;
5899     addEventListener<K extends keyof HTMLBodyElementEventMap>(type: K, listener: (this: HTMLBodyElement, ev: HTMLBodyElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
5900     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
5901     removeEventListener<K extends keyof HTMLBodyElementEventMap>(type: K, listener: (this: HTMLBodyElement, ev: HTMLBodyElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
5902     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
5903 }
5904
5905 declare var HTMLBodyElement: {
5906     prototype: HTMLBodyElement;
5907     new(): HTMLBodyElement;
5908 };
5909
5910 /** Provides properties and methods (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating <button> elements. */
5911 interface HTMLButtonElement extends HTMLElement {
5912     disabled: boolean;
5913     /** Retrieves a reference to the form that the object is embedded in. */
5914     readonly form: HTMLFormElement | null;
5915     /** Overrides the action attribute (where the data on a form is sent) on the parent form element. */
5916     formAction: string;
5917     /** Used to override the encoding (formEnctype attribute) specified on the form element. */
5918     formEnctype: string;
5919     /** Overrides the submit method attribute previously specified on a form element. */
5920     formMethod: string;
5921     /** 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. */
5922     formNoValidate: boolean;
5923     /** Overrides the target attribute on a form element. */
5924     formTarget: string;
5925     readonly labels: NodeListOf<HTMLLabelElement>;
5926     /** Sets or retrieves the name of the object. */
5927     name: string;
5928     /** Gets the classification and default behavior of the button. */
5929     type: string;
5930     /** 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. */
5931     readonly validationMessage: string;
5932     /** Returns a  ValidityState object that represents the validity states of an element. */
5933     readonly validity: ValidityState;
5934     /** Sets or retrieves the default or selected value of the control. */
5935     value: string;
5936     /** Returns whether an element will successfully validate based on forms validation rules and constraints. */
5937     readonly willValidate: boolean;
5938     /** Returns whether a form will validate when it is submitted, without having to submit it. */
5939     checkValidity(): boolean;
5940     reportValidity(): boolean;
5941     /**
5942      * Sets a custom error message that is displayed when a form is submitted.
5943      * @param error Sets a custom error message that is displayed when a form is submitted.
5944      */
5945     setCustomValidity(error: string): void;
5946     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLButtonElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
5947     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
5948     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLButtonElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
5949     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
5950 }
5951
5952 declare var HTMLButtonElement: {
5953     prototype: HTMLButtonElement;
5954     new(): HTMLButtonElement;
5955 };
5956
5957 /** 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. */
5958 interface HTMLCanvasElement extends HTMLElement {
5959     /** Gets or sets the height of a canvas element on a document. */
5960     height: number;
5961     /** Gets or sets the width of a canvas element on a document. */
5962     width: number;
5963     captureStream(frameRequestRate?: number): MediaStream;
5964     /**
5965      * 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.
5966      * @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");
5967      */
5968     getContext(contextId: "2d", options?: CanvasRenderingContext2DSettings): CanvasRenderingContext2D | null;
5969     getContext(contextId: "bitmaprenderer", options?: ImageBitmapRenderingContextSettings): ImageBitmapRenderingContext | null;
5970     getContext(contextId: "webgl", options?: WebGLContextAttributes): WebGLRenderingContext | null;
5971     getContext(contextId: "webgl2", options?: WebGLContextAttributes): WebGL2RenderingContext | null;
5972     getContext(contextId: string, options?: any): RenderingContext | null;
5973     toBlob(callback: BlobCallback, type?: string, quality?: any): void;
5974     /**
5975      * Returns the content of the current canvas as an image that you can use as a source for another canvas or an HTML element.
5976      * @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.
5977      */
5978     toDataURL(type?: string, quality?: any): string;
5979     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLCanvasElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
5980     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
5981     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLCanvasElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
5982     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
5983 }
5984
5985 declare var HTMLCanvasElement: {
5986     prototype: HTMLCanvasElement;
5987     new(): HTMLCanvasElement;
5988 };
5989
5990 /** A generic collection (array-like object similar to arguments) of elements (in document order) and offers methods and properties for selecting from the list. */
5991 interface HTMLCollectionBase {
5992     /** Sets or retrieves the number of objects in a collection. */
5993     readonly length: number;
5994     /** Retrieves an object from various collections. */
5995     item(index: number): Element | null;
5996     [index: number]: Element;
5997 }
5998
5999 interface HTMLCollection extends HTMLCollectionBase {
6000     /** Retrieves a select object or an object from an options collection. */
6001     namedItem(name: string): Element | null;
6002 }
6003
6004 declare var HTMLCollection: {
6005     prototype: HTMLCollection;
6006     new(): HTMLCollection;
6007 };
6008
6009 interface HTMLCollectionOf<T extends Element> extends HTMLCollectionBase {
6010     item(index: number): T | null;
6011     namedItem(name: string): T | null;
6012     [index: number]: T;
6013 }
6014
6015 /** Provides special properties (beyond those of the regular HTMLElement interface it also has available to it by inheritance) for manipulating definition list (<dl>) elements. */
6016 interface HTMLDListElement extends HTMLElement {
6017     /** @deprecated */
6018     compact: boolean;
6019     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDListElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6020     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6021     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDListElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6022     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6023 }
6024
6025 declare var HTMLDListElement: {
6026     prototype: HTMLDListElement;
6027     new(): HTMLDListElement;
6028 };
6029
6030 /** Provides special properties (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating <data> elements. */
6031 interface HTMLDataElement extends HTMLElement {
6032     value: string;
6033     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDataElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6034     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6035     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDataElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6036     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6037 }
6038
6039 declare var HTMLDataElement: {
6040     prototype: HTMLDataElement;
6041     new(): HTMLDataElement;
6042 };
6043
6044 /** Provides special properties (beyond the HTMLElement object interface it also has available to it by inheritance) to manipulate <datalist> elements and their content. */
6045 interface HTMLDataListElement extends HTMLElement {
6046     /** Returns an HTMLCollection of the option elements of the datalist element. */
6047     readonly options: HTMLCollectionOf<HTMLOptionElement>;
6048     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDataListElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6049     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6050     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDataListElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6051     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6052 }
6053
6054 declare var HTMLDataListElement: {
6055     prototype: HTMLDataListElement;
6056     new(): HTMLDataListElement;
6057 };
6058
6059 interface HTMLDetailsElement extends HTMLElement {
6060     open: boolean;
6061     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDetailsElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6062     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6063     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDetailsElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6064     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6065 }
6066
6067 declare var HTMLDetailsElement: {
6068     prototype: HTMLDetailsElement;
6069     new(): HTMLDetailsElement;
6070 };
6071
6072 /** @deprecated this is not available in most browsers */
6073 interface HTMLDialogElement extends HTMLElement {
6074     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDialogElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6075     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6076     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDialogElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6077     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6078 }
6079
6080 /** @deprecated */
6081 interface HTMLDirectoryElement extends HTMLElement {
6082     /** @deprecated */
6083     compact: boolean;
6084     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDirectoryElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6085     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6086     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDirectoryElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6087     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6088 }
6089
6090 /** @deprecated */
6091 declare var HTMLDirectoryElement: {
6092     prototype: HTMLDirectoryElement;
6093     new(): HTMLDirectoryElement;
6094 };
6095
6096 /** Provides special properties (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating <div> elements. */
6097 interface HTMLDivElement extends HTMLElement {
6098     /**
6099      * Sets or retrieves how the object is aligned with adjacent text.
6100      * @deprecated
6101      */
6102     align: string;
6103     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDivElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6104     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6105     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDivElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6106     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6107 }
6108
6109 declare var HTMLDivElement: {
6110     prototype: HTMLDivElement;
6111     new(): HTMLDivElement;
6112 };
6113
6114 /** @deprecated use Document */
6115 interface HTMLDocument extends Document {
6116     addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: HTMLDocument, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6117     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6118     removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: HTMLDocument, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6119     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6120 }
6121
6122 /** @deprecated */
6123 declare var HTMLDocument: {
6124     prototype: HTMLDocument;
6125     new(): HTMLDocument;
6126 };
6127
6128 interface HTMLElementEventMap extends ElementEventMap, DocumentAndElementEventHandlersEventMap, GlobalEventHandlersEventMap {
6129 }
6130
6131 /** Any HTML element. Some elements directly implement this interface, while others implement it via an interface that inherits it. */
6132 interface HTMLElement extends Element, DocumentAndElementEventHandlers, ElementCSSInlineStyle, ElementContentEditable, GlobalEventHandlers, HTMLOrSVGElement {
6133     accessKey: string;
6134     readonly accessKeyLabel: string;
6135     autocapitalize: string;
6136     dir: string;
6137     draggable: boolean;
6138     hidden: boolean;
6139     innerText: string;
6140     lang: string;
6141     readonly offsetHeight: number;
6142     readonly offsetLeft: number;
6143     readonly offsetParent: Element | null;
6144     readonly offsetTop: number;
6145     readonly offsetWidth: number;
6146     outerText: string;
6147     spellcheck: boolean;
6148     title: string;
6149     translate: boolean;
6150     attachInternals(): ElementInternals;
6151     click(): void;
6152     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6153     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6154     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6155     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6156 }
6157
6158 declare var HTMLElement: {
6159     prototype: HTMLElement;
6160     new(): HTMLElement;
6161 };
6162
6163 /** Provides special properties (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating <embed> elements. */
6164 interface HTMLEmbedElement extends HTMLElement {
6165     /** @deprecated */
6166     align: string;
6167     /** Sets or retrieves the height of the object. */
6168     height: string;
6169     /**
6170      * Sets or retrieves the name of the object.
6171      * @deprecated
6172      */
6173     name: string;
6174     /** Sets or retrieves a URL to be loaded by the object. */
6175     src: string;
6176     type: string;
6177     /** Sets or retrieves the width of the object. */
6178     width: string;
6179     getSVGDocument(): Document | null;
6180     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLEmbedElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6181     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6182     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLEmbedElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6183     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6184 }
6185
6186 declare var HTMLEmbedElement: {
6187     prototype: HTMLEmbedElement;
6188     new(): HTMLEmbedElement;
6189 };
6190
6191 /** 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. */
6192 interface HTMLFieldSetElement extends HTMLElement {
6193     disabled: boolean;
6194     /** Returns an HTMLCollection of the form controls in the element. */
6195     readonly elements: HTMLCollection;
6196     /** Retrieves a reference to the form that the object is embedded in. */
6197     readonly form: HTMLFormElement | null;
6198     name: string;
6199     /** Returns the string "fieldset". */
6200     readonly type: string;
6201     /** 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. */
6202     readonly validationMessage: string;
6203     /** Returns a  ValidityState object that represents the validity states of an element. */
6204     readonly validity: ValidityState;
6205     /** Returns whether an element will successfully validate based on forms validation rules and constraints. */
6206     readonly willValidate: boolean;
6207     /** Returns whether a form will validate when it is submitted, without having to submit it. */
6208     checkValidity(): boolean;
6209     reportValidity(): boolean;
6210     /**
6211      * Sets a custom error message that is displayed when a form is submitted.
6212      * @param error Sets a custom error message that is displayed when a form is submitted.
6213      */
6214     setCustomValidity(error: string): void;
6215     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLFieldSetElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6216     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6217     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLFieldSetElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6218     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6219 }
6220
6221 declare var HTMLFieldSetElement: {
6222     prototype: HTMLFieldSetElement;
6223     new(): HTMLFieldSetElement;
6224 };
6225
6226 /**
6227  * 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.
6228  * @deprecated
6229  */
6230 interface HTMLFontElement extends HTMLElement {
6231     /** @deprecated */
6232     color: string;
6233     /**
6234      * Sets or retrieves the current typeface family.
6235      * @deprecated
6236      */
6237     face: string;
6238     /** @deprecated */
6239     size: string;
6240     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLFontElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6241     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6242     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLFontElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6243     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6244 }
6245
6246 /** @deprecated */
6247 declare var HTMLFontElement: {
6248     prototype: HTMLFontElement;
6249     new(): HTMLFontElement;
6250 };
6251
6252 /** A collection of HTML form control elements.  */
6253 interface HTMLFormControlsCollection extends HTMLCollectionBase {
6254     /**
6255      * Returns the item with ID or name name from the collection.
6256      *
6257      * If there are multiple matching items, then a RadioNodeList object containing all those elements is returned.
6258      */
6259     namedItem(name: string): RadioNodeList | Element | null;
6260 }
6261
6262 declare var HTMLFormControlsCollection: {
6263     prototype: HTMLFormControlsCollection;
6264     new(): HTMLFormControlsCollection;
6265 };
6266
6267 /** 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. */
6268 interface HTMLFormElement extends HTMLElement {
6269     /** Sets or retrieves a list of character encodings for input data that must be accepted by the server processing the form. */
6270     acceptCharset: string;
6271     /** Sets or retrieves the URL to which the form content is sent for processing. */
6272     action: string;
6273     /** Specifies whether autocomplete is applied to an editable text field. */
6274     autocomplete: string;
6275     /** Retrieves a collection, in source order, of all controls in a given form. */
6276     readonly elements: HTMLFormControlsCollection;
6277     /** Sets or retrieves the MIME encoding for the form. */
6278     encoding: string;
6279     /** Sets or retrieves the encoding type for the form. */
6280     enctype: string;
6281     /** Sets or retrieves the number of objects in a collection. */
6282     readonly length: number;
6283     /** Sets or retrieves how to send the form data to the server. */
6284     method: string;
6285     /** Sets or retrieves the name of the object. */
6286     name: string;
6287     /** Designates a form that is not validated when submitted. */
6288     noValidate: boolean;
6289     /** Sets or retrieves the window or frame at which to target content. */
6290     target: string;
6291     /** Returns whether a form will validate when it is submitted, without having to submit it. */
6292     checkValidity(): boolean;
6293     reportValidity(): boolean;
6294     requestSubmit(submitter?: HTMLElement | null): void;
6295     /** Fires when the user resets a form. */
6296     reset(): void;
6297     /** Fires when a FORM is about to be submitted. */
6298     submit(): void;
6299     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLFormElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6300     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6301     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLFormElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6302     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6303     [index: number]: Element;
6304     [name: string]: any;
6305 }
6306
6307 declare var HTMLFormElement: {
6308     prototype: HTMLFormElement;
6309     new(): HTMLFormElement;
6310 };
6311
6312 /** @deprecated */
6313 interface HTMLFrameElement extends HTMLElement {
6314     /**
6315      * Retrieves the document object of the page or frame.
6316      * @deprecated
6317      */
6318     readonly contentDocument: Document | null;
6319     /**
6320      * Retrieves the object of the specified.
6321      * @deprecated
6322      */
6323     readonly contentWindow: WindowProxy | null;
6324     /**
6325      * Sets or retrieves whether to display a border for the frame.
6326      * @deprecated
6327      */
6328     frameBorder: string;
6329     /**
6330      * Sets or retrieves a URI to a long description of the object.
6331      * @deprecated
6332      */
6333     longDesc: string;
6334     /**
6335      * Sets or retrieves the top and bottom margin heights before displaying the text in a frame.
6336      * @deprecated
6337      */
6338     marginHeight: string;
6339     /**
6340      * Sets or retrieves the left and right margin widths before displaying the text in a frame.
6341      * @deprecated
6342      */
6343     marginWidth: string;
6344     /**
6345      * Sets or retrieves the frame name.
6346      * @deprecated
6347      */
6348     name: string;
6349     /**
6350      * Sets or retrieves whether the user can resize the frame.
6351      * @deprecated
6352      */
6353     noResize: boolean;
6354     /**
6355      * Sets or retrieves whether the frame can be scrolled.
6356      * @deprecated
6357      */
6358     scrolling: string;
6359     /**
6360      * Sets or retrieves a URL to be loaded by the object.
6361      * @deprecated
6362      */
6363     src: string;
6364     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLFrameElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6365     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6366     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLFrameElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6367     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6368 }
6369
6370 /** @deprecated */
6371 declare var HTMLFrameElement: {
6372     prototype: HTMLFrameElement;
6373     new(): HTMLFrameElement;
6374 };
6375
6376 interface HTMLFrameSetElementEventMap extends HTMLElementEventMap, WindowEventHandlersEventMap {
6377 }
6378
6379 /**
6380  * Provides special properties (beyond those of the regular HTMLElement interface they also inherit) for manipulating <frameset> elements.
6381  * @deprecated
6382  */
6383 interface HTMLFrameSetElement extends HTMLElement, WindowEventHandlers {
6384     /**
6385      * Sets or retrieves the frame widths of the object.
6386      * @deprecated
6387      */
6388     cols: string;
6389     /**
6390      * Sets or retrieves the frame heights of the object.
6391      * @deprecated
6392      */
6393     rows: string;
6394     addEventListener<K extends keyof HTMLFrameSetElementEventMap>(type: K, listener: (this: HTMLFrameSetElement, ev: HTMLFrameSetElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6395     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6396     removeEventListener<K extends keyof HTMLFrameSetElementEventMap>(type: K, listener: (this: HTMLFrameSetElement, ev: HTMLFrameSetElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6397     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6398 }
6399
6400 /** @deprecated */
6401 declare var HTMLFrameSetElement: {
6402     prototype: HTMLFrameSetElement;
6403     new(): HTMLFrameSetElement;
6404 };
6405
6406 /** Provides special properties (beyond those of the HTMLElement interface it also has available to it by inheritance) for manipulating <hr> elements. */
6407 interface HTMLHRElement extends HTMLElement {
6408     /**
6409      * Sets or retrieves how the object is aligned with adjacent text.
6410      * @deprecated
6411      */
6412     align: string;
6413     /** @deprecated */
6414     color: string;
6415     /**
6416      * Sets or retrieves whether the horizontal rule is drawn with 3-D shading.
6417      * @deprecated
6418      */
6419     noShade: boolean;
6420     /** @deprecated */
6421     size: string;
6422     /**
6423      * Sets or retrieves the width of the object.
6424      * @deprecated
6425      */
6426     width: string;
6427     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLHRElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6428     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6429     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLHRElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6430     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6431 }
6432
6433 declare var HTMLHRElement: {
6434     prototype: HTMLHRElement;
6435     new(): HTMLHRElement;
6436 };
6437
6438 /** Contains the descriptive information, or metadata, for a document. This object inherits all of the properties and methods described in the HTMLElement interface. */
6439 interface HTMLHeadElement extends HTMLElement {
6440     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLHeadElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6441     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6442     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLHeadElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6443     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6444 }
6445
6446 declare var HTMLHeadElement: {
6447     prototype: HTMLHeadElement;
6448     new(): HTMLHeadElement;
6449 };
6450
6451 /** The different heading elements. It inherits methods and properties from the HTMLElement interface. */
6452 interface HTMLHeadingElement extends HTMLElement {
6453     /**
6454      * Sets or retrieves a value that indicates the table alignment.
6455      * @deprecated
6456      */
6457     align: string;
6458     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLHeadingElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6459     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6460     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLHeadingElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6461     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6462 }
6463
6464 declare var HTMLHeadingElement: {
6465     prototype: HTMLHeadingElement;
6466     new(): HTMLHeadingElement;
6467 };
6468
6469 /** Serves as the root node for a given HTML document. This object inherits the properties and methods described in the HTMLElement interface. */
6470 interface HTMLHtmlElement extends HTMLElement {
6471     /**
6472      * Sets or retrieves the DTD version that governs the current document.
6473      * @deprecated
6474      */
6475     version: string;
6476     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLHtmlElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6477     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6478     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLHtmlElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6479     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6480 }
6481
6482 declare var HTMLHtmlElement: {
6483     prototype: HTMLHtmlElement;
6484     new(): HTMLHtmlElement;
6485 };
6486
6487 interface HTMLHyperlinkElementUtils {
6488     /**
6489      * Returns the hyperlink's URL's fragment (includes leading "#" if non-empty).
6490      *
6491      * Can be set, to change the URL's fragment (ignores leading "#").
6492      */
6493     hash: string;
6494     /**
6495      * Returns the hyperlink's URL's host and port (if different from the default port for the scheme).
6496      *
6497      * Can be set, to change the URL's host and port.
6498      */
6499     host: string;
6500     /**
6501      * Returns the hyperlink's URL's host.
6502      *
6503      * Can be set, to change the URL's host.
6504      */
6505     hostname: string;
6506     /**
6507      * Returns the hyperlink's URL.
6508      *
6509      * Can be set, to change the URL.
6510      */
6511     href: string;
6512     toString(): string;
6513     /** Returns the hyperlink's URL's origin. */
6514     readonly origin: string;
6515     /**
6516      * Returns the hyperlink's URL's password.
6517      *
6518      * Can be set, to change the URL's password.
6519      */
6520     password: string;
6521     /**
6522      * Returns the hyperlink's URL's path.
6523      *
6524      * Can be set, to change the URL's path.
6525      */
6526     pathname: string;
6527     /**
6528      * Returns the hyperlink's URL's port.
6529      *
6530      * Can be set, to change the URL's port.
6531      */
6532     port: string;
6533     /**
6534      * Returns the hyperlink's URL's scheme.
6535      *
6536      * Can be set, to change the URL's scheme.
6537      */
6538     protocol: string;
6539     /**
6540      * Returns the hyperlink's URL's query (includes leading "?" if non-empty).
6541      *
6542      * Can be set, to change the URL's query (ignores leading "?").
6543      */
6544     search: string;
6545     /**
6546      * Returns the hyperlink's URL's username.
6547      *
6548      * Can be set, to change the URL's username.
6549      */
6550     username: string;
6551 }
6552
6553 /** 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. */
6554 interface HTMLIFrameElement extends HTMLElement {
6555     /**
6556      * Sets or retrieves how the object is aligned with adjacent text.
6557      * @deprecated
6558      */
6559     align: string;
6560     allow: string;
6561     allowFullscreen: boolean;
6562     /** Retrieves the document object of the page or frame. */
6563     readonly contentDocument: Document | null;
6564     /** Retrieves the object of the specified. */
6565     readonly contentWindow: WindowProxy | null;
6566     /**
6567      * Sets or retrieves whether to display a border for the frame.
6568      * @deprecated
6569      */
6570     frameBorder: string;
6571     /** Sets or retrieves the height of the object. */
6572     height: string;
6573     /**
6574      * Sets or retrieves a URI to a long description of the object.
6575      * @deprecated
6576      */
6577     longDesc: string;
6578     /**
6579      * Sets or retrieves the top and bottom margin heights before displaying the text in a frame.
6580      * @deprecated
6581      */
6582     marginHeight: string;
6583     /**
6584      * Sets or retrieves the left and right margin widths before displaying the text in a frame.
6585      * @deprecated
6586      */
6587     marginWidth: string;
6588     /** Sets or retrieves the frame name. */
6589     name: string;
6590     referrerPolicy: ReferrerPolicy;
6591     readonly sandbox: DOMTokenList;
6592     /**
6593      * Sets or retrieves whether the frame can be scrolled.
6594      * @deprecated
6595      */
6596     scrolling: string;
6597     /** Sets or retrieves a URL to be loaded by the object. */
6598     src: string;
6599     /** Sets or retrives the content of the page that is to contain. */
6600     srcdoc: string;
6601     /** Sets or retrieves the width of the object. */
6602     width: string;
6603     getSVGDocument(): Document | null;
6604     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLIFrameElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6605     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6606     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLIFrameElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6607     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6608 }
6609
6610 declare var HTMLIFrameElement: {
6611     prototype: HTMLIFrameElement;
6612     new(): HTMLIFrameElement;
6613 };
6614
6615 /** Provides special properties and methods for manipulating <img> elements. */
6616 interface HTMLImageElement extends HTMLElement {
6617     /**
6618      * Sets or retrieves how the object is aligned with adjacent text.
6619      * @deprecated
6620      */
6621     align: string;
6622     /** Sets or retrieves a text alternative to the graphic. */
6623     alt: string;
6624     /**
6625      * Specifies the properties of a border drawn around an object.
6626      * @deprecated
6627      */
6628     border: string;
6629     /** Retrieves whether the object is fully loaded. */
6630     readonly complete: boolean;
6631     crossOrigin: string | null;
6632     readonly currentSrc: string;
6633     decoding: "async" | "sync" | "auto";
6634     /** Sets or retrieves the height of the object. */
6635     height: number;
6636     /**
6637      * Sets or retrieves the width of the border to draw around the object.
6638      * @deprecated
6639      */
6640     hspace: number;
6641     /** Sets or retrieves whether the image is a server-side image map. */
6642     isMap: boolean;
6643     loading: string;
6644     /**
6645      * Sets or retrieves a Uniform Resource Identifier (URI) to a long description of the object.
6646      * @deprecated
6647      */
6648     longDesc: string;
6649     /** @deprecated */
6650     lowsrc: string;
6651     /**
6652      * Sets or retrieves the name of the object.
6653      * @deprecated
6654      */
6655     name: string;
6656     /** The original height of the image resource before sizing. */
6657     readonly naturalHeight: number;
6658     /** The original width of the image resource before sizing. */
6659     readonly naturalWidth: number;
6660     referrerPolicy: string;
6661     sizes: string;
6662     /** The address or URL of the a media resource that is to be considered. */
6663     src: string;
6664     srcset: string;
6665     /** Sets or retrieves the URL, often with a bookmark extension (#name), to use as a client-side image map. */
6666     useMap: string;
6667     /**
6668      * Sets or retrieves the vertical margin for the object.
6669      * @deprecated
6670      */
6671     vspace: number;
6672     /** Sets or retrieves the width of the object. */
6673     width: number;
6674     readonly x: number;
6675     readonly y: number;
6676     decode(): Promise<void>;
6677     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLImageElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6678     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6679     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLImageElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6680     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6681 }
6682
6683 declare var HTMLImageElement: {
6684     prototype: HTMLImageElement;
6685     new(): HTMLImageElement;
6686 };
6687
6688 /** Provides special properties and methods for manipulating the options, layout, and presentation of <input> elements. */
6689 interface HTMLInputElement extends HTMLElement {
6690     /** Sets or retrieves a comma-separated list of content types. */
6691     accept: string;
6692     /**
6693      * Sets or retrieves how the object is aligned with adjacent text.
6694      * @deprecated
6695      */
6696     align: string;
6697     /** Sets or retrieves a text alternative to the graphic. */
6698     alt: string;
6699     /** Specifies whether autocomplete is applied to an editable text field. */
6700     autocomplete: string;
6701     capture: string;
6702     /** Sets or retrieves the state of the check box or radio button. */
6703     checked: boolean;
6704     /** Sets or retrieves the state of the check box or radio button. */
6705     defaultChecked: boolean;
6706     /** Sets or retrieves the initial contents of the object. */
6707     defaultValue: string;
6708     dirName: string;
6709     disabled: boolean;
6710     /** Returns a FileList object on a file type input object. */
6711     files: FileList | null;
6712     /** Retrieves a reference to the form that the object is embedded in. */
6713     readonly form: HTMLFormElement | null;
6714     /** Overrides the action attribute (where the data on a form is sent) on the parent form element. */
6715     formAction: string;
6716     /** Used to override the encoding (formEnctype attribute) specified on the form element. */
6717     formEnctype: string;
6718     /** Overrides the submit method attribute previously specified on a form element. */
6719     formMethod: string;
6720     /** 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. */
6721     formNoValidate: boolean;
6722     /** Overrides the target attribute on a form element. */
6723     formTarget: string;
6724     /** Sets or retrieves the height of the object. */
6725     height: number;
6726     /** When set, overrides the rendering of checkbox controls so that the current value is not visible. */
6727     indeterminate: boolean;
6728     readonly labels: NodeListOf<HTMLLabelElement> | null;
6729     /** Specifies the ID of a pre-defined datalist of options for an input element. */
6730     readonly list: HTMLElement | null;
6731     /** 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. */
6732     max: string;
6733     /** Sets or retrieves the maximum number of characters that the user can enter in a text control. */
6734     maxLength: number;
6735     /** 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. */
6736     min: string;
6737     minLength: number;
6738     /** Sets or retrieves the Boolean value indicating whether multiple items can be selected from a list. */
6739     multiple: boolean;
6740     /** Sets or retrieves the name of the object. */
6741     name: string;
6742     /** Gets or sets a string containing a regular expression that the user's input must match. */
6743     pattern: string;
6744     /** 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. */
6745     placeholder: string;
6746     readOnly: boolean;
6747     /** When present, marks an element that can't be submitted without a value. */
6748     required: boolean;
6749     selectionDirection: "forward" | "backward" | "none" | null;
6750     /** Gets or sets the end position or offset of a text selection. */
6751     selectionEnd: number | null;
6752     /** Gets or sets the starting position or offset of a text selection. */
6753     selectionStart: number | null;
6754     size: number;
6755     /** The address or URL of the a media resource that is to be considered. */
6756     src: string;
6757     /** 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. */
6758     step: string;
6759     /** Returns the content type of the object. */
6760     type: string;
6761     /**
6762      * Sets or retrieves the URL, often with a bookmark extension (#name), to use as a client-side image map.
6763      * @deprecated
6764      */
6765     useMap: string;
6766     /** 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. */
6767     readonly validationMessage: string;
6768     /** Returns a  ValidityState object that represents the validity states of an element. */
6769     readonly validity: ValidityState;
6770     /** Returns the value of the data at the cursor's current position. */
6771     value: string;
6772     /** 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. */
6773     valueAsDate: Date | null;
6774     /** Returns the input field value as a number. */
6775     valueAsNumber: number;
6776     readonly webkitEntries: ReadonlyArray<FileSystemEntry>;
6777     webkitdirectory: boolean;
6778     /** Sets or retrieves the width of the object. */
6779     width: number;
6780     /** Returns whether an element will successfully validate based on forms validation rules and constraints. */
6781     readonly willValidate: boolean;
6782     /** Returns whether a form will validate when it is submitted, without having to submit it. */
6783     checkValidity(): boolean;
6784     reportValidity(): boolean;
6785     /** Makes the selection equal to the current object. */
6786     select(): void;
6787     /**
6788      * Sets a custom error message that is displayed when a form is submitted.
6789      * @param error Sets a custom error message that is displayed when a form is submitted.
6790      */
6791     setCustomValidity(error: string): void;
6792     setRangeText(replacement: string): void;
6793     setRangeText(replacement: string, start: number, end: number, selectionMode?: SelectionMode): void;
6794     /**
6795      * Sets the start and end positions of a selection in a text field.
6796      * @param start The offset into the text field for the start of the selection.
6797      * @param end The offset into the text field for the end of the selection.
6798      * @param direction The direction in which the selection is performed.
6799      */
6800     setSelectionRange(start: number | null, end: number | null, direction?: "forward" | "backward" | "none"): void;
6801     /**
6802      * 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.
6803      * @param n Value to decrement the value by.
6804      */
6805     stepDown(n?: number): void;
6806     /**
6807      * 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.
6808      * @param n Value to increment the value by.
6809      */
6810     stepUp(n?: number): void;
6811     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLInputElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6812     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6813     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLInputElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6814     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6815 }
6816
6817 declare var HTMLInputElement: {
6818     prototype: HTMLInputElement;
6819     new(): HTMLInputElement;
6820 };
6821
6822 /** Exposes specific properties and methods (beyond those defined by regular HTMLElement interface it also has available to it by inheritance) for manipulating list elements. */
6823 interface HTMLLIElement extends HTMLElement {
6824     /** @deprecated */
6825     type: string;
6826     /** Sets or retrieves the value of a list item. */
6827     value: number;
6828     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLLIElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6829     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6830     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLLIElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6831     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6832 }
6833
6834 declare var HTMLLIElement: {
6835     prototype: HTMLLIElement;
6836     new(): HTMLLIElement;
6837 };
6838
6839 /** Gives access to properties specific to <label> elements. It inherits methods and properties from the base HTMLElement interface. */
6840 interface HTMLLabelElement extends HTMLElement {
6841     /** Returns the form control that is associated with this element. */
6842     readonly control: HTMLElement | null;
6843     /** Retrieves a reference to the form that the object is embedded in. */
6844     readonly form: HTMLFormElement | null;
6845     /** Sets or retrieves the object to which the given label object is assigned. */
6846     htmlFor: string;
6847     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLLabelElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6848     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6849     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLLabelElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6850     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6851 }
6852
6853 declare var HTMLLabelElement: {
6854     prototype: HTMLLabelElement;
6855     new(): HTMLLabelElement;
6856 };
6857
6858 /** The HTMLLegendElement is an interface allowing to access properties of the <legend> elements. It inherits properties and methods from the HTMLElement interface. */
6859 interface HTMLLegendElement extends HTMLElement {
6860     /** @deprecated */
6861     align: string;
6862     /** Retrieves a reference to the form that the object is embedded in. */
6863     readonly form: HTMLFormElement | null;
6864     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLLegendElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6865     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6866     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLLegendElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6867     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6868 }
6869
6870 declare var HTMLLegendElement: {
6871     prototype: HTMLLegendElement;
6872     new(): HTMLLegendElement;
6873 };
6874
6875 /** 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. */
6876 interface HTMLLinkElement extends HTMLElement, LinkStyle {
6877     as: string;
6878     /**
6879      * Sets or retrieves the character set used to encode the object.
6880      * @deprecated
6881      */
6882     charset: string;
6883     crossOrigin: string | null;
6884     disabled: boolean;
6885     /** Sets or retrieves a destination URL or an anchor point. */
6886     href: string;
6887     /** Sets or retrieves the language code of the object. */
6888     hreflang: string;
6889     imageSizes: string;
6890     imageSrcset: string;
6891     integrity: string;
6892     /** Sets or retrieves the media type. */
6893     media: string;
6894     referrerPolicy: string;
6895     /** Sets or retrieves the relationship between the object and the destination of the link. */
6896     rel: string;
6897     readonly relList: DOMTokenList;
6898     /**
6899      * Sets or retrieves the relationship between the object and the destination of the link.
6900      * @deprecated
6901      */
6902     rev: string;
6903     readonly sizes: DOMTokenList;
6904     /**
6905      * Sets or retrieves the window or frame at which to target content.
6906      * @deprecated
6907      */
6908     target: string;
6909     /** Sets or retrieves the MIME type of the object. */
6910     type: string;
6911     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLLinkElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6912     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6913     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLLinkElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6914     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6915 }
6916
6917 declare var HTMLLinkElement: {
6918     prototype: HTMLLinkElement;
6919     new(): HTMLLinkElement;
6920 };
6921
6922 /** 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. */
6923 interface HTMLMapElement extends HTMLElement {
6924     /** Retrieves a collection of the area objects defined for the given map object. */
6925     readonly areas: HTMLCollection;
6926     /** Sets or retrieves the name of the object. */
6927     name: string;
6928     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLMapElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6929     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6930     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLMapElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6931     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6932 }
6933
6934 declare var HTMLMapElement: {
6935     prototype: HTMLMapElement;
6936     new(): HTMLMapElement;
6937 };
6938
6939 /**
6940  * Provides methods to manipulate <marquee> elements.
6941  * @deprecated
6942  */
6943 interface HTMLMarqueeElement extends HTMLElement {
6944     /** @deprecated */
6945     behavior: string;
6946     /** @deprecated */
6947     bgColor: string;
6948     /** @deprecated */
6949     direction: string;
6950     /** @deprecated */
6951     height: string;
6952     /** @deprecated */
6953     hspace: number;
6954     /** @deprecated */
6955     loop: number;
6956     /** @deprecated */
6957     scrollAmount: number;
6958     /** @deprecated */
6959     scrollDelay: number;
6960     /** @deprecated */
6961     trueSpeed: boolean;
6962     /** @deprecated */
6963     vspace: number;
6964     /** @deprecated */
6965     width: string;
6966     /** @deprecated */
6967     start(): void;
6968     /** @deprecated */
6969     stop(): void;
6970     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLMarqueeElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6971     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6972     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLMarqueeElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6973     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6974 }
6975
6976 /** @deprecated */
6977 declare var HTMLMarqueeElement: {
6978     prototype: HTMLMarqueeElement;
6979     new(): HTMLMarqueeElement;
6980 };
6981
6982 interface HTMLMediaElementEventMap extends HTMLElementEventMap {
6983     "encrypted": MediaEncryptedEvent;
6984     "waitingforkey": Event;
6985 }
6986
6987 /** Adds to HTMLElement the properties and methods needed to support basic media-related capabilities that are common to audio and video. */
6988 interface HTMLMediaElement extends HTMLElement {
6989     /** Gets or sets a value that indicates whether to start playing the media automatically. */
6990     autoplay: boolean;
6991     /** Gets a collection of buffered time ranges. */
6992     readonly buffered: TimeRanges;
6993     /** 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). */
6994     controls: boolean;
6995     crossOrigin: string | null;
6996     /** Gets the address or URL of the current media resource that is selected by IHTMLMediaElement. */
6997     readonly currentSrc: string;
6998     /** Gets or sets the current playback position, in seconds. */
6999     currentTime: number;
7000     defaultMuted: boolean;
7001     /** Gets or sets the default playback rate when the user is not using fast forward or reverse for a video or audio resource. */
7002     defaultPlaybackRate: number;
7003     disableRemotePlayback: boolean;
7004     /** 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. */
7005     readonly duration: number;
7006     /** Gets information about whether the playback has ended or not. */
7007     readonly ended: boolean;
7008     /** Returns an object representing the current error state of the audio or video element. */
7009     readonly error: MediaError | null;
7010     /** Gets or sets a flag to specify whether playback should restart after it completes. */
7011     loop: boolean;
7012     /** Available only in secure contexts. */
7013     readonly mediaKeys: MediaKeys | null;
7014     /** Gets or sets a flag that indicates whether the audio (either audio or the audio track on video media) is muted. */
7015     muted: boolean;
7016     /** Gets the current network activity for the element. */
7017     readonly networkState: number;
7018     onencrypted: ((this: HTMLMediaElement, ev: MediaEncryptedEvent) => any) | null;
7019     onwaitingforkey: ((this: HTMLMediaElement, ev: Event) => any) | null;
7020     /** Gets a flag that specifies whether playback is paused. */
7021     readonly paused: boolean;
7022     /** 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. */
7023     playbackRate: number;
7024     /** Gets TimeRanges for the current media resource that has been played. */
7025     readonly played: TimeRanges;
7026     /** Gets or sets a value indicating what data should be preloaded, if any. */
7027     preload: "none" | "metadata" | "auto" | "";
7028     readonly readyState: number;
7029     readonly remote: RemotePlayback;
7030     /** Returns a TimeRanges object that represents the ranges of the current media resource that can be seeked. */
7031     readonly seekable: TimeRanges;
7032     /** Gets a flag that indicates whether the client is currently moving to a new playback position in the media resource. */
7033     readonly seeking: boolean;
7034     /** The address or URL of the a media resource that is to be considered. */
7035     src: string;
7036     srcObject: MediaProvider | null;
7037     readonly textTracks: TextTrackList;
7038     /** Gets or sets the volume level for audio portions of the media element. */
7039     volume: number;
7040     addTextTrack(kind: TextTrackKind, label?: string, language?: string): TextTrack;
7041     /** Returns a string that specifies whether the client can play a given media resource type. */
7042     canPlayType(type: string): CanPlayTypeResult;
7043     fastSeek(time: number): void;
7044     /** Resets the audio or video object and loads a new media resource. */
7045     load(): void;
7046     /** 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. */
7047     pause(): void;
7048     /** Loads and starts playback of a media resource. */
7049     play(): Promise<void>;
7050     /** Available only in secure contexts. */
7051     setMediaKeys(mediaKeys: MediaKeys | null): Promise<void>;
7052     readonly HAVE_CURRENT_DATA: number;
7053     readonly HAVE_ENOUGH_DATA: number;
7054     readonly HAVE_FUTURE_DATA: number;
7055     readonly HAVE_METADATA: number;
7056     readonly HAVE_NOTHING: number;
7057     readonly NETWORK_EMPTY: number;
7058     readonly NETWORK_IDLE: number;
7059     readonly NETWORK_LOADING: number;
7060     readonly NETWORK_NO_SOURCE: number;
7061     addEventListener<K extends keyof HTMLMediaElementEventMap>(type: K, listener: (this: HTMLMediaElement, ev: HTMLMediaElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7062     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7063     removeEventListener<K extends keyof HTMLMediaElementEventMap>(type: K, listener: (this: HTMLMediaElement, ev: HTMLMediaElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7064     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7065 }
7066
7067 declare var HTMLMediaElement: {
7068     prototype: HTMLMediaElement;
7069     new(): HTMLMediaElement;
7070     readonly HAVE_CURRENT_DATA: number;
7071     readonly HAVE_ENOUGH_DATA: number;
7072     readonly HAVE_FUTURE_DATA: number;
7073     readonly HAVE_METADATA: number;
7074     readonly HAVE_NOTHING: number;
7075     readonly NETWORK_EMPTY: number;
7076     readonly NETWORK_IDLE: number;
7077     readonly NETWORK_LOADING: number;
7078     readonly NETWORK_NO_SOURCE: number;
7079 };
7080
7081 interface HTMLMenuElement extends HTMLElement {
7082     /** @deprecated */
7083     compact: boolean;
7084     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLMenuElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7085     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7086     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLMenuElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7087     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7088 }
7089
7090 declare var HTMLMenuElement: {
7091     prototype: HTMLMenuElement;
7092     new(): HTMLMenuElement;
7093 };
7094
7095 /** Contains descriptive metadata about a document. It inherits all of the properties and methods described in the HTMLElement interface. */
7096 interface HTMLMetaElement extends HTMLElement {
7097     /** Gets or sets meta-information to associate with httpEquiv or name. */
7098     content: string;
7099     /** Gets or sets information used to bind the value of a content attribute of a meta element to an HTTP response header. */
7100     httpEquiv: string;
7101     /** Sets or retrieves the value specified in the content attribute of the meta object. */
7102     name: string;
7103     /**
7104      * Sets or retrieves a scheme to be used in interpreting the value of a property specified for the object.
7105      * @deprecated
7106      */
7107     scheme: string;
7108     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLMetaElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7109     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7110     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLMetaElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7111     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7112 }
7113
7114 declare var HTMLMetaElement: {
7115     prototype: HTMLMetaElement;
7116     new(): HTMLMetaElement;
7117 };
7118
7119 /** 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. */
7120 interface HTMLMeterElement extends HTMLElement {
7121     high: number;
7122     readonly labels: NodeListOf<HTMLLabelElement>;
7123     low: number;
7124     max: number;
7125     min: number;
7126     optimum: number;
7127     value: number;
7128     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLMeterElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7129     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7130     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLMeterElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7131     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7132 }
7133
7134 declare var HTMLMeterElement: {
7135     prototype: HTMLMeterElement;
7136     new(): HTMLMeterElement;
7137 };
7138
7139 /** 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>. */
7140 interface HTMLModElement extends HTMLElement {
7141     /** Sets or retrieves reference information about the object. */
7142     cite: string;
7143     /** Sets or retrieves the date and time of a modification to the object. */
7144     dateTime: string;
7145     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLModElement, 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: HTMLModElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7148     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7149 }
7150
7151 declare var HTMLModElement: {
7152     prototype: HTMLModElement;
7153     new(): HTMLModElement;
7154 };
7155
7156 /** Provides special properties (beyond those defined on the regular HTMLElement interface it also has available to it by inheritance) for manipulating ordered list elements. */
7157 interface HTMLOListElement extends HTMLElement {
7158     /** @deprecated */
7159     compact: boolean;
7160     reversed: boolean;
7161     /** The starting number. */
7162     start: number;
7163     type: string;
7164     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLOListElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7165     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7166     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLOListElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7167     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7168 }
7169
7170 declare var HTMLOListElement: {
7171     prototype: HTMLOListElement;
7172     new(): HTMLOListElement;
7173 };
7174
7175 /** 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. */
7176 interface HTMLObjectElement extends HTMLElement {
7177     /** @deprecated */
7178     align: string;
7179     /**
7180      * Sets or retrieves a character string that can be used to implement your own archive functionality for the object.
7181      * @deprecated
7182      */
7183     archive: string;
7184     /** @deprecated */
7185     border: string;
7186     /**
7187      * Sets or retrieves the URL of the file containing the compiled Java class.
7188      * @deprecated
7189      */
7190     code: string;
7191     /**
7192      * Sets or retrieves the URL of the component.
7193      * @deprecated
7194      */
7195     codeBase: string;
7196     /**
7197      * Sets or retrieves the Internet media type for the code associated with the object.
7198      * @deprecated
7199      */
7200     codeType: string;
7201     /** Retrieves the document object of the page or frame. */
7202     readonly contentDocument: Document | null;
7203     readonly contentWindow: WindowProxy | null;
7204     /** Sets or retrieves the URL that references the data of the object. */
7205     data: string;
7206     /** @deprecated */
7207     declare: boolean;
7208     /** Retrieves a reference to the form that the object is embedded in. */
7209     readonly form: HTMLFormElement | null;
7210     /** Sets or retrieves the height of the object. */
7211     height: string;
7212     /** @deprecated */
7213     hspace: number;
7214     /** Sets or retrieves the name of the object. */
7215     name: string;
7216     /**
7217      * Sets or retrieves a message to be displayed while an object is loading.
7218      * @deprecated
7219      */
7220     standby: string;
7221     /** Sets or retrieves the MIME type of the object. */
7222     type: string;
7223     /** Sets or retrieves the URL, often with a bookmark extension (#name), to use as a client-side image map. */
7224     useMap: string;
7225     /** 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. */
7226     readonly validationMessage: string;
7227     /** Returns a  ValidityState object that represents the validity states of an element. */
7228     readonly validity: ValidityState;
7229     /** @deprecated */
7230     vspace: number;
7231     /** Sets or retrieves the width of the object. */
7232     width: string;
7233     /** Returns whether an element will successfully validate based on forms validation rules and constraints. */
7234     readonly willValidate: boolean;
7235     /** Returns whether a form will validate when it is submitted, without having to submit it. */
7236     checkValidity(): boolean;
7237     getSVGDocument(): Document | null;
7238     reportValidity(): boolean;
7239     /**
7240      * Sets a custom error message that is displayed when a form is submitted.
7241      * @param error Sets a custom error message that is displayed when a form is submitted.
7242      */
7243     setCustomValidity(error: string): void;
7244     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLObjectElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7245     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7246     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLObjectElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7247     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7248 }
7249
7250 declare var HTMLObjectElement: {
7251     prototype: HTMLObjectElement;
7252     new(): HTMLObjectElement;
7253 };
7254
7255 /** 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. */
7256 interface HTMLOptGroupElement extends HTMLElement {
7257     disabled: boolean;
7258     /** Sets or retrieves a value that you can use to implement your own label functionality for the object. */
7259     label: string;
7260     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLOptGroupElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7261     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7262     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLOptGroupElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7263     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7264 }
7265
7266 declare var HTMLOptGroupElement: {
7267     prototype: HTMLOptGroupElement;
7268     new(): HTMLOptGroupElement;
7269 };
7270
7271 /** <option> elements and inherits all classes and methods of the HTMLElement interface. */
7272 interface HTMLOptionElement extends HTMLElement {
7273     /** Sets or retrieves the status of an option. */
7274     defaultSelected: boolean;
7275     disabled: boolean;
7276     /** Retrieves a reference to the form that the object is embedded in. */
7277     readonly form: HTMLFormElement | null;
7278     /** Sets or retrieves the ordinal position of an option in a list box. */
7279     readonly index: number;
7280     /** Sets or retrieves a value that you can use to implement your own label functionality for the object. */
7281     label: string;
7282     /** Sets or retrieves whether the option in the list box is the default item. */
7283     selected: boolean;
7284     /** Sets or retrieves the text string specified by the option tag. */
7285     text: string;
7286     /** Sets or retrieves the value which is returned to the server when the form control is submitted. */
7287     value: string;
7288     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLOptionElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7289     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7290     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLOptionElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7291     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7292 }
7293
7294 declare var HTMLOptionElement: {
7295     prototype: HTMLOptionElement;
7296     new(): HTMLOptionElement;
7297 };
7298
7299 /** 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. */
7300 interface HTMLOptionsCollection extends HTMLCollectionOf<HTMLOptionElement> {
7301     /**
7302      * Returns the number of elements in the collection.
7303      *
7304      * When set to a smaller number, truncates the number of option elements in the corresponding container.
7305      *
7306      * When set to a greater number, adds new blank option elements to that container.
7307      */
7308     length: number;
7309     /**
7310      * Returns the index of the first selected item, if any, or −1 if there is no selected item.
7311      *
7312      * Can be set, to change the selection.
7313      */
7314     selectedIndex: number;
7315     /**
7316      * Inserts element before the node given by before.
7317      *
7318      * 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.
7319      *
7320      * If before is omitted, null, or a number out of range, then element will be added at the end of the list.
7321      *
7322      * This method will throw a "HierarchyRequestError" DOMException if element is an ancestor of the element into which it is to be inserted.
7323      */
7324     add(element: HTMLOptionElement | HTMLOptGroupElement, before?: HTMLElement | number | null): void;
7325     /** Removes the item with index index from the collection. */
7326     remove(index: number): void;
7327 }
7328
7329 declare var HTMLOptionsCollection: {
7330     prototype: HTMLOptionsCollection;
7331     new(): HTMLOptionsCollection;
7332 };
7333
7334 interface HTMLOrSVGElement {
7335     autofocus: boolean;
7336     readonly dataset: DOMStringMap;
7337     nonce?: string;
7338     tabIndex: number;
7339     blur(): void;
7340     focus(options?: FocusOptions): void;
7341 }
7342
7343 /** Provides properties and methods (beyond those inherited from HTMLElement) for manipulating the layout and presentation of <output> elements. */
7344 interface HTMLOutputElement extends HTMLElement {
7345     defaultValue: string;
7346     readonly form: HTMLFormElement | null;
7347     readonly htmlFor: DOMTokenList;
7348     readonly labels: NodeListOf<HTMLLabelElement>;
7349     name: string;
7350     /** Returns the string "output". */
7351     readonly type: string;
7352     readonly validationMessage: string;
7353     readonly validity: ValidityState;
7354     /**
7355      * Returns the element's current value.
7356      *
7357      * Can be set, to change the value.
7358      */
7359     value: string;
7360     readonly willValidate: boolean;
7361     checkValidity(): boolean;
7362     reportValidity(): boolean;
7363     setCustomValidity(error: string): void;
7364     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLOutputElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7365     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7366     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLOutputElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7367     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7368 }
7369
7370 declare var HTMLOutputElement: {
7371     prototype: HTMLOutputElement;
7372     new(): HTMLOutputElement;
7373 };
7374
7375 /** Provides special properties (beyond those of the regular HTMLElement object interface it inherits) for manipulating <p> elements. */
7376 interface HTMLParagraphElement extends HTMLElement {
7377     /**
7378      * Sets or retrieves how the object is aligned with adjacent text.
7379      * @deprecated
7380      */
7381     align: string;
7382     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLParagraphElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7383     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7384     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLParagraphElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7385     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7386 }
7387
7388 declare var HTMLParagraphElement: {
7389     prototype: HTMLParagraphElement;
7390     new(): HTMLParagraphElement;
7391 };
7392
7393 /** 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. */
7394 interface HTMLParamElement extends HTMLElement {
7395     /** Sets or retrieves the name of an input parameter for an element. */
7396     name: string;
7397     /**
7398      * Sets or retrieves the content type of the resource designated by the value attribute.
7399      * @deprecated
7400      */
7401     type: string;
7402     /** Sets or retrieves the value of an input parameter for an element. */
7403     value: string;
7404     /**
7405      * Sets or retrieves the data type of the value attribute.
7406      * @deprecated
7407      */
7408     valueType: string;
7409     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLParamElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7410     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7411     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLParamElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7412     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7413 }
7414
7415 declare var HTMLParamElement: {
7416     prototype: HTMLParamElement;
7417     new(): HTMLParamElement;
7418 };
7419
7420 /** A <picture> HTML element. It doesn't implement specific properties or methods. */
7421 interface HTMLPictureElement extends HTMLElement {
7422     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLPictureElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7423     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7424     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLPictureElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7425     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7426 }
7427
7428 declare var HTMLPictureElement: {
7429     prototype: HTMLPictureElement;
7430     new(): HTMLPictureElement;
7431 };
7432
7433 /** 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>). */
7434 interface HTMLPreElement extends HTMLElement {
7435     /**
7436      * Sets or gets a value that you can use to implement your own width functionality for the object.
7437      * @deprecated
7438      */
7439     width: number;
7440     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLPreElement, 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: HTMLPreElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7443     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7444 }
7445
7446 declare var HTMLPreElement: {
7447     prototype: HTMLPreElement;
7448     new(): HTMLPreElement;
7449 };
7450
7451 /** 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. */
7452 interface HTMLProgressElement extends HTMLElement {
7453     readonly labels: NodeListOf<HTMLLabelElement>;
7454     /** Defines the maximum, or "done" value for a progress element. */
7455     max: number;
7456     /** 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). */
7457     readonly position: number;
7458     /** Sets or gets the current value of a progress element. The value must be a non-negative number between 0 and the max value. */
7459     value: number;
7460     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLProgressElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7461     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7462     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLProgressElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7463     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7464 }
7465
7466 declare var HTMLProgressElement: {
7467     prototype: HTMLProgressElement;
7468     new(): HTMLProgressElement;
7469 };
7470
7471 /** 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. */
7472 interface HTMLQuoteElement extends HTMLElement {
7473     /** Sets or retrieves reference information about the object. */
7474     cite: string;
7475     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLQuoteElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7476     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7477     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLQuoteElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7478     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7479 }
7480
7481 declare var HTMLQuoteElement: {
7482     prototype: HTMLQuoteElement;
7483     new(): HTMLQuoteElement;
7484 };
7485
7486 /** 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). */
7487 interface HTMLScriptElement extends HTMLElement {
7488     async: boolean;
7489     /**
7490      * Sets or retrieves the character set used to encode the object.
7491      * @deprecated
7492      */
7493     charset: string;
7494     crossOrigin: string | null;
7495     /** Sets or retrieves the status of the script. */
7496     defer: boolean;
7497     /**
7498      * Sets or retrieves the event for which the script is written.
7499      * @deprecated
7500      */
7501     event: string;
7502     /**
7503      * Sets or retrieves the object that is bound to the event script.
7504      * @deprecated
7505      */
7506     htmlFor: string;
7507     integrity: string;
7508     noModule: boolean;
7509     referrerPolicy: string;
7510     /** Retrieves the URL to an external file that contains the source code or data. */
7511     src: string;
7512     /** Retrieves or sets the text of the object as a string. */
7513     text: string;
7514     /** Sets or retrieves the MIME type for the associated scripting engine. */
7515     type: string;
7516     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLScriptElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7517     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7518     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLScriptElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7519     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7520 }
7521
7522 declare var HTMLScriptElement: {
7523     prototype: HTMLScriptElement;
7524     new(): HTMLScriptElement;
7525 };
7526
7527 /** A <select> HTML Element. These elements also share all of the properties and methods of other HTML elements via the HTMLElement interface. */
7528 interface HTMLSelectElement extends HTMLElement {
7529     autocomplete: string;
7530     disabled: boolean;
7531     /** Retrieves a reference to the form that the object is embedded in. */
7532     readonly form: HTMLFormElement | null;
7533     readonly labels: NodeListOf<HTMLLabelElement>;
7534     /** Sets or retrieves the number of objects in a collection. */
7535     length: number;
7536     /** Sets or retrieves the Boolean value indicating whether multiple items can be selected from a list. */
7537     multiple: boolean;
7538     /** Sets or retrieves the name of the object. */
7539     name: string;
7540     /** Returns an HTMLOptionsCollection of the list of options. */
7541     readonly options: HTMLOptionsCollection;
7542     /** When present, marks an element that can't be submitted without a value. */
7543     required: boolean;
7544     /** Sets or retrieves the index of the selected option in a select object. */
7545     selectedIndex: number;
7546     readonly selectedOptions: HTMLCollectionOf<HTMLOptionElement>;
7547     /** Sets or retrieves the number of rows in the list box. */
7548     size: number;
7549     /** Retrieves the type of select control based on the value of the MULTIPLE attribute. */
7550     readonly type: string;
7551     /** 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. */
7552     readonly validationMessage: string;
7553     /** Returns a  ValidityState object that represents the validity states of an element. */
7554     readonly validity: ValidityState;
7555     /** Sets or retrieves the value which is returned to the server when the form control is submitted. */
7556     value: string;
7557     /** Returns whether an element will successfully validate based on forms validation rules and constraints. */
7558     readonly willValidate: boolean;
7559     /**
7560      * Adds an element to the areas, controlRange, or options collection.
7561      * @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.
7562      * @param before Variant of type Object that specifies an element to insert before, or null to append the object to the collection.
7563      */
7564     add(element: HTMLOptionElement | HTMLOptGroupElement, before?: HTMLElement | number | null): void;
7565     /** Returns whether a form will validate when it is submitted, without having to submit it. */
7566     checkValidity(): boolean;
7567     /**
7568      * Retrieves a select object or an object from an options collection.
7569      * @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.
7570      * @param index Variant of type Number that specifies the zero-based index of the object to retrieve when a collection is returned.
7571      */
7572     item(index: number): HTMLOptionElement | null;
7573     /**
7574      * Retrieves a select object or an object from an options collection.
7575      * @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.
7576      */
7577     namedItem(name: string): HTMLOptionElement | null;
7578     /**
7579      * Removes an element from the collection.
7580      * @param index Number that specifies the zero-based index of the element to remove from the collection.
7581      */
7582     remove(): void;
7583     remove(index: number): void;
7584     reportValidity(): boolean;
7585     /**
7586      * Sets a custom error message that is displayed when a form is submitted.
7587      * @param error Sets a custom error message that is displayed when a form is submitted.
7588      */
7589     setCustomValidity(error: string): void;
7590     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLSelectElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7591     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7592     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLSelectElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7593     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7594     [name: number]: HTMLOptionElement | HTMLOptGroupElement;
7595 }
7596
7597 declare var HTMLSelectElement: {
7598     prototype: HTMLSelectElement;
7599     new(): HTMLSelectElement;
7600 };
7601
7602 interface HTMLSlotElement extends HTMLElement {
7603     name: string;
7604     assign(...nodes: (Element | Text)[]): void;
7605     assignedElements(options?: AssignedNodesOptions): Element[];
7606     assignedNodes(options?: AssignedNodesOptions): Node[];
7607     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLSlotElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7608     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7609     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLSlotElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7610     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7611 }
7612
7613 declare var HTMLSlotElement: {
7614     prototype: HTMLSlotElement;
7615     new(): HTMLSlotElement;
7616 };
7617
7618 /** Provides special properties (beyond the regular HTMLElement object interface it also has available to it by inheritance) for manipulating <source> elements. */
7619 interface HTMLSourceElement extends HTMLElement {
7620     /** Gets or sets the intended media type of the media source. */
7621     media: string;
7622     sizes: string;
7623     /** The address or URL of the a media resource that is to be considered. */
7624     src: string;
7625     srcset: string;
7626     /** Gets or sets the MIME type of a media resource. */
7627     type: string;
7628     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLSourceElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7629     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7630     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLSourceElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7631     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7632 }
7633
7634 declare var HTMLSourceElement: {
7635     prototype: HTMLSourceElement;
7636     new(): HTMLSourceElement;
7637 };
7638
7639 /** A <span> element and derives from the HTMLElement interface, but without implementing any additional properties or methods. */
7640 interface HTMLSpanElement extends HTMLElement {
7641     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLSpanElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7642     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7643     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLSpanElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7644     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7645 }
7646
7647 declare var HTMLSpanElement: {
7648     prototype: HTMLSpanElement;
7649     new(): HTMLSpanElement;
7650 };
7651
7652 /** A <style> element. It inherits properties and methods from its parent, HTMLElement, and from LinkStyle. */
7653 interface HTMLStyleElement extends HTMLElement, LinkStyle {
7654     /** Sets or retrieves the media type. */
7655     media: string;
7656     /**
7657      * Retrieves the CSS language in which the style sheet is written.
7658      * @deprecated
7659      */
7660     type: string;
7661     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLStyleElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7662     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7663     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLStyleElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7664     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7665 }
7666
7667 declare var HTMLStyleElement: {
7668     prototype: HTMLStyleElement;
7669     new(): HTMLStyleElement;
7670 };
7671
7672 /** Special properties (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating table caption elements. */
7673 interface HTMLTableCaptionElement extends HTMLElement {
7674     /**
7675      * Sets or retrieves the alignment of the caption or legend.
7676      * @deprecated
7677      */
7678     align: string;
7679     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableCaptionElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7680     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7681     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableCaptionElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7682     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7683 }
7684
7685 declare var HTMLTableCaptionElement: {
7686     prototype: HTMLTableCaptionElement;
7687     new(): HTMLTableCaptionElement;
7688 };
7689
7690 /** 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. */
7691 interface HTMLTableCellElement extends HTMLElement {
7692     /** Sets or retrieves abbreviated text for the object. */
7693     abbr: string;
7694     /**
7695      * Sets or retrieves how the object is aligned with adjacent text.
7696      * @deprecated
7697      */
7698     align: string;
7699     /**
7700      * Sets or retrieves a comma-delimited list of conceptual categories associated with the object.
7701      * @deprecated
7702      */
7703     axis: string;
7704     /** @deprecated */
7705     bgColor: string;
7706     /** Retrieves the position of the object in the cells collection of a row. */
7707     readonly cellIndex: number;
7708     /** @deprecated */
7709     ch: string;
7710     /** @deprecated */
7711     chOff: string;
7712     /** Sets or retrieves the number columns in the table that the object should span. */
7713     colSpan: number;
7714     /** Sets or retrieves a list of header cells that provide information for the object. */
7715     headers: string;
7716     /**
7717      * Sets or retrieves the height of the object.
7718      * @deprecated
7719      */
7720     height: string;
7721     /**
7722      * Sets or retrieves whether the browser automatically performs wordwrap.
7723      * @deprecated
7724      */
7725     noWrap: boolean;
7726     /** Sets or retrieves how many rows in a table the cell should span. */
7727     rowSpan: number;
7728     /** Sets or retrieves the group of cells in a table to which the object's information applies. */
7729     scope: string;
7730     /** @deprecated */
7731     vAlign: string;
7732     /**
7733      * Sets or retrieves the width of the object.
7734      * @deprecated
7735      */
7736     width: string;
7737     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableCellElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7738     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7739     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableCellElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7740     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7741 }
7742
7743 declare var HTMLTableCellElement: {
7744     prototype: HTMLTableCellElement;
7745     new(): HTMLTableCellElement;
7746 };
7747
7748 /** Provides special properties (beyond the HTMLElement interface it also has available to it inheritance) for manipulating single or grouped table column elements. */
7749 interface HTMLTableColElement extends HTMLElement {
7750     /**
7751      * Sets or retrieves the alignment of the object relative to the display or table.
7752      * @deprecated
7753      */
7754     align: string;
7755     /** @deprecated */
7756     ch: string;
7757     /** @deprecated */
7758     chOff: string;
7759     /** Sets or retrieves the number of columns in the group. */
7760     span: number;
7761     /** @deprecated */
7762     vAlign: string;
7763     /**
7764      * Sets or retrieves the width of the object.
7765      * @deprecated
7766      */
7767     width: string;
7768     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableColElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7769     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7770     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableColElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7771     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7772 }
7773
7774 declare var HTMLTableColElement: {
7775     prototype: HTMLTableColElement;
7776     new(): HTMLTableColElement;
7777 };
7778
7779 /** @deprecated prefer HTMLTableCellElement */
7780 interface HTMLTableDataCellElement extends HTMLTableCellElement {
7781     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableDataCellElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7782     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7783     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableDataCellElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7784     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7785 }
7786
7787 /** 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. */
7788 interface HTMLTableElement extends HTMLElement {
7789     /**
7790      * Sets or retrieves a value that indicates the table alignment.
7791      * @deprecated
7792      */
7793     align: string;
7794     /** @deprecated */
7795     bgColor: string;
7796     /**
7797      * Sets or retrieves the width of the border to draw around the object.
7798      * @deprecated
7799      */
7800     border: string;
7801     /** Retrieves the caption object of a table. */
7802     caption: HTMLTableCaptionElement | null;
7803     /**
7804      * Sets or retrieves the amount of space between the border of the cell and the content of the cell.
7805      * @deprecated
7806      */
7807     cellPadding: string;
7808     /**
7809      * Sets or retrieves the amount of space between cells in a table.
7810      * @deprecated
7811      */
7812     cellSpacing: string;
7813     /**
7814      * Sets or retrieves the way the border frame around the table is displayed.
7815      * @deprecated
7816      */
7817     frame: string;
7818     /** Sets or retrieves the number of horizontal rows contained in the object. */
7819     readonly rows: HTMLCollectionOf<HTMLTableRowElement>;
7820     /**
7821      * Sets or retrieves which dividing lines (inner borders) are displayed.
7822      * @deprecated
7823      */
7824     rules: string;
7825     /**
7826      * Sets or retrieves a description and/or structure of the object.
7827      * @deprecated
7828      */
7829     summary: string;
7830     /** Retrieves a collection of all tBody objects in the table. Objects in this collection are in source order. */
7831     readonly tBodies: HTMLCollectionOf<HTMLTableSectionElement>;
7832     /** Retrieves the tFoot object of the table. */
7833     tFoot: HTMLTableSectionElement | null;
7834     /** Retrieves the tHead object of the table. */
7835     tHead: HTMLTableSectionElement | null;
7836     /**
7837      * Sets or retrieves the width of the object.
7838      * @deprecated
7839      */
7840     width: string;
7841     /** Creates an empty caption element in the table. */
7842     createCaption(): HTMLTableCaptionElement;
7843     /** Creates an empty tBody element in the table. */
7844     createTBody(): HTMLTableSectionElement;
7845     /** Creates an empty tFoot element in the table. */
7846     createTFoot(): HTMLTableSectionElement;
7847     /** Returns the tHead element object if successful, or null otherwise. */
7848     createTHead(): HTMLTableSectionElement;
7849     /** Deletes the caption element and its contents from the table. */
7850     deleteCaption(): void;
7851     /**
7852      * Removes the specified row (tr) from the element and from the rows collection.
7853      * @param index Number that specifies the zero-based position in the rows collection of the row to remove.
7854      */
7855     deleteRow(index: number): void;
7856     /** Deletes the tFoot element and its contents from the table. */
7857     deleteTFoot(): void;
7858     /** Deletes the tHead element and its contents from the table. */
7859     deleteTHead(): void;
7860     /**
7861      * Creates a new row (tr) in the table, and adds the row to the rows collection.
7862      * @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.
7863      */
7864     insertRow(index?: number): HTMLTableRowElement;
7865     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7866     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7867     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7868     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7869 }
7870
7871 declare var HTMLTableElement: {
7872     prototype: HTMLTableElement;
7873     new(): HTMLTableElement;
7874 };
7875
7876 /** @deprecated prefer HTMLTableCellElement */
7877 interface HTMLTableHeaderCellElement extends HTMLTableCellElement {
7878     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableHeaderCellElement, 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: HTMLTableHeaderCellElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7881     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7882 }
7883
7884 /** 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. */
7885 interface HTMLTableRowElement extends HTMLElement {
7886     /**
7887      * Sets or retrieves how the object is aligned with adjacent text.
7888      * @deprecated
7889      */
7890     align: string;
7891     /** @deprecated */
7892     bgColor: string;
7893     /** Retrieves a collection of all cells in the table row. */
7894     readonly cells: HTMLCollectionOf<HTMLTableCellElement>;
7895     /** @deprecated */
7896     ch: string;
7897     /** @deprecated */
7898     chOff: string;
7899     /** Retrieves the position of the object in the rows collection for the table. */
7900     readonly rowIndex: number;
7901     /** Retrieves the position of the object in the collection. */
7902     readonly sectionRowIndex: number;
7903     /** @deprecated */
7904     vAlign: string;
7905     /**
7906      * Removes the specified cell from the table row, as well as from the cells collection.
7907      * @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.
7908      */
7909     deleteCell(index: number): void;
7910     /**
7911      * Creates a new cell in the table row, and adds the cell to the cells collection.
7912      * @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.
7913      */
7914     insertCell(index?: number): HTMLTableCellElement;
7915     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableRowElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7916     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7917     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableRowElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7918     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7919 }
7920
7921 declare var HTMLTableRowElement: {
7922     prototype: HTMLTableRowElement;
7923     new(): HTMLTableRowElement;
7924 };
7925
7926 /** 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. */
7927 interface HTMLTableSectionElement extends HTMLElement {
7928     /**
7929      * Sets or retrieves a value that indicates the table alignment.
7930      * @deprecated
7931      */
7932     align: string;
7933     /** @deprecated */
7934     ch: string;
7935     /** @deprecated */
7936     chOff: string;
7937     /** Sets or retrieves the number of horizontal rows contained in the object. */
7938     readonly rows: HTMLCollectionOf<HTMLTableRowElement>;
7939     /** @deprecated */
7940     vAlign: string;
7941     /**
7942      * Removes the specified row (tr) from the element and from the rows collection.
7943      * @param index Number that specifies the zero-based position in the rows collection of the row to remove.
7944      */
7945     deleteRow(index: number): void;
7946     /**
7947      * Creates a new row (tr) in the table, and adds the row to the rows collection.
7948      * @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.
7949      */
7950     insertRow(index?: number): HTMLTableRowElement;
7951     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableSectionElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7952     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7953     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableSectionElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7954     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7955 }
7956
7957 declare var HTMLTableSectionElement: {
7958     prototype: HTMLTableSectionElement;
7959     new(): HTMLTableSectionElement;
7960 };
7961
7962 /** Enables access to the contents of an HTML <template> element. */
7963 interface HTMLTemplateElement extends HTMLElement {
7964     /** Returns the template contents (a DocumentFragment). */
7965     readonly content: DocumentFragment;
7966     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTemplateElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7967     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7968     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTemplateElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7969     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7970 }
7971
7972 declare var HTMLTemplateElement: {
7973     prototype: HTMLTemplateElement;
7974     new(): HTMLTemplateElement;
7975 };
7976
7977 /** Provides special properties and methods for manipulating the layout and presentation of <textarea> elements. */
7978 interface HTMLTextAreaElement extends HTMLElement {
7979     autocomplete: string;
7980     /** Sets or retrieves the width of the object. */
7981     cols: number;
7982     /** Sets or retrieves the initial contents of the object. */
7983     defaultValue: string;
7984     dirName: string;
7985     disabled: boolean;
7986     /** Retrieves a reference to the form that the object is embedded in. */
7987     readonly form: HTMLFormElement | null;
7988     readonly labels: NodeListOf<HTMLLabelElement>;
7989     /** Sets or retrieves the maximum number of characters that the user can enter in a text control. */
7990     maxLength: number;
7991     minLength: number;
7992     /** Sets or retrieves the name of the object. */
7993     name: string;
7994     /** 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. */
7995     placeholder: string;
7996     /** Sets or retrieves the value indicated whether the content of the object is read-only. */
7997     readOnly: boolean;
7998     /** When present, marks an element that can't be submitted without a value. */
7999     required: boolean;
8000     /** Sets or retrieves the number of horizontal rows contained in the object. */
8001     rows: number;
8002     selectionDirection: "forward" | "backward" | "none";
8003     /** Gets or sets the end position or offset of a text selection. */
8004     selectionEnd: number;
8005     /** Gets or sets the starting position or offset of a text selection. */
8006     selectionStart: number;
8007     readonly textLength: number;
8008     /** Retrieves the type of control. */
8009     readonly type: string;
8010     /** 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. */
8011     readonly validationMessage: string;
8012     /** Returns a  ValidityState object that represents the validity states of an element. */
8013     readonly validity: ValidityState;
8014     /** Retrieves or sets the text in the entry field of the textArea element. */
8015     value: string;
8016     /** Returns whether an element will successfully validate based on forms validation rules and constraints. */
8017     readonly willValidate: boolean;
8018     /** Sets or retrieves how to handle wordwrapping in the object. */
8019     wrap: string;
8020     /** Returns whether a form will validate when it is submitted, without having to submit it. */
8021     checkValidity(): boolean;
8022     reportValidity(): boolean;
8023     /** Highlights the input area of a form element. */
8024     select(): void;
8025     /**
8026      * Sets a custom error message that is displayed when a form is submitted.
8027      * @param error Sets a custom error message that is displayed when a form is submitted.
8028      */
8029     setCustomValidity(error: string): void;
8030     setRangeText(replacement: string): void;
8031     setRangeText(replacement: string, start: number, end: number, selectionMode?: SelectionMode): void;
8032     /**
8033      * Sets the start and end positions of a selection in a text field.
8034      * @param start The offset into the text field for the start of the selection.
8035      * @param end The offset into the text field for the end of the selection.
8036      * @param direction The direction in which the selection is performed.
8037      */
8038     setSelectionRange(start: number | null, end: number | null, direction?: "forward" | "backward" | "none"): void;
8039     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTextAreaElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8040     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8041     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTextAreaElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8042     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8043 }
8044
8045 declare var HTMLTextAreaElement: {
8046     prototype: HTMLTextAreaElement;
8047     new(): HTMLTextAreaElement;
8048 };
8049
8050 /** Provides special properties (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating <time> elements. */
8051 interface HTMLTimeElement extends HTMLElement {
8052     dateTime: string;
8053     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTimeElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8054     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8055     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTimeElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8056     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8057 }
8058
8059 declare var HTMLTimeElement: {
8060     prototype: HTMLTimeElement;
8061     new(): HTMLTimeElement;
8062 };
8063
8064 /** Contains the title for a document. This element inherits all of the properties and methods of the HTMLElement interface. */
8065 interface HTMLTitleElement extends HTMLElement {
8066     /** Retrieves or sets the text of the object as a string. */
8067     text: string;
8068     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTitleElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8069     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8070     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTitleElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8071     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8072 }
8073
8074 declare var HTMLTitleElement: {
8075     prototype: HTMLTitleElement;
8076     new(): HTMLTitleElement;
8077 };
8078
8079 /** The HTMLTrackElement */
8080 interface HTMLTrackElement extends HTMLElement {
8081     default: boolean;
8082     kind: string;
8083     label: string;
8084     readonly readyState: number;
8085     src: string;
8086     srclang: string;
8087     /** Returns the TextTrack object corresponding to the text track of the track element. */
8088     readonly track: TextTrack;
8089     readonly ERROR: number;
8090     readonly LOADED: number;
8091     readonly LOADING: number;
8092     readonly NONE: number;
8093     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTrackElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8094     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8095     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTrackElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8096     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8097 }
8098
8099 declare var HTMLTrackElement: {
8100     prototype: HTMLTrackElement;
8101     new(): HTMLTrackElement;
8102     readonly ERROR: number;
8103     readonly LOADED: number;
8104     readonly LOADING: number;
8105     readonly NONE: number;
8106 };
8107
8108 /** Provides special properties (beyond those defined on the regular HTMLElement interface it also has available to it by inheritance) for manipulating unordered list elements. */
8109 interface HTMLUListElement extends HTMLElement {
8110     /** @deprecated */
8111     compact: boolean;
8112     /** @deprecated */
8113     type: string;
8114     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLUListElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8115     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8116     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLUListElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8117     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8118 }
8119
8120 declare var HTMLUListElement: {
8121     prototype: HTMLUListElement;
8122     new(): HTMLUListElement;
8123 };
8124
8125 /** An invalid HTML element and derives from the HTMLElement interface, but without implementing any additional properties or methods. */
8126 interface HTMLUnknownElement extends HTMLElement {
8127     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLUnknownElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8128     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8129     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLUnknownElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8130     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8131 }
8132
8133 declare var HTMLUnknownElement: {
8134     prototype: HTMLUnknownElement;
8135     new(): HTMLUnknownElement;
8136 };
8137
8138 interface HTMLVideoElementEventMap extends HTMLMediaElementEventMap {
8139     "enterpictureinpicture": Event;
8140     "leavepictureinpicture": Event;
8141 }
8142
8143 /** Provides special properties and methods for manipulating video objects. It also inherits properties and methods of HTMLMediaElement and HTMLElement. */
8144 interface HTMLVideoElement extends HTMLMediaElement {
8145     disablePictureInPicture: boolean;
8146     /** Gets or sets the height of the video element. */
8147     height: number;
8148     onenterpictureinpicture: ((this: HTMLVideoElement, ev: Event) => any) | null;
8149     onleavepictureinpicture: ((this: HTMLVideoElement, ev: Event) => any) | null;
8150     /** 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. */
8151     playsInline: boolean;
8152     /** 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. */
8153     poster: string;
8154     /** Gets the intrinsic height of a video in CSS pixels, or zero if the dimensions are not known. */
8155     readonly videoHeight: number;
8156     /** Gets the intrinsic width of a video in CSS pixels, or zero if the dimensions are not known. */
8157     readonly videoWidth: number;
8158     /** Gets or sets the width of the video element. */
8159     width: number;
8160     getVideoPlaybackQuality(): VideoPlaybackQuality;
8161     requestPictureInPicture(): Promise<PictureInPictureWindow>;
8162     addEventListener<K extends keyof HTMLVideoElementEventMap>(type: K, listener: (this: HTMLVideoElement, ev: HTMLVideoElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8163     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8164     removeEventListener<K extends keyof HTMLVideoElementEventMap>(type: K, listener: (this: HTMLVideoElement, ev: HTMLVideoElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8165     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8166 }
8167
8168 declare var HTMLVideoElement: {
8169     prototype: HTMLVideoElement;
8170     new(): HTMLVideoElement;
8171 };
8172
8173 /** Events that fire when the fragment identifier of the URL has changed. */
8174 interface HashChangeEvent extends Event {
8175     /** Returns the URL of the session history entry that is now current. */
8176     readonly newURL: string;
8177     /** Returns the URL of the session history entry that was previously current. */
8178     readonly oldURL: string;
8179 }
8180
8181 declare var HashChangeEvent: {
8182     prototype: HashChangeEvent;
8183     new(type: string, eventInitDict?: HashChangeEventInit): HashChangeEvent;
8184 };
8185
8186 /** 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. */
8187 interface Headers {
8188     append(name: string, value: string): void;
8189     delete(name: string): void;
8190     get(name: string): string | null;
8191     has(name: string): boolean;
8192     set(name: string, value: string): void;
8193     forEach(callbackfn: (value: string, key: string, parent: Headers) => void, thisArg?: any): void;
8194 }
8195
8196 declare var Headers: {
8197     prototype: Headers;
8198     new(init?: HeadersInit): Headers;
8199 };
8200
8201 /** Allows manipulation of the browser session history, that is the pages visited in the tab or frame that the current page is loaded in. */
8202 interface History {
8203     readonly length: number;
8204     scrollRestoration: ScrollRestoration;
8205     readonly state: any;
8206     back(): void;
8207     forward(): void;
8208     go(delta?: number): void;
8209     pushState(data: any, unused: string, url?: string | URL | null): void;
8210     replaceState(data: any, unused: string, url?: string | URL | null): void;
8211 }
8212
8213 declare var History: {
8214     prototype: History;
8215     new(): History;
8216 };
8217
8218 /** This IndexedDB API interface represents a cursor for traversing or iterating over multiple records in a database. */
8219 interface IDBCursor {
8220     /** Returns the direction ("next", "nextunique", "prev" or "prevunique") of the cursor. */
8221     readonly direction: IDBCursorDirection;
8222     /** Returns the key of the cursor. Throws a "InvalidStateError" DOMException if the cursor is advancing or is finished. */
8223     readonly key: IDBValidKey;
8224     /** Returns the effective key of the cursor. Throws a "InvalidStateError" DOMException if the cursor is advancing or is finished. */
8225     readonly primaryKey: IDBValidKey;
8226     readonly request: IDBRequest;
8227     /** Returns the IDBObjectStore or IDBIndex the cursor was opened from. */
8228     readonly source: IDBObjectStore | IDBIndex;
8229     /** Advances the cursor through the next count records in range. */
8230     advance(count: number): void;
8231     /** Advances the cursor to the next record in range. */
8232     continue(key?: IDBValidKey): void;
8233     /** 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. */
8234     continuePrimaryKey(key: IDBValidKey, primaryKey: IDBValidKey): void;
8235     /**
8236      * Delete the record pointed at by the cursor with a new value.
8237      *
8238      * If successful, request's result will be undefined.
8239      */
8240     delete(): IDBRequest<undefined>;
8241     /**
8242      * Updated the record pointed at by the cursor with a new value.
8243      *
8244      * Throws a "DataError" DOMException if the effective object store uses in-line keys and the key would have changed.
8245      *
8246      * If successful, request's result will be the record's key.
8247      */
8248     update(value: any): IDBRequest<IDBValidKey>;
8249 }
8250
8251 declare var IDBCursor: {
8252     prototype: IDBCursor;
8253     new(): IDBCursor;
8254 };
8255
8256 /** 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. */
8257 interface IDBCursorWithValue extends IDBCursor {
8258     /** Returns the cursor's current value. */
8259     readonly value: any;
8260 }
8261
8262 declare var IDBCursorWithValue: {
8263     prototype: IDBCursorWithValue;
8264     new(): IDBCursorWithValue;
8265 };
8266
8267 interface IDBDatabaseEventMap {
8268     "abort": Event;
8269     "close": Event;
8270     "error": Event;
8271     "versionchange": IDBVersionChangeEvent;
8272 }
8273
8274 /** 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. */
8275 interface IDBDatabase extends EventTarget {
8276     /** Returns the name of the database. */
8277     readonly name: string;
8278     /** Returns a list of the names of object stores in the database. */
8279     readonly objectStoreNames: DOMStringList;
8280     onabort: ((this: IDBDatabase, ev: Event) => any) | null;
8281     onclose: ((this: IDBDatabase, ev: Event) => any) | null;
8282     onerror: ((this: IDBDatabase, ev: Event) => any) | null;
8283     onversionchange: ((this: IDBDatabase, ev: IDBVersionChangeEvent) => any) | null;
8284     /** Returns the version of the database. */
8285     readonly version: number;
8286     /** Closes the connection once all running transactions have finished. */
8287     close(): void;
8288     /**
8289      * Creates a new object store with the given name and options and returns a new IDBObjectStore.
8290      *
8291      * Throws a "InvalidStateError" DOMException if not called within an upgrade transaction.
8292      */
8293     createObjectStore(name: string, options?: IDBObjectStoreParameters): IDBObjectStore;
8294     /**
8295      * Deletes the object store with the given name.
8296      *
8297      * Throws a "InvalidStateError" DOMException if not called within an upgrade transaction.
8298      */
8299     deleteObjectStore(name: string): void;
8300     /** 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. */
8301     transaction(storeNames: string | string[], mode?: IDBTransactionMode): IDBTransaction;
8302     addEventListener<K extends keyof IDBDatabaseEventMap>(type: K, listener: (this: IDBDatabase, ev: IDBDatabaseEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8303     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8304     removeEventListener<K extends keyof IDBDatabaseEventMap>(type: K, listener: (this: IDBDatabase, ev: IDBDatabaseEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8305     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8306 }
8307
8308 declare var IDBDatabase: {
8309     prototype: IDBDatabase;
8310     new(): IDBDatabase;
8311 };
8312
8313 /** 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.) */
8314 interface IDBFactory {
8315     /**
8316      * Compares two values as keys. Returns -1 if key1 precedes key2, 1 if key2 precedes key1, and 0 if the keys are equal.
8317      *
8318      * Throws a "DataError" DOMException if either input is not a valid key.
8319      */
8320     cmp(first: any, second: any): number;
8321     databases(): Promise<IDBDatabaseInfo[]>;
8322     /** 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. */
8323     deleteDatabase(name: string): IDBOpenDBRequest;
8324     /** 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. */
8325     open(name: string, version?: number): IDBOpenDBRequest;
8326 }
8327
8328 declare var IDBFactory: {
8329     prototype: IDBFactory;
8330     new(): IDBFactory;
8331 };
8332
8333 /** 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. */
8334 interface IDBIndex {
8335     readonly keyPath: string | string[];
8336     readonly multiEntry: boolean;
8337     /** Returns the name of the index. */
8338     name: string;
8339     /** Returns the IDBObjectStore the index belongs to. */
8340     readonly objectStore: IDBObjectStore;
8341     readonly unique: boolean;
8342     /**
8343      * Retrieves the number of records matching the given key or key range in query.
8344      *
8345      * If successful, request's result will be the count.
8346      */
8347     count(query?: IDBValidKey | IDBKeyRange): IDBRequest<number>;
8348     /**
8349      * Retrieves the value of the first record matching the given key or key range in query.
8350      *
8351      * If successful, request's result will be the value, or undefined if there was no matching record.
8352      */
8353     get(query: IDBValidKey | IDBKeyRange): IDBRequest<any>;
8354     /**
8355      * Retrieves the values of the records matching the given key or key range in query (up to count if given).
8356      *
8357      * If successful, request's result will be an Array of the values.
8358      */
8359     getAll(query?: IDBValidKey | IDBKeyRange | null, count?: number): IDBRequest<any[]>;
8360     /**
8361      * Retrieves the keys of records matching the given key or key range in query (up to count if given).
8362      *
8363      * If successful, request's result will be an Array of the keys.
8364      */
8365     getAllKeys(query?: IDBValidKey | IDBKeyRange | null, count?: number): IDBRequest<IDBValidKey[]>;
8366     /**
8367      * Retrieves the key of the first record matching the given key or key range in query.
8368      *
8369      * If successful, request's result will be the key, or undefined if there was no matching record.
8370      */
8371     getKey(query: IDBValidKey | IDBKeyRange): IDBRequest<IDBValidKey | undefined>;
8372     /**
8373      * Opens a cursor over the records matching query, ordered by direction. If query is null, all records in index are matched.
8374      *
8375      * If successful, request's result will be an IDBCursorWithValue, or null if there were no matching records.
8376      */
8377     openCursor(query?: IDBValidKey | IDBKeyRange | null, direction?: IDBCursorDirection): IDBRequest<IDBCursorWithValue | null>;
8378     /**
8379      * 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.
8380      *
8381      * If successful, request's result will be an IDBCursor, or null if there were no matching records.
8382      */
8383     openKeyCursor(query?: IDBValidKey | IDBKeyRange | null, direction?: IDBCursorDirection): IDBRequest<IDBCursor | null>;
8384 }
8385
8386 declare var IDBIndex: {
8387     prototype: IDBIndex;
8388     new(): IDBIndex;
8389 };
8390
8391 /** 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: */
8392 interface IDBKeyRange {
8393     /** Returns lower bound, or undefined if none. */
8394     readonly lower: any;
8395     /** Returns true if the lower open flag is set, and false otherwise. */
8396     readonly lowerOpen: boolean;
8397     /** Returns upper bound, or undefined if none. */
8398     readonly upper: any;
8399     /** Returns true if the upper open flag is set, and false otherwise. */
8400     readonly upperOpen: boolean;
8401     /** Returns true if key is included in the range, and false otherwise. */
8402     includes(key: any): boolean;
8403 }
8404
8405 declare var IDBKeyRange: {
8406     prototype: IDBKeyRange;
8407     new(): IDBKeyRange;
8408     /** 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. */
8409     bound(lower: any, upper: any, lowerOpen?: boolean, upperOpen?: boolean): IDBKeyRange;
8410     /** Returns a new IDBKeyRange starting at key with no upper bound. If open is true, key is not included in the range. */
8411     lowerBound(lower: any, open?: boolean): IDBKeyRange;
8412     /** Returns a new IDBKeyRange spanning only key. */
8413     only(value: any): IDBKeyRange;
8414     /** Returns a new IDBKeyRange with no lower bound and ending at key. If open is true, key is not included in the range. */
8415     upperBound(upper: any, open?: boolean): IDBKeyRange;
8416 };
8417
8418 /** 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.) */
8419 interface IDBObjectStore {
8420     /** Returns true if the store has a key generator, and false otherwise. */
8421     readonly autoIncrement: boolean;
8422     /** Returns a list of the names of indexes in the store. */
8423     readonly indexNames: DOMStringList;
8424     /** Returns the key path of the store, or null if none. */
8425     readonly keyPath: string | string[];
8426     /** Returns the name of the store. */
8427     name: string;
8428     /** Returns the associated transaction. */
8429     readonly transaction: IDBTransaction;
8430     /**
8431      * Adds or updates a record in store with the given value and key.
8432      *
8433      * If the store uses in-line keys and key is specified a "DataError" DOMException will be thrown.
8434      *
8435      * 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.
8436      *
8437      * If successful, request's result will be the record's key.
8438      */
8439     add(value: any, key?: IDBValidKey): IDBRequest<IDBValidKey>;
8440     /**
8441      * Deletes all records in store.
8442      *
8443      * If successful, request's result will be undefined.
8444      */
8445     clear(): IDBRequest<undefined>;
8446     /**
8447      * Retrieves the number of records matching the given key or key range in query.
8448      *
8449      * If successful, request's result will be the count.
8450      */
8451     count(query?: IDBValidKey | IDBKeyRange): IDBRequest<number>;
8452     /**
8453      * 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.
8454      *
8455      * Throws an "InvalidStateError" DOMException if not called within an upgrade transaction.
8456      */
8457     createIndex(name: string, keyPath: string | string[], options?: IDBIndexParameters): IDBIndex;
8458     /**
8459      * Deletes records in store with the given key or in the given key range in query.
8460      *
8461      * If successful, request's result will be undefined.
8462      */
8463     delete(query: IDBValidKey | IDBKeyRange): IDBRequest<undefined>;
8464     /**
8465      * Deletes the index in store with the given name.
8466      *
8467      * Throws an "InvalidStateError" DOMException if not called within an upgrade transaction.
8468      */
8469     deleteIndex(name: string): void;
8470     /**
8471      * Retrieves the value of the first record matching the given key or key range in query.
8472      *
8473      * If successful, request's result will be the value, or undefined if there was no matching record.
8474      */
8475     get(query: IDBValidKey | IDBKeyRange): IDBRequest<any>;
8476     /**
8477      * Retrieves the values of the records matching the given key or key range in query (up to count if given).
8478      *
8479      * If successful, request's result will be an Array of the values.
8480      */
8481     getAll(query?: IDBValidKey | IDBKeyRange | null, count?: number): IDBRequest<any[]>;
8482     /**
8483      * Retrieves the keys of records matching the given key or key range in query (up to count if given).
8484      *
8485      * If successful, request's result will be an Array of the keys.
8486      */
8487     getAllKeys(query?: IDBValidKey | IDBKeyRange | null, count?: number): IDBRequest<IDBValidKey[]>;
8488     /**
8489      * Retrieves the key of the first record matching the given key or key range in query.
8490      *
8491      * If successful, request's result will be the key, or undefined if there was no matching record.
8492      */
8493     getKey(query: IDBValidKey | IDBKeyRange): IDBRequest<IDBValidKey | undefined>;
8494     index(name: string): IDBIndex;
8495     /**
8496      * Opens a cursor over the records matching query, ordered by direction. If query is null, all records in store are matched.
8497      *
8498      * If successful, request's result will be an IDBCursorWithValue pointing at the first matching record, or null if there were no matching records.
8499      */
8500     openCursor(query?: IDBValidKey | IDBKeyRange | null, direction?: IDBCursorDirection): IDBRequest<IDBCursorWithValue | null>;
8501     /**
8502      * 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.
8503      *
8504      * If successful, request's result will be an IDBCursor pointing at the first matching record, or null if there were no matching records.
8505      */
8506     openKeyCursor(query?: IDBValidKey | IDBKeyRange | null, direction?: IDBCursorDirection): IDBRequest<IDBCursor | null>;
8507     /**
8508      * Adds or updates a record in store with the given value and key.
8509      *
8510      * If the store uses in-line keys and key is specified a "DataError" DOMException will be thrown.
8511      *
8512      * 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.
8513      *
8514      * If successful, request's result will be the record's key.
8515      */
8516     put(value: any, key?: IDBValidKey): IDBRequest<IDBValidKey>;
8517 }
8518
8519 declare var IDBObjectStore: {
8520     prototype: IDBObjectStore;
8521     new(): IDBObjectStore;
8522 };
8523
8524 interface IDBOpenDBRequestEventMap extends IDBRequestEventMap {
8525     "blocked": Event;
8526     "upgradeneeded": IDBVersionChangeEvent;
8527 }
8528
8529 /** Also inherits methods from its parents IDBRequest and EventTarget. */
8530 interface IDBOpenDBRequest extends IDBRequest<IDBDatabase> {
8531     onblocked: ((this: IDBOpenDBRequest, ev: Event) => any) | null;
8532     onupgradeneeded: ((this: IDBOpenDBRequest, ev: IDBVersionChangeEvent) => any) | null;
8533     addEventListener<K extends keyof IDBOpenDBRequestEventMap>(type: K, listener: (this: IDBOpenDBRequest, ev: IDBOpenDBRequestEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8534     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8535     removeEventListener<K extends keyof IDBOpenDBRequestEventMap>(type: K, listener: (this: IDBOpenDBRequest, ev: IDBOpenDBRequestEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8536     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8537 }
8538
8539 declare var IDBOpenDBRequest: {
8540     prototype: IDBOpenDBRequest;
8541     new(): IDBOpenDBRequest;
8542 };
8543
8544 interface IDBRequestEventMap {
8545     "error": Event;
8546     "success": Event;
8547 }
8548
8549 /** 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. */
8550 interface IDBRequest<T = any> extends EventTarget {
8551     /** 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. */
8552     readonly error: DOMException | null;
8553     onerror: ((this: IDBRequest<T>, ev: Event) => any) | null;
8554     onsuccess: ((this: IDBRequest<T>, ev: Event) => any) | null;
8555     /** Returns "pending" until a request is complete, then returns "done". */
8556     readonly readyState: IDBRequestReadyState;
8557     /** When a request is completed, returns the result, or undefined if the request failed. Throws a "InvalidStateError" DOMException if the request is still pending. */
8558     readonly result: T;
8559     /** Returns the IDBObjectStore, IDBIndex, or IDBCursor the request was made against, or null if is was an open request. */
8560     readonly source: IDBObjectStore | IDBIndex | IDBCursor;
8561     /** 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. */
8562     readonly transaction: IDBTransaction | null;
8563     addEventListener<K extends keyof IDBRequestEventMap>(type: K, listener: (this: IDBRequest<T>, ev: IDBRequestEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8564     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8565     removeEventListener<K extends keyof IDBRequestEventMap>(type: K, listener: (this: IDBRequest<T>, ev: IDBRequestEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8566     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8567 }
8568
8569 declare var IDBRequest: {
8570     prototype: IDBRequest;
8571     new(): IDBRequest;
8572 };
8573
8574 interface IDBTransactionEventMap {
8575     "abort": Event;
8576     "complete": Event;
8577     "error": Event;
8578 }
8579
8580 interface IDBTransaction extends EventTarget {
8581     /** Returns the transaction's connection. */
8582     readonly db: IDBDatabase;
8583     /** If the transaction was aborted, returns the error (a DOMException) providing the reason. */
8584     readonly error: DOMException | null;
8585     /** Returns the mode the transaction was created with ("readonly" or "readwrite"), or "versionchange" for an upgrade transaction. */
8586     readonly mode: IDBTransactionMode;
8587     /** 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. */
8588     readonly objectStoreNames: DOMStringList;
8589     onabort: ((this: IDBTransaction, ev: Event) => any) | null;
8590     oncomplete: ((this: IDBTransaction, ev: Event) => any) | null;
8591     onerror: ((this: IDBTransaction, ev: Event) => any) | null;
8592     /** Aborts the transaction. All pending requests will fail with a "AbortError" DOMException and all changes made to the database will be reverted. */
8593     abort(): void;
8594     commit(): void;
8595     /** Returns an IDBObjectStore in the transaction's scope. */
8596     objectStore(name: string): IDBObjectStore;
8597     addEventListener<K extends keyof IDBTransactionEventMap>(type: K, listener: (this: IDBTransaction, ev: IDBTransactionEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8598     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8599     removeEventListener<K extends keyof IDBTransactionEventMap>(type: K, listener: (this: IDBTransaction, ev: IDBTransactionEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8600     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8601 }
8602
8603 declare var IDBTransaction: {
8604     prototype: IDBTransaction;
8605     new(): IDBTransaction;
8606 };
8607
8608 /** This IndexedDB API interface indicates that the version of the database has changed, as the result of an IDBOpenDBRequest.onupgradeneeded event handler function. */
8609 interface IDBVersionChangeEvent extends Event {
8610     readonly newVersion: number | null;
8611     readonly oldVersion: number;
8612 }
8613
8614 declare var IDBVersionChangeEvent: {
8615     prototype: IDBVersionChangeEvent;
8616     new(type: string, eventInitDict?: IDBVersionChangeEventInit): IDBVersionChangeEvent;
8617 };
8618
8619 /** 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. */
8620 interface IIRFilterNode extends AudioNode {
8621     getFrequencyResponse(frequencyHz: Float32Array, magResponse: Float32Array, phaseResponse: Float32Array): void;
8622 }
8623
8624 declare var IIRFilterNode: {
8625     prototype: IIRFilterNode;
8626     new(context: BaseAudioContext, options: IIRFilterOptions): IIRFilterNode;
8627 };
8628
8629 interface IdleDeadline {
8630     readonly didTimeout: boolean;
8631     timeRemaining(): DOMHighResTimeStamp;
8632 }
8633
8634 declare var IdleDeadline: {
8635     prototype: IdleDeadline;
8636     new(): IdleDeadline;
8637 };
8638
8639 interface ImageBitmap {
8640     /** Returns the intrinsic height of the image, in CSS pixels. */
8641     readonly height: number;
8642     /** Returns the intrinsic width of the image, in CSS pixels. */
8643     readonly width: number;
8644     /** Releases imageBitmap's underlying bitmap data. */
8645     close(): void;
8646 }
8647
8648 declare var ImageBitmap: {
8649     prototype: ImageBitmap;
8650     new(): ImageBitmap;
8651 };
8652
8653 interface ImageBitmapRenderingContext {
8654     /** Returns the canvas element that the context is bound to. */
8655     readonly canvas: HTMLCanvasElement;
8656     /** Transfers the underlying bitmap data from imageBitmap to context, and the bitmap becomes the contents of the canvas element to which context is bound. */
8657     transferFromImageBitmap(bitmap: ImageBitmap | null): void;
8658 }
8659
8660 declare var ImageBitmapRenderingContext: {
8661     prototype: ImageBitmapRenderingContext;
8662     new(): ImageBitmapRenderingContext;
8663 };
8664
8665 /** 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(). */
8666 interface ImageData {
8667     /** Returns the one-dimensional array containing the data in RGBA order, as integers in the range 0 to 255. */
8668     readonly data: Uint8ClampedArray;
8669     /** Returns the actual dimensions of the data in the ImageData object, in pixels. */
8670     readonly height: number;
8671     /** Returns the actual dimensions of the data in the ImageData object, in pixels. */
8672     readonly width: number;
8673 }
8674
8675 declare var ImageData: {
8676     prototype: ImageData;
8677     new(sw: number, sh: number, settings?: ImageDataSettings): ImageData;
8678     new(data: Uint8ClampedArray, sw: number, sh?: number, settings?: ImageDataSettings): ImageData;
8679 };
8680
8681 interface InnerHTML {
8682     innerHTML: string;
8683 }
8684
8685 interface InputEvent extends UIEvent {
8686     readonly data: string | null;
8687     readonly dataTransfer: DataTransfer | null;
8688     readonly inputType: string;
8689     readonly isComposing: boolean;
8690     getTargetRanges(): StaticRange[];
8691 }
8692
8693 declare var InputEvent: {
8694     prototype: InputEvent;
8695     new(type: string, eventInitDict?: InputEventInit): InputEvent;
8696 };
8697
8698 /** 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. */
8699 interface IntersectionObserver {
8700     readonly root: Element | Document | null;
8701     readonly rootMargin: string;
8702     readonly thresholds: ReadonlyArray<number>;
8703     disconnect(): void;
8704     observe(target: Element): void;
8705     takeRecords(): IntersectionObserverEntry[];
8706     unobserve(target: Element): void;
8707 }
8708
8709 declare var IntersectionObserver: {
8710     prototype: IntersectionObserver;
8711     new(callback: IntersectionObserverCallback, options?: IntersectionObserverInit): IntersectionObserver;
8712 };
8713
8714 /** This Intersection Observer API interface describes the intersection between the target element and its root container at a specific moment of transition. */
8715 interface IntersectionObserverEntry {
8716     readonly boundingClientRect: DOMRectReadOnly;
8717     readonly intersectionRatio: number;
8718     readonly intersectionRect: DOMRectReadOnly;
8719     readonly isIntersecting: boolean;
8720     readonly rootBounds: DOMRectReadOnly | null;
8721     readonly target: Element;
8722     readonly time: DOMHighResTimeStamp;
8723 }
8724
8725 declare var IntersectionObserverEntry: {
8726     prototype: IntersectionObserverEntry;
8727     new(intersectionObserverEntryInit: IntersectionObserverEntryInit): IntersectionObserverEntry;
8728 };
8729
8730 interface KHR_parallel_shader_compile {
8731     readonly COMPLETION_STATUS_KHR: GLenum;
8732 }
8733
8734 /** 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. */
8735 interface KeyboardEvent extends UIEvent {
8736     readonly altKey: boolean;
8737     /** @deprecated */
8738     readonly charCode: number;
8739     readonly code: string;
8740     readonly ctrlKey: boolean;
8741     readonly isComposing: boolean;
8742     readonly key: string;
8743     /** @deprecated */
8744     readonly keyCode: number;
8745     readonly location: number;
8746     readonly metaKey: boolean;
8747     readonly repeat: boolean;
8748     readonly shiftKey: boolean;
8749     getModifierState(keyArg: string): boolean;
8750     /** @deprecated */
8751     initKeyboardEvent(typeArg: string, bubblesArg?: boolean, cancelableArg?: boolean, viewArg?: Window | null, keyArg?: string, locationArg?: number, ctrlKey?: boolean, altKey?: boolean, shiftKey?: boolean, metaKey?: boolean): void;
8752     readonly DOM_KEY_LOCATION_LEFT: number;
8753     readonly DOM_KEY_LOCATION_NUMPAD: number;
8754     readonly DOM_KEY_LOCATION_RIGHT: number;
8755     readonly DOM_KEY_LOCATION_STANDARD: number;
8756 }
8757
8758 declare var KeyboardEvent: {
8759     prototype: KeyboardEvent;
8760     new(type: string, eventInitDict?: KeyboardEventInit): KeyboardEvent;
8761     readonly DOM_KEY_LOCATION_LEFT: number;
8762     readonly DOM_KEY_LOCATION_NUMPAD: number;
8763     readonly DOM_KEY_LOCATION_RIGHT: number;
8764     readonly DOM_KEY_LOCATION_STANDARD: number;
8765 };
8766
8767 interface KeyframeEffect extends AnimationEffect {
8768     composite: CompositeOperation;
8769     iterationComposite: IterationCompositeOperation;
8770     pseudoElement: string | null;
8771     target: Element | null;
8772     getKeyframes(): ComputedKeyframe[];
8773     setKeyframes(keyframes: Keyframe[] | PropertyIndexedKeyframes | null): void;
8774 }
8775
8776 declare var KeyframeEffect: {
8777     prototype: KeyframeEffect;
8778     new(target: Element | null, keyframes: Keyframe[] | PropertyIndexedKeyframes | null, options?: number | KeyframeEffectOptions): KeyframeEffect;
8779     new(source: KeyframeEffect): KeyframeEffect;
8780 };
8781
8782 interface LinkStyle {
8783     readonly sheet: CSSStyleSheet | null;
8784 }
8785
8786 /** 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. */
8787 interface Location {
8788     /** Returns a DOMStringList object listing the origins of the ancestor browsing contexts, from the parent browsing context to the top-level browsing context. */
8789     readonly ancestorOrigins: DOMStringList;
8790     /**
8791      * Returns the Location object's URL's fragment (includes leading "#" if non-empty).
8792      *
8793      * Can be set, to navigate to the same URL with a changed fragment (ignores leading "#").
8794      */
8795     hash: string;
8796     /**
8797      * Returns the Location object's URL's host and port (if different from the default port for the scheme).
8798      *
8799      * Can be set, to navigate to the same URL with a changed host and port.
8800      */
8801     host: string;
8802     /**
8803      * Returns the Location object's URL's host.
8804      *
8805      * Can be set, to navigate to the same URL with a changed host.
8806      */
8807     hostname: string;
8808     /**
8809      * Returns the Location object's URL.
8810      *
8811      * Can be set, to navigate to the given URL.
8812      */
8813     href: string;
8814     toString(): string;
8815     /** Returns the Location object's URL's origin. */
8816     readonly origin: string;
8817     /**
8818      * Returns the Location object's URL's path.
8819      *
8820      * Can be set, to navigate to the same URL with a changed path.
8821      */
8822     pathname: string;
8823     /**
8824      * Returns the Location object's URL's port.
8825      *
8826      * Can be set, to navigate to the same URL with a changed port.
8827      */
8828     port: string;
8829     /**
8830      * Returns the Location object's URL's scheme.
8831      *
8832      * Can be set, to navigate to the same URL with a changed scheme.
8833      */
8834     protocol: string;
8835     /**
8836      * Returns the Location object's URL's query (includes leading "?" if non-empty).
8837      *
8838      * Can be set, to navigate to the same URL with a changed query (ignores leading "?").
8839      */
8840     search: string;
8841     /** Navigates to the given URL. */
8842     assign(url: string | URL): void;
8843     /** Reloads the current page. */
8844     reload(): void;
8845     /** Removes the current page from the session history and navigates to the given URL. */
8846     replace(url: string | URL): void;
8847 }
8848
8849 declare var Location: {
8850     prototype: Location;
8851     new(): Location;
8852 };
8853
8854 interface MathMLElementEventMap extends ElementEventMap, DocumentAndElementEventHandlersEventMap, GlobalEventHandlersEventMap {
8855 }
8856
8857 interface MathMLElement extends Element, DocumentAndElementEventHandlers, ElementCSSInlineStyle, GlobalEventHandlers, HTMLOrSVGElement {
8858     addEventListener<K extends keyof MathMLElementEventMap>(type: K, listener: (this: MathMLElement, ev: MathMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8859     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8860     removeEventListener<K extends keyof MathMLElementEventMap>(type: K, listener: (this: MathMLElement, ev: MathMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8861     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8862 }
8863
8864 declare var MathMLElement: {
8865     prototype: MathMLElement;
8866     new(): MathMLElement;
8867 };
8868
8869 interface MediaCapabilities {
8870     decodingInfo(configuration: MediaDecodingConfiguration): Promise<MediaCapabilitiesDecodingInfo>;
8871     encodingInfo(configuration: MediaEncodingConfiguration): Promise<MediaCapabilitiesEncodingInfo>;
8872 }
8873
8874 declare var MediaCapabilities: {
8875     prototype: MediaCapabilities;
8876     new(): MediaCapabilities;
8877 };
8878
8879 /**
8880  * The MediaDevicesInfo interface contains information that describes a single media input or output device.
8881  * Available only in secure contexts.
8882  */
8883 interface MediaDeviceInfo {
8884     readonly deviceId: string;
8885     readonly groupId: string;
8886     readonly kind: MediaDeviceKind;
8887     readonly label: string;
8888     toJSON(): any;
8889 }
8890
8891 declare var MediaDeviceInfo: {
8892     prototype: MediaDeviceInfo;
8893     new(): MediaDeviceInfo;
8894 };
8895
8896 interface MediaDevicesEventMap {
8897     "devicechange": Event;
8898 }
8899
8900 /**
8901  * 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.
8902  * Available only in secure contexts.
8903  */
8904 interface MediaDevices extends EventTarget {
8905     ondevicechange: ((this: MediaDevices, ev: Event) => any) | null;
8906     enumerateDevices(): Promise<MediaDeviceInfo[]>;
8907     getDisplayMedia(constraints?: DisplayMediaStreamConstraints): Promise<MediaStream>;
8908     getSupportedConstraints(): MediaTrackSupportedConstraints;
8909     getUserMedia(constraints?: MediaStreamConstraints): Promise<MediaStream>;
8910     addEventListener<K extends keyof MediaDevicesEventMap>(type: K, listener: (this: MediaDevices, ev: MediaDevicesEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8911     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8912     removeEventListener<K extends keyof MediaDevicesEventMap>(type: K, listener: (this: MediaDevices, ev: MediaDevicesEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8913     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8914 }
8915
8916 declare var MediaDevices: {
8917     prototype: MediaDevices;
8918     new(): MediaDevices;
8919 };
8920
8921 /** 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. */
8922 interface MediaElementAudioSourceNode extends AudioNode {
8923     readonly mediaElement: HTMLMediaElement;
8924 }
8925
8926 declare var MediaElementAudioSourceNode: {
8927     prototype: MediaElementAudioSourceNode;
8928     new(context: AudioContext, options: MediaElementAudioSourceOptions): MediaElementAudioSourceNode;
8929 };
8930
8931 interface MediaEncryptedEvent extends Event {
8932     readonly initData: ArrayBuffer | null;
8933     readonly initDataType: string;
8934 }
8935
8936 declare var MediaEncryptedEvent: {
8937     prototype: MediaEncryptedEvent;
8938     new(type: string, eventInitDict?: MediaEncryptedEventInit): MediaEncryptedEvent;
8939 };
8940
8941 /** An error which occurred while handling media in an HTML media element based on HTMLMediaElement, such as <audio> or <video>. */
8942 interface MediaError {
8943     readonly code: number;
8944     readonly message: string;
8945     readonly MEDIA_ERR_ABORTED: number;
8946     readonly MEDIA_ERR_DECODE: number;
8947     readonly MEDIA_ERR_NETWORK: number;
8948     readonly MEDIA_ERR_SRC_NOT_SUPPORTED: number;
8949 }
8950
8951 declare var MediaError: {
8952     prototype: MediaError;
8953     new(): MediaError;
8954     readonly MEDIA_ERR_ABORTED: number;
8955     readonly MEDIA_ERR_DECODE: number;
8956     readonly MEDIA_ERR_NETWORK: number;
8957     readonly MEDIA_ERR_SRC_NOT_SUPPORTED: number;
8958 };
8959
8960 /**
8961  * This EncryptedMediaExtensions API interface contains the content and related data when the content decryption module generates a message for the session.
8962  * Available only in secure contexts.
8963  */
8964 interface MediaKeyMessageEvent extends Event {
8965     readonly message: ArrayBuffer;
8966     readonly messageType: MediaKeyMessageType;
8967 }
8968
8969 declare var MediaKeyMessageEvent: {
8970     prototype: MediaKeyMessageEvent;
8971     new(type: string, eventInitDict: MediaKeyMessageEventInit): MediaKeyMessageEvent;
8972 };
8973
8974 interface MediaKeySessionEventMap {
8975     "keystatuseschange": Event;
8976     "message": MediaKeyMessageEvent;
8977 }
8978
8979 /**
8980  * This EncryptedMediaExtensions API interface represents a context for message exchange with a content decryption module (CDM).
8981  * Available only in secure contexts.
8982  */
8983 interface MediaKeySession extends EventTarget {
8984     readonly closed: Promise<MediaKeySessionClosedReason>;
8985     readonly expiration: number;
8986     readonly keyStatuses: MediaKeyStatusMap;
8987     onkeystatuseschange: ((this: MediaKeySession, ev: Event) => any) | null;
8988     onmessage: ((this: MediaKeySession, ev: MediaKeyMessageEvent) => any) | null;
8989     readonly sessionId: string;
8990     close(): Promise<void>;
8991     generateRequest(initDataType: string, initData: BufferSource): Promise<void>;
8992     load(sessionId: string): Promise<boolean>;
8993     remove(): Promise<void>;
8994     update(response: BufferSource): Promise<void>;
8995     addEventListener<K extends keyof MediaKeySessionEventMap>(type: K, listener: (this: MediaKeySession, ev: MediaKeySessionEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8996     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8997     removeEventListener<K extends keyof MediaKeySessionEventMap>(type: K, listener: (this: MediaKeySession, ev: MediaKeySessionEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8998     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8999 }
9000
9001 declare var MediaKeySession: {
9002     prototype: MediaKeySession;
9003     new(): MediaKeySession;
9004 };
9005
9006 /**
9007  * This EncryptedMediaExtensions API interface is a read-only map of media key statuses by key IDs.
9008  * Available only in secure contexts.
9009  */
9010 interface MediaKeyStatusMap {
9011     readonly size: number;
9012     get(keyId: BufferSource): MediaKeyStatus | undefined;
9013     has(keyId: BufferSource): boolean;
9014     forEach(callbackfn: (value: MediaKeyStatus, key: BufferSource, parent: MediaKeyStatusMap) => void, thisArg?: any): void;
9015 }
9016
9017 declare var MediaKeyStatusMap: {
9018     prototype: MediaKeyStatusMap;
9019     new(): MediaKeyStatusMap;
9020 };
9021
9022 /**
9023  * 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.
9024  * Available only in secure contexts.
9025  */
9026 interface MediaKeySystemAccess {
9027     readonly keySystem: string;
9028     createMediaKeys(): Promise<MediaKeys>;
9029     getConfiguration(): MediaKeySystemConfiguration;
9030 }
9031
9032 declare var MediaKeySystemAccess: {
9033     prototype: MediaKeySystemAccess;
9034     new(): MediaKeySystemAccess;
9035 };
9036
9037 /**
9038  * This EncryptedMediaExtensions API interface the represents a set of keys that an associated HTMLMediaElement can use for decryption of media data during playback.
9039  * Available only in secure contexts.
9040  */
9041 interface MediaKeys {
9042     createSession(sessionType?: MediaKeySessionType): MediaKeySession;
9043     setServerCertificate(serverCertificate: BufferSource): Promise<boolean>;
9044 }
9045
9046 declare var MediaKeys: {
9047     prototype: MediaKeys;
9048     new(): MediaKeys;
9049 };
9050
9051 interface MediaList {
9052     readonly length: number;
9053     mediaText: string;
9054     toString(): string;
9055     appendMedium(medium: string): void;
9056     deleteMedium(medium: string): void;
9057     item(index: number): string | null;
9058     [index: number]: string;
9059 }
9060
9061 declare var MediaList: {
9062     prototype: MediaList;
9063     new(): MediaList;
9064 };
9065
9066 interface MediaMetadata {
9067     album: string;
9068     artist: string;
9069     artwork: ReadonlyArray<MediaImage>;
9070     title: string;
9071 }
9072
9073 declare var MediaMetadata: {
9074     prototype: MediaMetadata;
9075     new(init?: MediaMetadataInit): MediaMetadata;
9076 };
9077
9078 interface MediaQueryListEventMap {
9079     "change": MediaQueryListEvent;
9080 }
9081
9082 /** 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). */
9083 interface MediaQueryList extends EventTarget {
9084     readonly matches: boolean;
9085     readonly media: string;
9086     onchange: ((this: MediaQueryList, ev: MediaQueryListEvent) => any) | null;
9087     /** @deprecated */
9088     addListener(callback: ((this: MediaQueryList, ev: MediaQueryListEvent) => any) | null): void;
9089     /** @deprecated */
9090     removeListener(callback: ((this: MediaQueryList, ev: MediaQueryListEvent) => any) | null): void;
9091     addEventListener<K extends keyof MediaQueryListEventMap>(type: K, listener: (this: MediaQueryList, ev: MediaQueryListEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9092     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9093     removeEventListener<K extends keyof MediaQueryListEventMap>(type: K, listener: (this: MediaQueryList, ev: MediaQueryListEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9094     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9095 }
9096
9097 declare var MediaQueryList: {
9098     prototype: MediaQueryList;
9099     new(): MediaQueryList;
9100 };
9101
9102 interface MediaQueryListEvent extends Event {
9103     readonly matches: boolean;
9104     readonly media: string;
9105 }
9106
9107 declare var MediaQueryListEvent: {
9108     prototype: MediaQueryListEvent;
9109     new(type: string, eventInitDict?: MediaQueryListEventInit): MediaQueryListEvent;
9110 };
9111
9112 interface MediaRecorderEventMap {
9113     "dataavailable": BlobEvent;
9114     "error": MediaRecorderErrorEvent;
9115     "pause": Event;
9116     "resume": Event;
9117     "start": Event;
9118     "stop": Event;
9119 }
9120
9121 interface MediaRecorder extends EventTarget {
9122     readonly audioBitsPerSecond: number;
9123     readonly mimeType: string;
9124     ondataavailable: ((this: MediaRecorder, ev: BlobEvent) => any) | null;
9125     onerror: ((this: MediaRecorder, ev: MediaRecorderErrorEvent) => any) | null;
9126     onpause: ((this: MediaRecorder, ev: Event) => any) | null;
9127     onresume: ((this: MediaRecorder, ev: Event) => any) | null;
9128     onstart: ((this: MediaRecorder, ev: Event) => any) | null;
9129     onstop: ((this: MediaRecorder, ev: Event) => any) | null;
9130     readonly state: RecordingState;
9131     readonly stream: MediaStream;
9132     readonly videoBitsPerSecond: number;
9133     pause(): void;
9134     requestData(): void;
9135     resume(): void;
9136     start(timeslice?: number): void;
9137     stop(): void;
9138     addEventListener<K extends keyof MediaRecorderEventMap>(type: K, listener: (this: MediaRecorder, ev: MediaRecorderEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9139     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9140     removeEventListener<K extends keyof MediaRecorderEventMap>(type: K, listener: (this: MediaRecorder, ev: MediaRecorderEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9141     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9142 }
9143
9144 declare var MediaRecorder: {
9145     prototype: MediaRecorder;
9146     new(stream: MediaStream, options?: MediaRecorderOptions): MediaRecorder;
9147     isTypeSupported(type: string): boolean;
9148 };
9149
9150 interface MediaRecorderErrorEvent extends Event {
9151     readonly error: DOMException;
9152 }
9153
9154 declare var MediaRecorderErrorEvent: {
9155     prototype: MediaRecorderErrorEvent;
9156     new(type: string, eventInitDict: MediaRecorderErrorEventInit): MediaRecorderErrorEvent;
9157 };
9158
9159 interface MediaSession {
9160     metadata: MediaMetadata | null;
9161     playbackState: MediaSessionPlaybackState;
9162     setActionHandler(action: MediaSessionAction, handler: MediaSessionActionHandler | null): void;
9163     setPositionState(state?: MediaPositionState): void;
9164 }
9165
9166 declare var MediaSession: {
9167     prototype: MediaSession;
9168     new(): MediaSession;
9169 };
9170
9171 interface MediaSourceEventMap {
9172     "sourceclose": Event;
9173     "sourceended": Event;
9174     "sourceopen": Event;
9175 }
9176
9177 /** 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. */
9178 interface MediaSource extends EventTarget {
9179     readonly activeSourceBuffers: SourceBufferList;
9180     duration: number;
9181     onsourceclose: ((this: MediaSource, ev: Event) => any) | null;
9182     onsourceended: ((this: MediaSource, ev: Event) => any) | null;
9183     onsourceopen: ((this: MediaSource, ev: Event) => any) | null;
9184     readonly readyState: ReadyState;
9185     readonly sourceBuffers: SourceBufferList;
9186     addSourceBuffer(type: string): SourceBuffer;
9187     clearLiveSeekableRange(): void;
9188     endOfStream(error?: EndOfStreamError): void;
9189     removeSourceBuffer(sourceBuffer: SourceBuffer): void;
9190     setLiveSeekableRange(start: number, end: number): void;
9191     addEventListener<K extends keyof MediaSourceEventMap>(type: K, listener: (this: MediaSource, ev: MediaSourceEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9192     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9193     removeEventListener<K extends keyof MediaSourceEventMap>(type: K, listener: (this: MediaSource, ev: MediaSourceEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9194     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9195 }
9196
9197 declare var MediaSource: {
9198     prototype: MediaSource;
9199     new(): MediaSource;
9200     isTypeSupported(type: string): boolean;
9201 };
9202
9203 interface MediaStreamEventMap {
9204     "addtrack": MediaStreamTrackEvent;
9205     "removetrack": MediaStreamTrackEvent;
9206 }
9207
9208 /** 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. */
9209 interface MediaStream extends EventTarget {
9210     readonly active: boolean;
9211     readonly id: string;
9212     onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
9213     onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
9214     addTrack(track: MediaStreamTrack): void;
9215     clone(): MediaStream;
9216     getAudioTracks(): MediaStreamTrack[];
9217     getTrackById(trackId: string): MediaStreamTrack | null;
9218     getTracks(): MediaStreamTrack[];
9219     getVideoTracks(): MediaStreamTrack[];
9220     removeTrack(track: MediaStreamTrack): void;
9221     addEventListener<K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9222     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9223     removeEventListener<K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9224     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9225 }
9226
9227 declare var MediaStream: {
9228     prototype: MediaStream;
9229     new(): MediaStream;
9230     new(stream: MediaStream): MediaStream;
9231     new(tracks: MediaStreamTrack[]): MediaStream;
9232 };
9233
9234 interface MediaStreamAudioDestinationNode extends AudioNode {
9235     readonly stream: MediaStream;
9236 }
9237
9238 declare var MediaStreamAudioDestinationNode: {
9239     prototype: MediaStreamAudioDestinationNode;
9240     new(context: AudioContext, options?: AudioNodeOptions): MediaStreamAudioDestinationNode;
9241 };
9242
9243 /** 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. */
9244 interface MediaStreamAudioSourceNode extends AudioNode {
9245     readonly mediaStream: MediaStream;
9246 }
9247
9248 declare var MediaStreamAudioSourceNode: {
9249     prototype: MediaStreamAudioSourceNode;
9250     new(context: AudioContext, options: MediaStreamAudioSourceOptions): MediaStreamAudioSourceNode;
9251 };
9252
9253 interface MediaStreamTrackEventMap {
9254     "ended": Event;
9255     "mute": Event;
9256     "unmute": Event;
9257 }
9258
9259 /** A single media track within a stream; typically, these are audio or video tracks, but other track types may exist as well. */
9260 interface MediaStreamTrack extends EventTarget {
9261     contentHint: string;
9262     enabled: boolean;
9263     readonly id: string;
9264     readonly kind: string;
9265     readonly label: string;
9266     readonly muted: boolean;
9267     onended: ((this: MediaStreamTrack, ev: Event) => any) | null;
9268     onmute: ((this: MediaStreamTrack, ev: Event) => any) | null;
9269     onunmute: ((this: MediaStreamTrack, ev: Event) => any) | null;
9270     readonly readyState: MediaStreamTrackState;
9271     applyConstraints(constraints?: MediaTrackConstraints): Promise<void>;
9272     clone(): MediaStreamTrack;
9273     getCapabilities(): MediaTrackCapabilities;
9274     getConstraints(): MediaTrackConstraints;
9275     getSettings(): MediaTrackSettings;
9276     stop(): void;
9277     addEventListener<K extends keyof MediaStreamTrackEventMap>(type: K, listener: (this: MediaStreamTrack, ev: MediaStreamTrackEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9278     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9279     removeEventListener<K extends keyof MediaStreamTrackEventMap>(type: K, listener: (this: MediaStreamTrack, ev: MediaStreamTrackEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9280     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9281 }
9282
9283 declare var MediaStreamTrack: {
9284     prototype: MediaStreamTrack;
9285     new(): MediaStreamTrack;
9286 };
9287
9288 /** 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. */
9289 interface MediaStreamTrackEvent extends Event {
9290     readonly track: MediaStreamTrack;
9291 }
9292
9293 declare var MediaStreamTrackEvent: {
9294     prototype: MediaStreamTrackEvent;
9295     new(type: string, eventInitDict: MediaStreamTrackEventInit): MediaStreamTrackEvent;
9296 };
9297
9298 /** This Channel Messaging API interface allows us to create a new message channel and send data through it via its two MessagePort properties. */
9299 interface MessageChannel {
9300     /** Returns the first MessagePort object. */
9301     readonly port1: MessagePort;
9302     /** Returns the second MessagePort object. */
9303     readonly port2: MessagePort;
9304 }
9305
9306 declare var MessageChannel: {
9307     prototype: MessageChannel;
9308     new(): MessageChannel;
9309 };
9310
9311 /** A message received by a target object. */
9312 interface MessageEvent<T = any> extends Event {
9313     /** Returns the data of the message. */
9314     readonly data: T;
9315     /** Returns the last event ID string, for server-sent events. */
9316     readonly lastEventId: string;
9317     /** Returns the origin of the message, for server-sent events and cross-document messaging. */
9318     readonly origin: string;
9319     /** Returns the MessagePort array sent with the message, for cross-document messaging and channel messaging. */
9320     readonly ports: ReadonlyArray<MessagePort>;
9321     /** Returns the WindowProxy of the source window, for cross-document messaging, and the MessagePort being attached, in the connect event fired at SharedWorkerGlobalScope objects. */
9322     readonly source: MessageEventSource | null;
9323     /** @deprecated */
9324     initMessageEvent(type: string, bubbles?: boolean, cancelable?: boolean, data?: any, origin?: string, lastEventId?: string, source?: MessageEventSource | null, ports?: MessagePort[]): void;
9325 }
9326
9327 declare var MessageEvent: {
9328     prototype: MessageEvent;
9329     new<T>(type: string, eventInitDict?: MessageEventInit<T>): MessageEvent<T>;
9330 };
9331
9332 interface MessagePortEventMap {
9333     "message": MessageEvent;
9334     "messageerror": MessageEvent;
9335 }
9336
9337 /** 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. */
9338 interface MessagePort extends EventTarget {
9339     onmessage: ((this: MessagePort, ev: MessageEvent) => any) | null;
9340     onmessageerror: ((this: MessagePort, ev: MessageEvent) => any) | null;
9341     /** Disconnects the port, so that it is no longer active. */
9342     close(): void;
9343     /**
9344      * 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.
9345      *
9346      * Throws a "DataCloneError" DOMException if transfer contains duplicate objects or port, or if message could not be cloned.
9347      */
9348     postMessage(message: any, transfer: Transferable[]): void;
9349     postMessage(message: any, options?: StructuredSerializeOptions): void;
9350     /** Begins dispatching messages received on the port. */
9351     start(): void;
9352     addEventListener<K extends keyof MessagePortEventMap>(type: K, listener: (this: MessagePort, ev: MessagePortEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9353     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9354     removeEventListener<K extends keyof MessagePortEventMap>(type: K, listener: (this: MessagePort, ev: MessagePortEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9355     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9356 }
9357
9358 declare var MessagePort: {
9359     prototype: MessagePort;
9360     new(): MessagePort;
9361 };
9362
9363 /**
9364  * Provides contains information about a MIME type associated with a particular plugin. NavigatorPlugins.mimeTypes returns an array of this object.
9365  * @deprecated
9366  */
9367 interface MimeType {
9368     /**
9369      * Returns the MIME type's description.
9370      * @deprecated
9371      */
9372     readonly description: string;
9373     /**
9374      * Returns the Plugin object that implements this MIME type.
9375      * @deprecated
9376      */
9377     readonly enabledPlugin: Plugin;
9378     /**
9379      * Returns the MIME type's typical file extensions, in a comma-separated list.
9380      * @deprecated
9381      */
9382     readonly suffixes: string;
9383     /**
9384      * Returns the MIME type.
9385      * @deprecated
9386      */
9387     readonly type: string;
9388 }
9389
9390 /** @deprecated */
9391 declare var MimeType: {
9392     prototype: MimeType;
9393     new(): MimeType;
9394 };
9395
9396 /**
9397  * Returns an array of MimeType instances, each of which contains information about a supported browser plugins. This object is returned by NavigatorPlugins.mimeTypes.
9398  * @deprecated
9399  */
9400 interface MimeTypeArray {
9401     /** @deprecated */
9402     readonly length: number;
9403     /** @deprecated */
9404     item(index: number): MimeType | null;
9405     /** @deprecated */
9406     namedItem(name: string): MimeType | null;
9407     [index: number]: MimeType;
9408 }
9409
9410 /** @deprecated */
9411 declare var MimeTypeArray: {
9412     prototype: MimeTypeArray;
9413     new(): MimeTypeArray;
9414 };
9415
9416 /** 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. */
9417 interface MouseEvent extends UIEvent {
9418     readonly altKey: boolean;
9419     readonly button: number;
9420     readonly buttons: number;
9421     readonly clientX: number;
9422     readonly clientY: number;
9423     readonly ctrlKey: boolean;
9424     readonly metaKey: boolean;
9425     readonly movementX: number;
9426     readonly movementY: number;
9427     readonly offsetX: number;
9428     readonly offsetY: number;
9429     readonly pageX: number;
9430     readonly pageY: number;
9431     readonly relatedTarget: EventTarget | null;
9432     readonly screenX: number;
9433     readonly screenY: number;
9434     readonly shiftKey: boolean;
9435     readonly x: number;
9436     readonly y: number;
9437     getModifierState(keyArg: string): boolean;
9438     /** @deprecated */
9439     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;
9440 }
9441
9442 declare var MouseEvent: {
9443     prototype: MouseEvent;
9444     new(type: string, eventInitDict?: MouseEventInit): MouseEvent;
9445 };
9446
9447 /**
9448  * Provides event properties that are specific to modifications to the Document Object Model (DOM) hierarchy and nodes.
9449  * @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.
9450  */
9451 interface MutationEvent extends Event {
9452     /** @deprecated */
9453     readonly attrChange: number;
9454     /** @deprecated */
9455     readonly attrName: string;
9456     /** @deprecated */
9457     readonly newValue: string;
9458     /** @deprecated */
9459     readonly prevValue: string;
9460     /** @deprecated */
9461     readonly relatedNode: Node | null;
9462     /** @deprecated */
9463     initMutationEvent(typeArg: string, bubblesArg?: boolean, cancelableArg?: boolean, relatedNodeArg?: Node | null, prevValueArg?: string, newValueArg?: string, attrNameArg?: string, attrChangeArg?: number): void;
9464     readonly ADDITION: number;
9465     readonly MODIFICATION: number;
9466     readonly REMOVAL: number;
9467 }
9468
9469 /** @deprecated */
9470 declare var MutationEvent: {
9471     prototype: MutationEvent;
9472     new(): MutationEvent;
9473     readonly ADDITION: number;
9474     readonly MODIFICATION: number;
9475     readonly REMOVAL: number;
9476 };
9477
9478 /** 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. */
9479 interface MutationObserver {
9480     /** Stops observer from observing any mutations. Until the observe() method is used again, observer's callback will not be invoked. */
9481     disconnect(): void;
9482     /**
9483      * Instructs the user agent to observe a given target (a node) and report any mutations based on the criteria given by options (an object).
9484      *
9485      * The options argument allows for setting mutation observation options via object members.
9486      */
9487     observe(target: Node, options?: MutationObserverInit): void;
9488     /** Empties the record queue and returns what was in there. */
9489     takeRecords(): MutationRecord[];
9490 }
9491
9492 declare var MutationObserver: {
9493     prototype: MutationObserver;
9494     new(callback: MutationCallback): MutationObserver;
9495 };
9496
9497 /** A MutationRecord represents an individual DOM mutation. It is the object that is passed to MutationObserver's callback. */
9498 interface MutationRecord {
9499     /** Return the nodes added and removed respectively. */
9500     readonly addedNodes: NodeList;
9501     /** Returns the local name of the changed attribute, and null otherwise. */
9502     readonly attributeName: string | null;
9503     /** Returns the namespace of the changed attribute, and null otherwise. */
9504     readonly attributeNamespace: string | null;
9505     /** Return the previous and next sibling respectively of the added or removed nodes, and null otherwise. */
9506     readonly nextSibling: Node | null;
9507     /** 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. */
9508     readonly oldValue: string | null;
9509     /** Return the previous and next sibling respectively of the added or removed nodes, and null otherwise. */
9510     readonly previousSibling: Node | null;
9511     /** Return the nodes added and removed respectively. */
9512     readonly removedNodes: NodeList;
9513     /** 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. */
9514     readonly target: Node;
9515     /** 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. */
9516     readonly type: MutationRecordType;
9517 }
9518
9519 declare var MutationRecord: {
9520     prototype: MutationRecord;
9521     new(): MutationRecord;
9522 };
9523
9524 /** 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. */
9525 interface NamedNodeMap {
9526     readonly length: number;
9527     getNamedItem(qualifiedName: string): Attr | null;
9528     getNamedItemNS(namespace: string | null, localName: string): Attr | null;
9529     item(index: number): Attr | null;
9530     removeNamedItem(qualifiedName: string): Attr;
9531     removeNamedItemNS(namespace: string | null, localName: string): Attr;
9532     setNamedItem(attr: Attr): Attr | null;
9533     setNamedItemNS(attr: Attr): Attr | null;
9534     [index: number]: Attr;
9535 }
9536
9537 declare var NamedNodeMap: {
9538     prototype: NamedNodeMap;
9539     new(): NamedNodeMap;
9540 };
9541
9542 /** The state and the identity of the user agent. It allows scripts to query it and to register themselves to carry on some activities. */
9543 interface Navigator extends NavigatorAutomationInformation, NavigatorConcurrentHardware, NavigatorContentUtils, NavigatorCookies, NavigatorID, NavigatorLanguage, NavigatorNetworkInformation, NavigatorOnLine, NavigatorPlugins, NavigatorStorage {
9544     /** Available only in secure contexts. */
9545     readonly clipboard: Clipboard;
9546     /** Available only in secure contexts. */
9547     readonly credentials: CredentialsContainer;
9548     readonly doNotTrack: string | null;
9549     readonly geolocation: Geolocation;
9550     readonly maxTouchPoints: number;
9551     readonly mediaCapabilities: MediaCapabilities;
9552     /** Available only in secure contexts. */
9553     readonly mediaDevices: MediaDevices;
9554     readonly mediaSession: MediaSession;
9555     readonly permissions: Permissions;
9556     /** Available only in secure contexts. */
9557     readonly serviceWorker: ServiceWorkerContainer;
9558     /** Available only in secure contexts. */
9559     canShare(data?: ShareData): boolean;
9560     getGamepads(): (Gamepad | null)[];
9561     /** Available only in secure contexts. */
9562     requestMediaKeySystemAccess(keySystem: string, supportedConfigurations: MediaKeySystemConfiguration[]): Promise<MediaKeySystemAccess>;
9563     sendBeacon(url: string | URL, data?: BodyInit | null): boolean;
9564     /** Available only in secure contexts. */
9565     share(data?: ShareData): Promise<void>;
9566     vibrate(pattern: VibratePattern): boolean;
9567 }
9568
9569 declare var Navigator: {
9570     prototype: Navigator;
9571     new(): Navigator;
9572 };
9573
9574 interface NavigatorAutomationInformation {
9575     readonly webdriver: boolean;
9576 }
9577
9578 interface NavigatorConcurrentHardware {
9579     readonly hardwareConcurrency: number;
9580 }
9581
9582 interface NavigatorContentUtils {
9583     /** Available only in secure contexts. */
9584     registerProtocolHandler(scheme: string, url: string | URL): void;
9585 }
9586
9587 interface NavigatorCookies {
9588     readonly cookieEnabled: boolean;
9589 }
9590
9591 interface NavigatorID {
9592     /** @deprecated */
9593     readonly appCodeName: string;
9594     /** @deprecated */
9595     readonly appName: string;
9596     /** @deprecated */
9597     readonly appVersion: string;
9598     /** @deprecated */
9599     readonly platform: string;
9600     /** @deprecated */
9601     readonly product: string;
9602     /** @deprecated */
9603     readonly productSub: string;
9604     readonly userAgent: string;
9605     readonly vendor: string;
9606     /** @deprecated */
9607     readonly vendorSub: string;
9608 }
9609
9610 interface NavigatorLanguage {
9611     readonly language: string;
9612     readonly languages: ReadonlyArray<string>;
9613 }
9614
9615 interface NavigatorNetworkInformation {
9616     readonly connection: NetworkInformation;
9617 }
9618
9619 interface NavigatorOnLine {
9620     readonly onLine: boolean;
9621 }
9622
9623 interface NavigatorPlugins {
9624     /** @deprecated */
9625     readonly mimeTypes: MimeTypeArray;
9626     /** @deprecated */
9627     readonly plugins: PluginArray;
9628     /** @deprecated */
9629     javaEnabled(): boolean;
9630 }
9631
9632 /** Available only in secure contexts. */
9633 interface NavigatorStorage {
9634     readonly storage: StorageManager;
9635 }
9636
9637 interface NetworkInformation extends EventTarget {
9638     readonly type: ConnectionType;
9639 }
9640
9641 declare var NetworkInformation: {
9642     prototype: NetworkInformation;
9643     new(): NetworkInformation;
9644 };
9645
9646 /** 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. */
9647 interface Node extends EventTarget {
9648     /** Returns node's node document's document base URL. */
9649     readonly baseURI: string;
9650     /** Returns the children. */
9651     readonly childNodes: NodeListOf<ChildNode>;
9652     /** Returns the first child. */
9653     readonly firstChild: ChildNode | null;
9654     /** Returns true if node is connected and false otherwise. */
9655     readonly isConnected: boolean;
9656     /** Returns the last child. */
9657     readonly lastChild: ChildNode | null;
9658     /** Returns the next sibling. */
9659     readonly nextSibling: ChildNode | null;
9660     /** Returns a string appropriate for the type of node. */
9661     readonly nodeName: string;
9662     /** Returns the type of node. */
9663     readonly nodeType: number;
9664     nodeValue: string | null;
9665     /** Returns the node document. Returns null for documents. */
9666     readonly ownerDocument: Document | null;
9667     /** Returns the parent element. */
9668     readonly parentElement: HTMLElement | null;
9669     /** Returns the parent. */
9670     readonly parentNode: ParentNode | null;
9671     /** Returns the previous sibling. */
9672     readonly previousSibling: ChildNode | null;
9673     textContent: string | null;
9674     appendChild<T extends Node>(node: T): T;
9675     /** Returns a copy of node. If deep is true, the copy also includes the node's descendants. */
9676     cloneNode(deep?: boolean): Node;
9677     /** Returns a bitmask indicating the position of other relative to node. */
9678     compareDocumentPosition(other: Node): number;
9679     /** Returns true if other is an inclusive descendant of node, and false otherwise. */
9680     contains(other: Node | null): boolean;
9681     /** Returns node's root. */
9682     getRootNode(options?: GetRootNodeOptions): Node;
9683     /** Returns whether node has children. */
9684     hasChildNodes(): boolean;
9685     insertBefore<T extends Node>(node: T, child: Node | null): T;
9686     isDefaultNamespace(namespace: string | null): boolean;
9687     /** Returns whether node and otherNode have the same properties. */
9688     isEqualNode(otherNode: Node | null): boolean;
9689     isSameNode(otherNode: Node | null): boolean;
9690     lookupNamespaceURI(prefix: string | null): string | null;
9691     lookupPrefix(namespace: string | null): string | null;
9692     /** Removes empty exclusive Text nodes and concatenates the data of remaining contiguous exclusive Text nodes into the first of their nodes. */
9693     normalize(): void;
9694     removeChild<T extends Node>(child: T): T;
9695     replaceChild<T extends Node>(node: Node, child: T): T;
9696     readonly ATTRIBUTE_NODE: number;
9697     /** node is a CDATASection node. */
9698     readonly CDATA_SECTION_NODE: number;
9699     /** node is a Comment node. */
9700     readonly COMMENT_NODE: number;
9701     /** node is a DocumentFragment node. */
9702     readonly DOCUMENT_FRAGMENT_NODE: number;
9703     /** node is a document. */
9704     readonly DOCUMENT_NODE: number;
9705     /** Set when other is a descendant of node. */
9706     readonly DOCUMENT_POSITION_CONTAINED_BY: number;
9707     /** Set when other is an ancestor of node. */
9708     readonly DOCUMENT_POSITION_CONTAINS: number;
9709     /** Set when node and other are not in the same tree. */
9710     readonly DOCUMENT_POSITION_DISCONNECTED: number;
9711     /** Set when other is following node. */
9712     readonly DOCUMENT_POSITION_FOLLOWING: number;
9713     readonly DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC: number;
9714     /** Set when other is preceding node. */
9715     readonly DOCUMENT_POSITION_PRECEDING: number;
9716     /** node is a doctype. */
9717     readonly DOCUMENT_TYPE_NODE: number;
9718     /** node is an element. */
9719     readonly ELEMENT_NODE: number;
9720     readonly ENTITY_NODE: number;
9721     readonly ENTITY_REFERENCE_NODE: number;
9722     readonly NOTATION_NODE: number;
9723     /** node is a ProcessingInstruction node. */
9724     readonly PROCESSING_INSTRUCTION_NODE: number;
9725     /** node is a Text node. */
9726     readonly TEXT_NODE: number;
9727 }
9728
9729 declare var Node: {
9730     prototype: Node;
9731     new(): Node;
9732     readonly ATTRIBUTE_NODE: number;
9733     /** node is a CDATASection node. */
9734     readonly CDATA_SECTION_NODE: number;
9735     /** node is a Comment node. */
9736     readonly COMMENT_NODE: number;
9737     /** node is a DocumentFragment node. */
9738     readonly DOCUMENT_FRAGMENT_NODE: number;
9739     /** node is a document. */
9740     readonly DOCUMENT_NODE: number;
9741     /** Set when other is a descendant of node. */
9742     readonly DOCUMENT_POSITION_CONTAINED_BY: number;
9743     /** Set when other is an ancestor of node. */
9744     readonly DOCUMENT_POSITION_CONTAINS: number;
9745     /** Set when node and other are not in the same tree. */
9746     readonly DOCUMENT_POSITION_DISCONNECTED: number;
9747     /** Set when other is following node. */
9748     readonly DOCUMENT_POSITION_FOLLOWING: number;
9749     readonly DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC: number;
9750     /** Set when other is preceding node. */
9751     readonly DOCUMENT_POSITION_PRECEDING: number;
9752     /** node is a doctype. */
9753     readonly DOCUMENT_TYPE_NODE: number;
9754     /** node is an element. */
9755     readonly ELEMENT_NODE: number;
9756     readonly ENTITY_NODE: number;
9757     readonly ENTITY_REFERENCE_NODE: number;
9758     readonly NOTATION_NODE: number;
9759     /** node is a ProcessingInstruction node. */
9760     readonly PROCESSING_INSTRUCTION_NODE: number;
9761     /** node is a Text node. */
9762     readonly TEXT_NODE: number;
9763 };
9764
9765 /** 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. */
9766 interface NodeIterator {
9767     readonly filter: NodeFilter | null;
9768     readonly pointerBeforeReferenceNode: boolean;
9769     readonly referenceNode: Node;
9770     readonly root: Node;
9771     readonly whatToShow: number;
9772     /** @deprecated */
9773     detach(): void;
9774     nextNode(): Node | null;
9775     previousNode(): Node | null;
9776 }
9777
9778 declare var NodeIterator: {
9779     prototype: NodeIterator;
9780     new(): NodeIterator;
9781 };
9782
9783 /** NodeList objects are collections of nodes, usually returned by properties such as Node.childNodes and methods such as document.querySelectorAll(). */
9784 interface NodeList {
9785     /** Returns the number of nodes in the collection. */
9786     readonly length: number;
9787     /** Returns the node with index index from the collection. The nodes are sorted in tree order. */
9788     item(index: number): Node | null;
9789     /**
9790      * Performs the specified action for each node in an list.
9791      * @param callbackfn  A function that accepts up to three arguments. forEach calls the callbackfn function one time for each element in the list.
9792      * @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.
9793      */
9794     forEach(callbackfn: (value: Node, key: number, parent: NodeList) => void, thisArg?: any): void;
9795     [index: number]: Node;
9796 }
9797
9798 declare var NodeList: {
9799     prototype: NodeList;
9800     new(): NodeList;
9801 };
9802
9803 interface NodeListOf<TNode extends Node> extends NodeList {
9804     item(index: number): TNode;
9805     /**
9806      * Performs the specified action for each node in an list.
9807      * @param callbackfn  A function that accepts up to three arguments. forEach calls the callbackfn function one time for each element in the list.
9808      * @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.
9809      */
9810     forEach(callbackfn: (value: TNode, key: number, parent: NodeListOf<TNode>) => void, thisArg?: any): void;
9811     [index: number]: TNode;
9812 }
9813
9814 interface NonDocumentTypeChildNode {
9815     /** Returns the first following sibling that is an element, and null otherwise. */
9816     readonly nextElementSibling: Element | null;
9817     /** Returns the first preceding sibling that is an element, and null otherwise. */
9818     readonly previousElementSibling: Element | null;
9819 }
9820
9821 interface NonElementParentNode {
9822     /** Returns the first element within node's descendants whose ID is elementId. */
9823     getElementById(elementId: string): Element | null;
9824 }
9825
9826 interface NotificationEventMap {
9827     "click": Event;
9828     "close": Event;
9829     "error": Event;
9830     "show": Event;
9831 }
9832
9833 /** This Notifications API interface is used to configure and display desktop notifications to the user. */
9834 interface Notification extends EventTarget {
9835     readonly body: string;
9836     readonly data: any;
9837     readonly dir: NotificationDirection;
9838     readonly icon: string;
9839     readonly lang: string;
9840     onclick: ((this: Notification, ev: Event) => any) | null;
9841     onclose: ((this: Notification, ev: Event) => any) | null;
9842     onerror: ((this: Notification, ev: Event) => any) | null;
9843     onshow: ((this: Notification, ev: Event) => any) | null;
9844     readonly tag: string;
9845     readonly title: string;
9846     close(): void;
9847     addEventListener<K extends keyof NotificationEventMap>(type: K, listener: (this: Notification, ev: NotificationEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9848     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9849     removeEventListener<K extends keyof NotificationEventMap>(type: K, listener: (this: Notification, ev: NotificationEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9850     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9851 }
9852
9853 declare var Notification: {
9854     prototype: Notification;
9855     new(title: string, options?: NotificationOptions): Notification;
9856     readonly permission: NotificationPermission;
9857     requestPermission(deprecatedCallback?: NotificationPermissionCallback): Promise<NotificationPermission>;
9858 };
9859
9860 /** The OES_element_index_uint extension is part of the WebGL API and adds support for gl.UNSIGNED_INT types to WebGLRenderingContext.drawElements(). */
9861 interface OES_element_index_uint {
9862 }
9863
9864 interface OES_fbo_render_mipmap {
9865 }
9866
9867 /** The OES_standard_derivatives extension is part of the WebGL API and adds the GLSL derivative functions dFdx, dFdy, and fwidth. */
9868 interface OES_standard_derivatives {
9869     readonly FRAGMENT_SHADER_DERIVATIVE_HINT_OES: GLenum;
9870 }
9871
9872 /** The OES_texture_float extension is part of the WebGL API and exposes floating-point pixel types for textures. */
9873 interface OES_texture_float {
9874 }
9875
9876 /** The OES_texture_float_linear extension is part of the WebGL API and allows linear filtering with floating-point pixel types for textures. */
9877 interface OES_texture_float_linear {
9878 }
9879
9880 /** 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. */
9881 interface OES_texture_half_float {
9882     readonly HALF_FLOAT_OES: GLenum;
9883 }
9884
9885 /** 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. */
9886 interface OES_texture_half_float_linear {
9887 }
9888
9889 interface OES_vertex_array_object {
9890     bindVertexArrayOES(arrayObject: WebGLVertexArrayObjectOES | null): void;
9891     createVertexArrayOES(): WebGLVertexArrayObjectOES | null;
9892     deleteVertexArrayOES(arrayObject: WebGLVertexArrayObjectOES | null): void;
9893     isVertexArrayOES(arrayObject: WebGLVertexArrayObjectOES | null): GLboolean;
9894     readonly VERTEX_ARRAY_BINDING_OES: GLenum;
9895 }
9896
9897 interface OVR_multiview2 {
9898     framebufferTextureMultiviewOVR(target: GLenum, attachment: GLenum, texture: WebGLTexture | null, level: GLint, baseViewIndex: GLint, numViews: GLsizei): void;
9899     readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_BASE_VIEW_INDEX_OVR: GLenum;
9900     readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_NUM_VIEWS_OVR: GLenum;
9901     readonly FRAMEBUFFER_INCOMPLETE_VIEW_TARGETS_OVR: GLenum;
9902     readonly MAX_VIEWS_OVR: GLenum;
9903 }
9904
9905 /** The Web Audio API OfflineAudioCompletionEvent interface represents events that occur when the processing of an OfflineAudioContext is terminated. The complete event implements this interface. */
9906 interface OfflineAudioCompletionEvent extends Event {
9907     readonly renderedBuffer: AudioBuffer;
9908 }
9909
9910 declare var OfflineAudioCompletionEvent: {
9911     prototype: OfflineAudioCompletionEvent;
9912     new(type: string, eventInitDict: OfflineAudioCompletionEventInit): OfflineAudioCompletionEvent;
9913 };
9914
9915 interface OfflineAudioContextEventMap extends BaseAudioContextEventMap {
9916     "complete": OfflineAudioCompletionEvent;
9917 }
9918
9919 /** 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. */
9920 interface OfflineAudioContext extends BaseAudioContext {
9921     readonly length: number;
9922     oncomplete: ((this: OfflineAudioContext, ev: OfflineAudioCompletionEvent) => any) | null;
9923     resume(): Promise<void>;
9924     startRendering(): Promise<AudioBuffer>;
9925     suspend(suspendTime: number): Promise<void>;
9926     addEventListener<K extends keyof OfflineAudioContextEventMap>(type: K, listener: (this: OfflineAudioContext, ev: OfflineAudioContextEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9927     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9928     removeEventListener<K extends keyof OfflineAudioContextEventMap>(type: K, listener: (this: OfflineAudioContext, ev: OfflineAudioContextEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9929     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9930 }
9931
9932 declare var OfflineAudioContext: {
9933     prototype: OfflineAudioContext;
9934     new(contextOptions: OfflineAudioContextOptions): OfflineAudioContext;
9935     new(numberOfChannels: number, length: number, sampleRate: number): OfflineAudioContext;
9936 };
9937
9938 /** 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. */
9939 interface OscillatorNode extends AudioScheduledSourceNode {
9940     readonly detune: AudioParam;
9941     readonly frequency: AudioParam;
9942     type: OscillatorType;
9943     setPeriodicWave(periodicWave: PeriodicWave): void;
9944     addEventListener<K extends keyof AudioScheduledSourceNodeEventMap>(type: K, listener: (this: OscillatorNode, ev: AudioScheduledSourceNodeEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9945     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9946     removeEventListener<K extends keyof AudioScheduledSourceNodeEventMap>(type: K, listener: (this: OscillatorNode, ev: AudioScheduledSourceNodeEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9947     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9948 }
9949
9950 declare var OscillatorNode: {
9951     prototype: OscillatorNode;
9952     new(context: BaseAudioContext, options?: OscillatorOptions): OscillatorNode;
9953 };
9954
9955 interface OverconstrainedError extends Error {
9956     readonly constraint: string;
9957 }
9958
9959 declare var OverconstrainedError: {
9960     prototype: OverconstrainedError;
9961     new(constraint: string, message?: string): OverconstrainedError;
9962 };
9963
9964 /** The PageTransitionEvent is fired when a document is being loaded or unloaded. */
9965 interface PageTransitionEvent extends Event {
9966     /**
9967      * For the pageshow event, returns false if the page is newly being loaded (and the load event will fire). Otherwise, returns true.
9968      *
9969      * 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.
9970      *
9971      * Things that can cause the page to be unsalvageable include:
9972      *
9973      * The user agent decided to not keep the Document alive in a session history entry after unload
9974      * Having iframes that are not salvageable
9975      * Active WebSocket objects
9976      * Aborting a Document
9977      */
9978     readonly persisted: boolean;
9979 }
9980
9981 declare var PageTransitionEvent: {
9982     prototype: PageTransitionEvent;
9983     new(type: string, eventInitDict?: PageTransitionEventInit): PageTransitionEvent;
9984 };
9985
9986 /** 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! */
9987 interface PannerNode extends AudioNode {
9988     coneInnerAngle: number;
9989     coneOuterAngle: number;
9990     coneOuterGain: number;
9991     distanceModel: DistanceModelType;
9992     maxDistance: number;
9993     readonly orientationX: AudioParam;
9994     readonly orientationY: AudioParam;
9995     readonly orientationZ: AudioParam;
9996     panningModel: PanningModelType;
9997     readonly positionX: AudioParam;
9998     readonly positionY: AudioParam;
9999     readonly positionZ: AudioParam;
10000     refDistance: number;
10001     rolloffFactor: number;
10002     /** @deprecated */
10003     setOrientation(x: number, y: number, z: number): void;
10004     /** @deprecated */
10005     setPosition(x: number, y: number, z: number): void;
10006 }
10007
10008 declare var PannerNode: {
10009     prototype: PannerNode;
10010     new(context: BaseAudioContext, options?: PannerOptions): PannerNode;
10011 };
10012
10013 interface ParentNode extends Node {
10014     readonly childElementCount: number;
10015     /** Returns the child elements. */
10016     readonly children: HTMLCollection;
10017     /** Returns the first child that is an element, and null otherwise. */
10018     readonly firstElementChild: Element | null;
10019     /** Returns the last child that is an element, and null otherwise. */
10020     readonly lastElementChild: Element | null;
10021     /**
10022      * Inserts nodes after the last child of node, while replacing strings in nodes with equivalent Text nodes.
10023      *
10024      * Throws a "HierarchyRequestError" DOMException if the constraints of the node tree are violated.
10025      */
10026     append(...nodes: (Node | string)[]): void;
10027     /**
10028      * Inserts nodes before the first child of node, while replacing strings in nodes with equivalent Text nodes.
10029      *
10030      * Throws a "HierarchyRequestError" DOMException if the constraints of the node tree are violated.
10031      */
10032     prepend(...nodes: (Node | string)[]): void;
10033     /** Returns the first element that is a descendant of node that matches selectors. */
10034     querySelector<K extends keyof HTMLElementTagNameMap>(selectors: K): HTMLElementTagNameMap[K] | null;
10035     querySelector<K extends keyof SVGElementTagNameMap>(selectors: K): SVGElementTagNameMap[K] | null;
10036     querySelector<E extends Element = Element>(selectors: string): E | null;
10037     /** Returns all element descendants of node that match selectors. */
10038     querySelectorAll<K extends keyof HTMLElementTagNameMap>(selectors: K): NodeListOf<HTMLElementTagNameMap[K]>;
10039     querySelectorAll<K extends keyof SVGElementTagNameMap>(selectors: K): NodeListOf<SVGElementTagNameMap[K]>;
10040     querySelectorAll<E extends Element = Element>(selectors: string): NodeListOf<E>;
10041     /**
10042      * Replace all children of node with nodes, while replacing strings in nodes with equivalent Text nodes.
10043      *
10044      * Throws a "HierarchyRequestError" DOMException if the constraints of the node tree are violated.
10045      */
10046     replaceChildren(...nodes: (Node | string)[]): void;
10047 }
10048
10049 /** 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. */
10050 interface Path2D extends CanvasPath {
10051     /** Adds to the path the path given by the argument. */
10052     addPath(path: Path2D, transform?: DOMMatrix2DInit): void;
10053 }
10054
10055 declare var Path2D: {
10056     prototype: Path2D;
10057     new(path?: Path2D | string): Path2D;
10058 };
10059
10060 /** Available only in secure contexts. */
10061 interface PaymentMethodChangeEvent extends PaymentRequestUpdateEvent {
10062     readonly methodDetails: any;
10063     readonly methodName: string;
10064 }
10065
10066 declare var PaymentMethodChangeEvent: {
10067     prototype: PaymentMethodChangeEvent;
10068     new(type: string, eventInitDict?: PaymentMethodChangeEventInit): PaymentMethodChangeEvent;
10069 };
10070
10071 interface PaymentRequestEventMap {
10072     "paymentmethodchange": Event;
10073 }
10074
10075 /**
10076  * 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.
10077  * Available only in secure contexts.
10078  */
10079 interface PaymentRequest extends EventTarget {
10080     readonly id: string;
10081     onpaymentmethodchange: ((this: PaymentRequest, ev: Event) => any) | null;
10082     abort(): Promise<void>;
10083     canMakePayment(): Promise<boolean>;
10084     show(detailsPromise?: PaymentDetailsUpdate | PromiseLike<PaymentDetailsUpdate>): Promise<PaymentResponse>;
10085     addEventListener<K extends keyof PaymentRequestEventMap>(type: K, listener: (this: PaymentRequest, ev: PaymentRequestEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10086     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10087     removeEventListener<K extends keyof PaymentRequestEventMap>(type: K, listener: (this: PaymentRequest, ev: PaymentRequestEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10088     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10089 }
10090
10091 declare var PaymentRequest: {
10092     prototype: PaymentRequest;
10093     new(methodData: PaymentMethodData[], details: PaymentDetailsInit): PaymentRequest;
10094 };
10095
10096 /**
10097  * This Payment Request API interface enables a web page to update the details of a PaymentRequest in response to a user action.
10098  * Available only in secure contexts.
10099  */
10100 interface PaymentRequestUpdateEvent extends Event {
10101     updateWith(detailsPromise: PaymentDetailsUpdate | PromiseLike<PaymentDetailsUpdate>): void;
10102 }
10103
10104 declare var PaymentRequestUpdateEvent: {
10105     prototype: PaymentRequestUpdateEvent;
10106     new(type: string, eventInitDict?: PaymentRequestUpdateEventInit): PaymentRequestUpdateEvent;
10107 };
10108
10109 /**
10110  * This Payment Request API interface is returned after a user selects a payment method and approves a payment request.
10111  * Available only in secure contexts.
10112  */
10113 interface PaymentResponse extends EventTarget {
10114     readonly details: any;
10115     readonly methodName: string;
10116     readonly requestId: string;
10117     complete(result?: PaymentComplete): Promise<void>;
10118     retry(errorFields?: PaymentValidationErrors): Promise<void>;
10119     toJSON(): any;
10120 }
10121
10122 declare var PaymentResponse: {
10123     prototype: PaymentResponse;
10124     new(): PaymentResponse;
10125 };
10126
10127 interface PerformanceEventMap {
10128     "resourcetimingbufferfull": Event;
10129 }
10130
10131 /** 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. */
10132 interface Performance extends EventTarget {
10133     /** @deprecated */
10134     readonly navigation: PerformanceNavigation;
10135     onresourcetimingbufferfull: ((this: Performance, ev: Event) => any) | null;
10136     readonly timeOrigin: DOMHighResTimeStamp;
10137     /** @deprecated */
10138     readonly timing: PerformanceTiming;
10139     clearMarks(markName?: string): void;
10140     clearMeasures(measureName?: string): void;
10141     clearResourceTimings(): void;
10142     getEntries(): PerformanceEntryList;
10143     getEntriesByName(name: string, type?: string): PerformanceEntryList;
10144     getEntriesByType(type: string): PerformanceEntryList;
10145     mark(markName: string, markOptions?: PerformanceMarkOptions): PerformanceMark;
10146     measure(measureName: string, startOrMeasureOptions?: string | PerformanceMeasureOptions, endMark?: string): PerformanceMeasure;
10147     now(): DOMHighResTimeStamp;
10148     setResourceTimingBufferSize(maxSize: number): void;
10149     toJSON(): any;
10150     addEventListener<K extends keyof PerformanceEventMap>(type: K, listener: (this: Performance, ev: PerformanceEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10151     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10152     removeEventListener<K extends keyof PerformanceEventMap>(type: K, listener: (this: Performance, ev: PerformanceEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10153     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10154 }
10155
10156 declare var Performance: {
10157     prototype: Performance;
10158     new(): Performance;
10159 };
10160
10161 /** 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). */
10162 interface PerformanceEntry {
10163     readonly duration: DOMHighResTimeStamp;
10164     readonly entryType: string;
10165     readonly name: string;
10166     readonly startTime: DOMHighResTimeStamp;
10167     toJSON(): any;
10168 }
10169
10170 declare var PerformanceEntry: {
10171     prototype: PerformanceEntry;
10172     new(): PerformanceEntry;
10173 };
10174
10175 interface PerformanceEventTiming extends PerformanceEntry {
10176     readonly cancelable: boolean;
10177     readonly processingEnd: DOMHighResTimeStamp;
10178     readonly processingStart: DOMHighResTimeStamp;
10179     readonly target: Node | null;
10180 }
10181
10182 declare var PerformanceEventTiming: {
10183     prototype: PerformanceEventTiming;
10184     new(): PerformanceEventTiming;
10185 };
10186
10187 /** 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. */
10188 interface PerformanceMark extends PerformanceEntry {
10189     readonly detail: any;
10190 }
10191
10192 declare var PerformanceMark: {
10193     prototype: PerformanceMark;
10194     new(markName: string, markOptions?: PerformanceMarkOptions): PerformanceMark;
10195 };
10196
10197 /** 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. */
10198 interface PerformanceMeasure extends PerformanceEntry {
10199     readonly detail: any;
10200 }
10201
10202 declare var PerformanceMeasure: {
10203     prototype: PerformanceMeasure;
10204     new(): PerformanceMeasure;
10205 };
10206
10207 /**
10208  * The legacy PerformanceNavigation interface represents information about how the navigation to the current document was done.
10209  * @deprecated This interface is deprecated in the Navigation Timing Level 2 specification. Please use the PerformanceNavigationTiming interface instead.
10210  */
10211 interface PerformanceNavigation {
10212     /** @deprecated */
10213     readonly redirectCount: number;
10214     /** @deprecated */
10215     readonly type: number;
10216     /** @deprecated */
10217     toJSON(): any;
10218     readonly TYPE_BACK_FORWARD: number;
10219     readonly TYPE_NAVIGATE: number;
10220     readonly TYPE_RELOAD: number;
10221     readonly TYPE_RESERVED: number;
10222 }
10223
10224 /** @deprecated */
10225 declare var PerformanceNavigation: {
10226     prototype: PerformanceNavigation;
10227     new(): PerformanceNavigation;
10228     readonly TYPE_BACK_FORWARD: number;
10229     readonly TYPE_NAVIGATE: number;
10230     readonly TYPE_RELOAD: number;
10231     readonly TYPE_RESERVED: number;
10232 };
10233
10234 /** 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. */
10235 interface PerformanceNavigationTiming extends PerformanceResourceTiming {
10236     readonly domComplete: DOMHighResTimeStamp;
10237     readonly domContentLoadedEventEnd: DOMHighResTimeStamp;
10238     readonly domContentLoadedEventStart: DOMHighResTimeStamp;
10239     readonly domInteractive: DOMHighResTimeStamp;
10240     readonly loadEventEnd: DOMHighResTimeStamp;
10241     readonly loadEventStart: DOMHighResTimeStamp;
10242     readonly redirectCount: number;
10243     readonly type: NavigationType;
10244     readonly unloadEventEnd: DOMHighResTimeStamp;
10245     readonly unloadEventStart: DOMHighResTimeStamp;
10246     toJSON(): any;
10247 }
10248
10249 declare var PerformanceNavigationTiming: {
10250     prototype: PerformanceNavigationTiming;
10251     new(): PerformanceNavigationTiming;
10252 };
10253
10254 interface PerformanceObserver {
10255     disconnect(): void;
10256     observe(options?: PerformanceObserverInit): void;
10257     takeRecords(): PerformanceEntryList;
10258 }
10259
10260 declare var PerformanceObserver: {
10261     prototype: PerformanceObserver;
10262     new(callback: PerformanceObserverCallback): PerformanceObserver;
10263     readonly supportedEntryTypes: ReadonlyArray<string>;
10264 };
10265
10266 interface PerformanceObserverEntryList {
10267     getEntries(): PerformanceEntryList;
10268     getEntriesByName(name: string, type?: string): PerformanceEntryList;
10269     getEntriesByType(type: string): PerformanceEntryList;
10270 }
10271
10272 declare var PerformanceObserverEntryList: {
10273     prototype: PerformanceObserverEntryList;
10274     new(): PerformanceObserverEntryList;
10275 };
10276
10277 interface PerformancePaintTiming extends PerformanceEntry {
10278 }
10279
10280 declare var PerformancePaintTiming: {
10281     prototype: PerformancePaintTiming;
10282     new(): PerformancePaintTiming;
10283 };
10284
10285 /** 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. */
10286 interface PerformanceResourceTiming extends PerformanceEntry {
10287     readonly connectEnd: DOMHighResTimeStamp;
10288     readonly connectStart: DOMHighResTimeStamp;
10289     readonly decodedBodySize: number;
10290     readonly domainLookupEnd: DOMHighResTimeStamp;
10291     readonly domainLookupStart: DOMHighResTimeStamp;
10292     readonly encodedBodySize: number;
10293     readonly fetchStart: DOMHighResTimeStamp;
10294     readonly initiatorType: string;
10295     readonly nextHopProtocol: string;
10296     readonly redirectEnd: DOMHighResTimeStamp;
10297     readonly redirectStart: DOMHighResTimeStamp;
10298     readonly requestStart: DOMHighResTimeStamp;
10299     readonly responseEnd: DOMHighResTimeStamp;
10300     readonly responseStart: DOMHighResTimeStamp;
10301     readonly secureConnectionStart: DOMHighResTimeStamp;
10302     readonly serverTiming: ReadonlyArray<PerformanceServerTiming>;
10303     readonly transferSize: number;
10304     readonly workerStart: DOMHighResTimeStamp;
10305     toJSON(): any;
10306 }
10307
10308 declare var PerformanceResourceTiming: {
10309     prototype: PerformanceResourceTiming;
10310     new(): PerformanceResourceTiming;
10311 };
10312
10313 interface PerformanceServerTiming {
10314     readonly description: string;
10315     readonly duration: DOMHighResTimeStamp;
10316     readonly name: string;
10317     toJSON(): any;
10318 }
10319
10320 declare var PerformanceServerTiming: {
10321     prototype: PerformanceServerTiming;
10322     new(): PerformanceServerTiming;
10323 };
10324
10325 /**
10326  * 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.
10327  * @deprecated This interface is deprecated in the Navigation Timing Level 2 specification. Please use the PerformanceNavigationTiming interface instead.
10328  */
10329 interface PerformanceTiming {
10330     /** @deprecated */
10331     readonly connectEnd: number;
10332     /** @deprecated */
10333     readonly connectStart: number;
10334     /** @deprecated */
10335     readonly domComplete: number;
10336     /** @deprecated */
10337     readonly domContentLoadedEventEnd: number;
10338     /** @deprecated */
10339     readonly domContentLoadedEventStart: number;
10340     /** @deprecated */
10341     readonly domInteractive: number;
10342     /** @deprecated */
10343     readonly domLoading: number;
10344     /** @deprecated */
10345     readonly domainLookupEnd: number;
10346     /** @deprecated */
10347     readonly domainLookupStart: number;
10348     /** @deprecated */
10349     readonly fetchStart: number;
10350     /** @deprecated */
10351     readonly loadEventEnd: number;
10352     /** @deprecated */
10353     readonly loadEventStart: number;
10354     /** @deprecated */
10355     readonly navigationStart: number;
10356     /** @deprecated */
10357     readonly redirectEnd: number;
10358     /** @deprecated */
10359     readonly redirectStart: number;
10360     /** @deprecated */
10361     readonly requestStart: number;
10362     /** @deprecated */
10363     readonly responseEnd: number;
10364     /** @deprecated */
10365     readonly responseStart: number;
10366     /** @deprecated */
10367     readonly secureConnectionStart: number;
10368     /** @deprecated */
10369     readonly unloadEventEnd: number;
10370     /** @deprecated */
10371     readonly unloadEventStart: number;
10372     /** @deprecated */
10373     toJSON(): any;
10374 }
10375
10376 /** @deprecated */
10377 declare var PerformanceTiming: {
10378     prototype: PerformanceTiming;
10379     new(): PerformanceTiming;
10380 };
10381
10382 /** 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(). */
10383 interface PeriodicWave {
10384 }
10385
10386 declare var PeriodicWave: {
10387     prototype: PeriodicWave;
10388     new(context: BaseAudioContext, options?: PeriodicWaveOptions): PeriodicWave;
10389 };
10390
10391 interface PermissionStatusEventMap {
10392     "change": Event;
10393 }
10394
10395 interface PermissionStatus extends EventTarget {
10396     onchange: ((this: PermissionStatus, ev: Event) => any) | null;
10397     readonly state: PermissionState;
10398     addEventListener<K extends keyof PermissionStatusEventMap>(type: K, listener: (this: PermissionStatus, ev: PermissionStatusEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10399     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10400     removeEventListener<K extends keyof PermissionStatusEventMap>(type: K, listener: (this: PermissionStatus, ev: PermissionStatusEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10401     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10402 }
10403
10404 declare var PermissionStatus: {
10405     prototype: PermissionStatus;
10406     new(): PermissionStatus;
10407 };
10408
10409 interface Permissions {
10410     query(permissionDesc: PermissionDescriptor): Promise<PermissionStatus>;
10411 }
10412
10413 declare var Permissions: {
10414     prototype: Permissions;
10415     new(): Permissions;
10416 };
10417
10418 interface PictureInPictureWindowEventMap {
10419     "resize": Event;
10420 }
10421
10422 interface PictureInPictureWindow extends EventTarget {
10423     readonly height: number;
10424     onresize: ((this: PictureInPictureWindow, ev: Event) => any) | null;
10425     readonly width: number;
10426     addEventListener<K extends keyof PictureInPictureWindowEventMap>(type: K, listener: (this: PictureInPictureWindow, ev: PictureInPictureWindowEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10427     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10428     removeEventListener<K extends keyof PictureInPictureWindowEventMap>(type: K, listener: (this: PictureInPictureWindow, ev: PictureInPictureWindowEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10429     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10430 }
10431
10432 declare var PictureInPictureWindow: {
10433     prototype: PictureInPictureWindow;
10434     new(): PictureInPictureWindow;
10435 };
10436
10437 /**
10438  * Provides information about a browser plugin.
10439  * @deprecated
10440  */
10441 interface Plugin {
10442     /**
10443      * Returns the plugin's description.
10444      * @deprecated
10445      */
10446     readonly description: string;
10447     /**
10448      * Returns the plugin library's filename, if applicable on the current platform.
10449      * @deprecated
10450      */
10451     readonly filename: string;
10452     /**
10453      * Returns the number of MIME types, represented by MimeType objects, supported by the plugin.
10454      * @deprecated
10455      */
10456     readonly length: number;
10457     /**
10458      * Returns the plugin's name.
10459      * @deprecated
10460      */
10461     readonly name: string;
10462     /**
10463      * Returns the specified MimeType object.
10464      * @deprecated
10465      */
10466     item(index: number): MimeType | null;
10467     /** @deprecated */
10468     namedItem(name: string): MimeType | null;
10469     [index: number]: MimeType;
10470 }
10471
10472 /** @deprecated */
10473 declare var Plugin: {
10474     prototype: Plugin;
10475     new(): Plugin;
10476 };
10477
10478 /**
10479  * 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.
10480  * @deprecated
10481  */
10482 interface PluginArray {
10483     /** @deprecated */
10484     readonly length: number;
10485     /** @deprecated */
10486     item(index: number): Plugin | null;
10487     /** @deprecated */
10488     namedItem(name: string): Plugin | null;
10489     /** @deprecated */
10490     refresh(): void;
10491     [index: number]: Plugin;
10492 }
10493
10494 /** @deprecated */
10495 declare var PluginArray: {
10496     prototype: PluginArray;
10497     new(): PluginArray;
10498 };
10499
10500 /** 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. */
10501 interface PointerEvent extends MouseEvent {
10502     readonly height: number;
10503     readonly isPrimary: boolean;
10504     readonly pointerId: number;
10505     readonly pointerType: string;
10506     readonly pressure: number;
10507     readonly tangentialPressure: number;
10508     readonly tiltX: number;
10509     readonly tiltY: number;
10510     readonly twist: number;
10511     readonly width: number;
10512     /** Available only in secure contexts. */
10513     getCoalescedEvents(): PointerEvent[];
10514     getPredictedEvents(): PointerEvent[];
10515 }
10516
10517 declare var PointerEvent: {
10518     prototype: PointerEvent;
10519     new(type: string, eventInitDict?: PointerEventInit): PointerEvent;
10520 };
10521
10522 /** PopStateEvent is an event handler for the popstate event on the window. */
10523 interface PopStateEvent extends Event {
10524     /** Returns a copy of the information that was provided to pushState() or replaceState(). */
10525     readonly state: any;
10526 }
10527
10528 declare var PopStateEvent: {
10529     prototype: PopStateEvent;
10530     new(type: string, eventInitDict?: PopStateEventInit): PopStateEvent;
10531 };
10532
10533 /** A processing instruction embeds application-specific instructions in XML which can be ignored by other applications that don't recognize them. */
10534 interface ProcessingInstruction extends CharacterData, LinkStyle {
10535     readonly ownerDocument: Document;
10536     readonly target: string;
10537 }
10538
10539 declare var ProcessingInstruction: {
10540     prototype: ProcessingInstruction;
10541     new(): ProcessingInstruction;
10542 };
10543
10544 /** 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>). */
10545 interface ProgressEvent<T extends EventTarget = EventTarget> extends Event {
10546     readonly lengthComputable: boolean;
10547     readonly loaded: number;
10548     readonly target: T | null;
10549     readonly total: number;
10550 }
10551
10552 declare var ProgressEvent: {
10553     prototype: ProgressEvent;
10554     new(type: string, eventInitDict?: ProgressEventInit): ProgressEvent;
10555 };
10556
10557 interface PromiseRejectionEvent extends Event {
10558     readonly promise: Promise<any>;
10559     readonly reason: any;
10560 }
10561
10562 declare var PromiseRejectionEvent: {
10563     prototype: PromiseRejectionEvent;
10564     new(type: string, eventInitDict: PromiseRejectionEventInit): PromiseRejectionEvent;
10565 };
10566
10567 /** Available only in secure contexts. */
10568 interface PublicKeyCredential extends Credential {
10569     readonly rawId: ArrayBuffer;
10570     readonly response: AuthenticatorResponse;
10571     getClientExtensionResults(): AuthenticationExtensionsClientOutputs;
10572 }
10573
10574 declare var PublicKeyCredential: {
10575     prototype: PublicKeyCredential;
10576     new(): PublicKeyCredential;
10577     isUserVerifyingPlatformAuthenticatorAvailable(): Promise<boolean>;
10578 };
10579
10580 /**
10581  * This Push API interface provides a way to receive notifications from third-party servers as well as request URLs for push notifications.
10582  * Available only in secure contexts.
10583  */
10584 interface PushManager {
10585     getSubscription(): Promise<PushSubscription | null>;
10586     permissionState(options?: PushSubscriptionOptionsInit): Promise<PushPermissionState>;
10587     subscribe(options?: PushSubscriptionOptionsInit): Promise<PushSubscription>;
10588 }
10589
10590 declare var PushManager: {
10591     prototype: PushManager;
10592     new(): PushManager;
10593     readonly supportedContentEncodings: ReadonlyArray<string>;
10594 };
10595
10596 /**
10597  * This Push API interface provides a subcription's URL endpoint and allows unsubscription from a push service.
10598  * Available only in secure contexts.
10599  */
10600 interface PushSubscription {
10601     readonly endpoint: string;
10602     readonly options: PushSubscriptionOptions;
10603     getKey(name: PushEncryptionKeyName): ArrayBuffer | null;
10604     toJSON(): PushSubscriptionJSON;
10605     unsubscribe(): Promise<boolean>;
10606 }
10607
10608 declare var PushSubscription: {
10609     prototype: PushSubscription;
10610     new(): PushSubscription;
10611 };
10612
10613 /** Available only in secure contexts. */
10614 interface PushSubscriptionOptions {
10615     readonly applicationServerKey: ArrayBuffer | null;
10616 }
10617
10618 declare var PushSubscriptionOptions: {
10619     prototype: PushSubscriptionOptions;
10620     new(): PushSubscriptionOptions;
10621 };
10622
10623 interface RTCCertificate {
10624     readonly expires: DOMTimeStamp;
10625     getFingerprints(): RTCDtlsFingerprint[];
10626 }
10627
10628 declare var RTCCertificate: {
10629     prototype: RTCCertificate;
10630     new(): RTCCertificate;
10631 };
10632
10633 interface RTCDTMFSenderEventMap {
10634     "tonechange": RTCDTMFToneChangeEvent;
10635 }
10636
10637 interface RTCDTMFSender extends EventTarget {
10638     readonly canInsertDTMF: boolean;
10639     ontonechange: ((this: RTCDTMFSender, ev: RTCDTMFToneChangeEvent) => any) | null;
10640     readonly toneBuffer: string;
10641     insertDTMF(tones: string, duration?: number, interToneGap?: number): void;
10642     addEventListener<K extends keyof RTCDTMFSenderEventMap>(type: K, listener: (this: RTCDTMFSender, ev: RTCDTMFSenderEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10643     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10644     removeEventListener<K extends keyof RTCDTMFSenderEventMap>(type: K, listener: (this: RTCDTMFSender, ev: RTCDTMFSenderEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10645     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10646 }
10647
10648 declare var RTCDTMFSender: {
10649     prototype: RTCDTMFSender;
10650     new(): RTCDTMFSender;
10651 };
10652
10653 /** Events sent to indicate that DTMF tones have started or finished playing. This interface is used by the tonechange event. */
10654 interface RTCDTMFToneChangeEvent extends Event {
10655     readonly tone: string;
10656 }
10657
10658 declare var RTCDTMFToneChangeEvent: {
10659     prototype: RTCDTMFToneChangeEvent;
10660     new(type: string, eventInitDict?: RTCDTMFToneChangeEventInit): RTCDTMFToneChangeEvent;
10661 };
10662
10663 interface RTCDataChannelEventMap {
10664     "bufferedamountlow": Event;
10665     "close": Event;
10666     "error": Event;
10667     "message": MessageEvent;
10668     "open": Event;
10669 }
10670
10671 interface RTCDataChannel extends EventTarget {
10672     binaryType: BinaryType;
10673     readonly bufferedAmount: number;
10674     bufferedAmountLowThreshold: number;
10675     readonly id: number | null;
10676     readonly label: string;
10677     readonly maxPacketLifeTime: number | null;
10678     readonly maxRetransmits: number | null;
10679     readonly negotiated: boolean;
10680     onbufferedamountlow: ((this: RTCDataChannel, ev: Event) => any) | null;
10681     onclose: ((this: RTCDataChannel, ev: Event) => any) | null;
10682     onerror: ((this: RTCDataChannel, ev: Event) => any) | null;
10683     onmessage: ((this: RTCDataChannel, ev: MessageEvent) => any) | null;
10684     onopen: ((this: RTCDataChannel, ev: Event) => any) | null;
10685     readonly ordered: boolean;
10686     readonly protocol: string;
10687     readonly readyState: RTCDataChannelState;
10688     close(): void;
10689     send(data: string): void;
10690     send(data: Blob): void;
10691     send(data: ArrayBuffer): void;
10692     send(data: ArrayBufferView): void;
10693     addEventListener<K extends keyof RTCDataChannelEventMap>(type: K, listener: (this: RTCDataChannel, ev: RTCDataChannelEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10694     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10695     removeEventListener<K extends keyof RTCDataChannelEventMap>(type: K, listener: (this: RTCDataChannel, ev: RTCDataChannelEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10696     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10697 }
10698
10699 declare var RTCDataChannel: {
10700     prototype: RTCDataChannel;
10701     new(): RTCDataChannel;
10702 };
10703
10704 interface RTCDataChannelEvent extends Event {
10705     readonly channel: RTCDataChannel;
10706 }
10707
10708 declare var RTCDataChannelEvent: {
10709     prototype: RTCDataChannelEvent;
10710     new(type: string, eventInitDict: RTCDataChannelEventInit): RTCDataChannelEvent;
10711 };
10712
10713 interface RTCDtlsTransportEventMap {
10714     "statechange": Event;
10715 }
10716
10717 interface RTCDtlsTransport extends EventTarget {
10718     onstatechange: ((this: RTCDtlsTransport, ev: Event) => any) | null;
10719     readonly state: RTCDtlsTransportState;
10720     addEventListener<K extends keyof RTCDtlsTransportEventMap>(type: K, listener: (this: RTCDtlsTransport, ev: RTCDtlsTransportEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10721     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10722     removeEventListener<K extends keyof RTCDtlsTransportEventMap>(type: K, listener: (this: RTCDtlsTransport, ev: RTCDtlsTransportEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10723     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10724 }
10725
10726 declare var RTCDtlsTransport: {
10727     prototype: RTCDtlsTransport;
10728     new(): RTCDtlsTransport;
10729 };
10730
10731 /** The RTCIceCandidate interface—part of the WebRTC API—represents a candidate Internet Connectivity Establishment (ICE) configuration which may be used to establish an RTCPeerConnection. */
10732 interface RTCIceCandidate {
10733     readonly address: string | null;
10734     readonly candidate: string;
10735     readonly component: RTCIceComponent | null;
10736     readonly foundation: string | null;
10737     readonly port: number | null;
10738     readonly priority: number | null;
10739     readonly protocol: RTCIceProtocol | null;
10740     readonly relatedAddress: string | null;
10741     readonly relatedPort: number | null;
10742     readonly sdpMLineIndex: number | null;
10743     readonly sdpMid: string | null;
10744     readonly tcpType: RTCIceTcpCandidateType | null;
10745     readonly type: RTCIceCandidateType | null;
10746     readonly usernameFragment: string | null;
10747     toJSON(): RTCIceCandidateInit;
10748 }
10749
10750 declare var RTCIceCandidate: {
10751     prototype: RTCIceCandidate;
10752     new(candidateInitDict?: RTCIceCandidateInit): RTCIceCandidate;
10753 };
10754
10755 /** Provides access to information about the ICE transport layer over which the data is being sent and received. */
10756 interface RTCIceTransport extends EventTarget {
10757     readonly gatheringState: RTCIceGathererState;
10758     readonly state: RTCIceTransportState;
10759 }
10760
10761 declare var RTCIceTransport: {
10762     prototype: RTCIceTransport;
10763     new(): RTCIceTransport;
10764 };
10765
10766 interface RTCPeerConnectionEventMap {
10767     "connectionstatechange": Event;
10768     "datachannel": RTCDataChannelEvent;
10769     "icecandidate": RTCPeerConnectionIceEvent;
10770     "icecandidateerror": Event;
10771     "iceconnectionstatechange": Event;
10772     "icegatheringstatechange": Event;
10773     "negotiationneeded": Event;
10774     "signalingstatechange": Event;
10775     "track": RTCTrackEvent;
10776 }
10777
10778 /** 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. */
10779 interface RTCPeerConnection extends EventTarget {
10780     readonly canTrickleIceCandidates: boolean | null;
10781     readonly connectionState: RTCPeerConnectionState;
10782     readonly currentLocalDescription: RTCSessionDescription | null;
10783     readonly currentRemoteDescription: RTCSessionDescription | null;
10784     readonly iceConnectionState: RTCIceConnectionState;
10785     readonly iceGatheringState: RTCIceGatheringState;
10786     readonly localDescription: RTCSessionDescription | null;
10787     onconnectionstatechange: ((this: RTCPeerConnection, ev: Event) => any) | null;
10788     ondatachannel: ((this: RTCPeerConnection, ev: RTCDataChannelEvent) => any) | null;
10789     onicecandidate: ((this: RTCPeerConnection, ev: RTCPeerConnectionIceEvent) => any) | null;
10790     onicecandidateerror: ((this: RTCPeerConnection, ev: Event) => any) | null;
10791     oniceconnectionstatechange: ((this: RTCPeerConnection, ev: Event) => any) | null;
10792     onicegatheringstatechange: ((this: RTCPeerConnection, ev: Event) => any) | null;
10793     onnegotiationneeded: ((this: RTCPeerConnection, ev: Event) => any) | null;
10794     onsignalingstatechange: ((this: RTCPeerConnection, ev: Event) => any) | null;
10795     ontrack: ((this: RTCPeerConnection, ev: RTCTrackEvent) => any) | null;
10796     readonly pendingLocalDescription: RTCSessionDescription | null;
10797     readonly pendingRemoteDescription: RTCSessionDescription | null;
10798     readonly remoteDescription: RTCSessionDescription | null;
10799     readonly signalingState: RTCSignalingState;
10800     addIceCandidate(candidate?: RTCIceCandidateInit): Promise<void>;
10801     /** @deprecated */
10802     addIceCandidate(candidate: RTCIceCandidateInit, successCallback: VoidFunction, failureCallback: RTCPeerConnectionErrorCallback): Promise<void>;
10803     addTrack(track: MediaStreamTrack, ...streams: MediaStream[]): RTCRtpSender;
10804     addTransceiver(trackOrKind: MediaStreamTrack | string, init?: RTCRtpTransceiverInit): RTCRtpTransceiver;
10805     close(): void;
10806     createAnswer(options?: RTCAnswerOptions): Promise<RTCSessionDescriptionInit>;
10807     /** @deprecated */
10808     createAnswer(successCallback: RTCSessionDescriptionCallback, failureCallback: RTCPeerConnectionErrorCallback): Promise<void>;
10809     createDataChannel(label: string, dataChannelDict?: RTCDataChannelInit): RTCDataChannel;
10810     createOffer(options?: RTCOfferOptions): Promise<RTCSessionDescriptionInit>;
10811     /** @deprecated */
10812     createOffer(successCallback: RTCSessionDescriptionCallback, failureCallback: RTCPeerConnectionErrorCallback, options?: RTCOfferOptions): Promise<void>;
10813     getConfiguration(): RTCConfiguration;
10814     getReceivers(): RTCRtpReceiver[];
10815     getSenders(): RTCRtpSender[];
10816     getStats(selector?: MediaStreamTrack | null): Promise<RTCStatsReport>;
10817     getTransceivers(): RTCRtpTransceiver[];
10818     removeTrack(sender: RTCRtpSender): void;
10819     restartIce(): void;
10820     setConfiguration(configuration?: RTCConfiguration): void;
10821     setLocalDescription(description?: RTCLocalSessionDescriptionInit): Promise<void>;
10822     /** @deprecated */
10823     setLocalDescription(description: RTCLocalSessionDescriptionInit, successCallback: VoidFunction, failureCallback: RTCPeerConnectionErrorCallback): Promise<void>;
10824     setRemoteDescription(description: RTCSessionDescriptionInit): Promise<void>;
10825     /** @deprecated */
10826     setRemoteDescription(description: RTCSessionDescriptionInit, successCallback: VoidFunction, failureCallback: RTCPeerConnectionErrorCallback): Promise<void>;
10827     addEventListener<K extends keyof RTCPeerConnectionEventMap>(type: K, listener: (this: RTCPeerConnection, ev: RTCPeerConnectionEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10828     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10829     removeEventListener<K extends keyof RTCPeerConnectionEventMap>(type: K, listener: (this: RTCPeerConnection, ev: RTCPeerConnectionEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10830     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10831 }
10832
10833 declare var RTCPeerConnection: {
10834     prototype: RTCPeerConnection;
10835     new(configuration?: RTCConfiguration): RTCPeerConnection;
10836     generateCertificate(keygenAlgorithm: AlgorithmIdentifier): Promise<RTCCertificate>;
10837 };
10838
10839 interface RTCPeerConnectionIceErrorEvent extends Event {
10840     readonly address: string | null;
10841     readonly errorCode: number;
10842     readonly errorText: string;
10843     readonly port: number | null;
10844     readonly url: string;
10845 }
10846
10847 declare var RTCPeerConnectionIceErrorEvent: {
10848     prototype: RTCPeerConnectionIceErrorEvent;
10849     new(type: string, eventInitDict: RTCPeerConnectionIceErrorEventInit): RTCPeerConnectionIceErrorEvent;
10850 };
10851
10852 /** Events that occurs in relation to ICE candidates with the target, usually an RTCPeerConnection. Only one event is of this type: icecandidate. */
10853 interface RTCPeerConnectionIceEvent extends Event {
10854     readonly candidate: RTCIceCandidate | null;
10855 }
10856
10857 declare var RTCPeerConnectionIceEvent: {
10858     prototype: RTCPeerConnectionIceEvent;
10859     new(type: string, eventInitDict?: RTCPeerConnectionIceEventInit): RTCPeerConnectionIceEvent;
10860 };
10861
10862 /** This WebRTC API interface manages the reception and decoding of data for a MediaStreamTrack on an RTCPeerConnection. */
10863 interface RTCRtpReceiver {
10864     readonly track: MediaStreamTrack;
10865     readonly transport: RTCDtlsTransport | null;
10866     getContributingSources(): RTCRtpContributingSource[];
10867     getParameters(): RTCRtpReceiveParameters;
10868     getStats(): Promise<RTCStatsReport>;
10869     getSynchronizationSources(): RTCRtpSynchronizationSource[];
10870 }
10871
10872 declare var RTCRtpReceiver: {
10873     prototype: RTCRtpReceiver;
10874     new(): RTCRtpReceiver;
10875     getCapabilities(kind: string): RTCRtpCapabilities | null;
10876 };
10877
10878 /** Provides the ability to control and obtain details about how a particular MediaStreamTrack is encoded and sent to a remote peer. */
10879 interface RTCRtpSender {
10880     readonly dtmf: RTCDTMFSender | null;
10881     readonly track: MediaStreamTrack | null;
10882     readonly transport: RTCDtlsTransport | null;
10883     getParameters(): RTCRtpSendParameters;
10884     getStats(): Promise<RTCStatsReport>;
10885     replaceTrack(withTrack: MediaStreamTrack | null): Promise<void>;
10886     setParameters(parameters: RTCRtpSendParameters): Promise<void>;
10887     setStreams(...streams: MediaStream[]): void;
10888 }
10889
10890 declare var RTCRtpSender: {
10891     prototype: RTCRtpSender;
10892     new(): RTCRtpSender;
10893     getCapabilities(kind: string): RTCRtpCapabilities | null;
10894 };
10895
10896 interface RTCRtpTransceiver {
10897     readonly currentDirection: RTCRtpTransceiverDirection | null;
10898     direction: RTCRtpTransceiverDirection;
10899     readonly mid: string | null;
10900     readonly receiver: RTCRtpReceiver;
10901     readonly sender: RTCRtpSender;
10902     stop(): void;
10903 }
10904
10905 declare var RTCRtpTransceiver: {
10906     prototype: RTCRtpTransceiver;
10907     new(): RTCRtpTransceiver;
10908 };
10909
10910 /** 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. */
10911 interface RTCSessionDescription {
10912     readonly sdp: string;
10913     readonly type: RTCSdpType;
10914     toJSON(): any;
10915 }
10916
10917 declare var RTCSessionDescription: {
10918     prototype: RTCSessionDescription;
10919     new(descriptionInitDict: RTCSessionDescriptionInit): RTCSessionDescription;
10920 };
10921
10922 interface RTCStatsReport {
10923     forEach(callbackfn: (value: any, key: string, parent: RTCStatsReport) => void, thisArg?: any): void;
10924 }
10925
10926 declare var RTCStatsReport: {
10927     prototype: RTCStatsReport;
10928     new(): RTCStatsReport;
10929 };
10930
10931 interface RTCTrackEvent extends Event {
10932     readonly receiver: RTCRtpReceiver;
10933     readonly streams: ReadonlyArray<MediaStream>;
10934     readonly track: MediaStreamTrack;
10935     readonly transceiver: RTCRtpTransceiver;
10936 }
10937
10938 declare var RTCTrackEvent: {
10939     prototype: RTCTrackEvent;
10940     new(type: string, eventInitDict: RTCTrackEventInit): RTCTrackEvent;
10941 };
10942
10943 interface RadioNodeList extends NodeList {
10944     value: string;
10945 }
10946
10947 declare var RadioNodeList: {
10948     prototype: RadioNodeList;
10949     new(): RadioNodeList;
10950 };
10951
10952 /** A fragment of a document that can contain nodes and parts of text nodes. */
10953 interface Range extends AbstractRange {
10954     /** Returns the node, furthest away from the document, that is an ancestor of both range's start node and end node. */
10955     readonly commonAncestorContainer: Node;
10956     cloneContents(): DocumentFragment;
10957     cloneRange(): Range;
10958     collapse(toStart?: boolean): void;
10959     compareBoundaryPoints(how: number, sourceRange: Range): number;
10960     /** 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. */
10961     comparePoint(node: Node, offset: number): number;
10962     createContextualFragment(fragment: string): DocumentFragment;
10963     deleteContents(): void;
10964     detach(): void;
10965     extractContents(): DocumentFragment;
10966     getBoundingClientRect(): DOMRect;
10967     getClientRects(): DOMRectList;
10968     insertNode(node: Node): void;
10969     /** Returns whether range intersects node. */
10970     intersectsNode(node: Node): boolean;
10971     isPointInRange(node: Node, offset: number): boolean;
10972     selectNode(node: Node): void;
10973     selectNodeContents(node: Node): void;
10974     setEnd(node: Node, offset: number): void;
10975     setEndAfter(node: Node): void;
10976     setEndBefore(node: Node): void;
10977     setStart(node: Node, offset: number): void;
10978     setStartAfter(node: Node): void;
10979     setStartBefore(node: Node): void;
10980     surroundContents(newParent: Node): void;
10981     toString(): string;
10982     readonly END_TO_END: number;
10983     readonly END_TO_START: number;
10984     readonly START_TO_END: number;
10985     readonly START_TO_START: number;
10986 }
10987
10988 declare var Range: {
10989     prototype: Range;
10990     new(): Range;
10991     readonly END_TO_END: number;
10992     readonly END_TO_START: number;
10993     readonly START_TO_END: number;
10994     readonly START_TO_START: number;
10995     toString(): string;
10996 };
10997
10998 /** 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. */
10999 interface ReadableStream<R = any> {
11000     readonly locked: boolean;
11001     cancel(reason?: any): Promise<void>;
11002     getReader(): ReadableStreamDefaultReader<R>;
11003     pipeThrough<T>(transform: ReadableWritablePair<T, R>, options?: StreamPipeOptions): ReadableStream<T>;
11004     pipeTo(destination: WritableStream<R>, options?: StreamPipeOptions): Promise<void>;
11005     tee(): [ReadableStream<R>, ReadableStream<R>];
11006 }
11007
11008 declare var ReadableStream: {
11009     prototype: ReadableStream;
11010     new<R = any>(underlyingSource?: UnderlyingSource<R>, strategy?: QueuingStrategy<R>): ReadableStream<R>;
11011 };
11012
11013 interface ReadableStreamDefaultController<R = any> {
11014     readonly desiredSize: number | null;
11015     close(): void;
11016     enqueue(chunk?: R): void;
11017     error(e?: any): void;
11018 }
11019
11020 declare var ReadableStreamDefaultController: {
11021     prototype: ReadableStreamDefaultController;
11022     new(): ReadableStreamDefaultController;
11023 };
11024
11025 interface ReadableStreamDefaultReader<R = any> extends ReadableStreamGenericReader {
11026     read(): Promise<ReadableStreamDefaultReadResult<R>>;
11027     releaseLock(): void;
11028 }
11029
11030 declare var ReadableStreamDefaultReader: {
11031     prototype: ReadableStreamDefaultReader;
11032     new<R = any>(stream: ReadableStream<R>): ReadableStreamDefaultReader<R>;
11033 };
11034
11035 interface ReadableStreamGenericReader {
11036     readonly closed: Promise<undefined>;
11037     cancel(reason?: any): Promise<void>;
11038 }
11039
11040 interface RemotePlaybackEventMap {
11041     "connect": Event;
11042     "connecting": Event;
11043     "disconnect": Event;
11044 }
11045
11046 interface RemotePlayback extends EventTarget {
11047     onconnect: ((this: RemotePlayback, ev: Event) => any) | null;
11048     onconnecting: ((this: RemotePlayback, ev: Event) => any) | null;
11049     ondisconnect: ((this: RemotePlayback, ev: Event) => any) | null;
11050     readonly state: RemotePlaybackState;
11051     cancelWatchAvailability(id?: number): Promise<void>;
11052     prompt(): Promise<void>;
11053     watchAvailability(callback: RemotePlaybackAvailabilityCallback): Promise<number>;
11054     addEventListener<K extends keyof RemotePlaybackEventMap>(type: K, listener: (this: RemotePlayback, ev: RemotePlaybackEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11055     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11056     removeEventListener<K extends keyof RemotePlaybackEventMap>(type: K, listener: (this: RemotePlayback, ev: RemotePlaybackEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11057     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11058 }
11059
11060 declare var RemotePlayback: {
11061     prototype: RemotePlayback;
11062     new(): RemotePlayback;
11063 };
11064
11065 /** This Fetch API interface represents a resource request. */
11066 interface Request extends Body {
11067     /** Returns the cache mode associated with request, which is a string indicating how the request will interact with the browser's cache when fetching. */
11068     readonly cache: RequestCache;
11069     /** 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. */
11070     readonly credentials: RequestCredentials;
11071     /** Returns the kind of resource requested by request, e.g., "document" or "script". */
11072     readonly destination: RequestDestination;
11073     /** 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. */
11074     readonly headers: Headers;
11075     /** 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] */
11076     readonly integrity: string;
11077     /** Returns a boolean indicating whether or not request can outlive the global in which it was created. */
11078     readonly keepalive: boolean;
11079     /** Returns request's HTTP method, which is "GET" by default. */
11080     readonly method: string;
11081     /** 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. */
11082     readonly mode: RequestMode;
11083     /** 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. */
11084     readonly redirect: RequestRedirect;
11085     /** 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. */
11086     readonly referrer: string;
11087     /** Returns the referrer policy associated with request. This is used during fetching to compute the value of the request's referrer. */
11088     readonly referrerPolicy: ReferrerPolicy;
11089     /** Returns the signal associated with request, which is an AbortSignal object indicating whether or not request has been aborted, and its abort event handler. */
11090     readonly signal: AbortSignal;
11091     /** Returns the URL of request as a string. */
11092     readonly url: string;
11093     clone(): Request;
11094 }
11095
11096 declare var Request: {
11097     prototype: Request;
11098     new(input: RequestInfo, init?: RequestInit): Request;
11099 };
11100
11101 interface ResizeObserver {
11102     disconnect(): void;
11103     observe(target: Element, options?: ResizeObserverOptions): void;
11104     unobserve(target: Element): void;
11105 }
11106
11107 declare var ResizeObserver: {
11108     prototype: ResizeObserver;
11109     new(callback: ResizeObserverCallback): ResizeObserver;
11110 };
11111
11112 interface ResizeObserverEntry {
11113     readonly borderBoxSize: ReadonlyArray<ResizeObserverSize>;
11114     readonly contentBoxSize: ReadonlyArray<ResizeObserverSize>;
11115     readonly contentRect: DOMRectReadOnly;
11116     readonly target: Element;
11117 }
11118
11119 declare var ResizeObserverEntry: {
11120     prototype: ResizeObserverEntry;
11121     new(): ResizeObserverEntry;
11122 };
11123
11124 interface ResizeObserverSize {
11125     readonly blockSize: number;
11126     readonly inlineSize: number;
11127 }
11128
11129 declare var ResizeObserverSize: {
11130     prototype: ResizeObserverSize;
11131     new(): ResizeObserverSize;
11132 };
11133
11134 /** This Fetch API interface represents the response to a request. */
11135 interface Response extends Body {
11136     readonly headers: Headers;
11137     readonly ok: boolean;
11138     readonly redirected: boolean;
11139     readonly status: number;
11140     readonly statusText: string;
11141     readonly type: ResponseType;
11142     readonly url: string;
11143     clone(): Response;
11144 }
11145
11146 declare var Response: {
11147     prototype: Response;
11148     new(body?: BodyInit | null, init?: ResponseInit): Response;
11149     error(): Response;
11150     redirect(url: string | URL, status?: number): Response;
11151 };
11152
11153 /** Provides access to the properties of <a> element, as well as methods to manipulate them. */
11154 interface SVGAElement extends SVGGraphicsElement, SVGURIReference {
11155     rel: string;
11156     readonly relList: DOMTokenList;
11157     readonly target: SVGAnimatedString;
11158     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGAElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11159     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11160     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGAElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11161     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11162 }
11163
11164 declare var SVGAElement: {
11165     prototype: SVGAElement;
11166     new(): SVGAElement;
11167 };
11168
11169 /** Used to represent a value that can be an <angle> or <number> value. An SVGAngle reflected through the animVal attribute is always read only. */
11170 interface SVGAngle {
11171     readonly unitType: number;
11172     value: number;
11173     valueAsString: string;
11174     valueInSpecifiedUnits: number;
11175     convertToSpecifiedUnits(unitType: number): void;
11176     newValueSpecifiedUnits(unitType: number, valueInSpecifiedUnits: number): void;
11177     readonly SVG_ANGLETYPE_DEG: number;
11178     readonly SVG_ANGLETYPE_GRAD: number;
11179     readonly SVG_ANGLETYPE_RAD: number;
11180     readonly SVG_ANGLETYPE_UNKNOWN: number;
11181     readonly SVG_ANGLETYPE_UNSPECIFIED: number;
11182 }
11183
11184 declare var SVGAngle: {
11185     prototype: SVGAngle;
11186     new(): SVGAngle;
11187     readonly SVG_ANGLETYPE_DEG: number;
11188     readonly SVG_ANGLETYPE_GRAD: number;
11189     readonly SVG_ANGLETYPE_RAD: number;
11190     readonly SVG_ANGLETYPE_UNKNOWN: number;
11191     readonly SVG_ANGLETYPE_UNSPECIFIED: number;
11192 };
11193
11194 interface SVGAnimateElement extends SVGAnimationElement {
11195     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGAnimateElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11196     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11197     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGAnimateElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11198     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11199 }
11200
11201 declare var SVGAnimateElement: {
11202     prototype: SVGAnimateElement;
11203     new(): SVGAnimateElement;
11204 };
11205
11206 interface SVGAnimateMotionElement extends SVGAnimationElement {
11207     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGAnimateMotionElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11208     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11209     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGAnimateMotionElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11210     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11211 }
11212
11213 declare var SVGAnimateMotionElement: {
11214     prototype: SVGAnimateMotionElement;
11215     new(): SVGAnimateMotionElement;
11216 };
11217
11218 interface SVGAnimateTransformElement extends SVGAnimationElement {
11219     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGAnimateTransformElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11220     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11221     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGAnimateTransformElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11222     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11223 }
11224
11225 declare var SVGAnimateTransformElement: {
11226     prototype: SVGAnimateTransformElement;
11227     new(): SVGAnimateTransformElement;
11228 };
11229
11230 /** Used for attributes of basic type <angle> which can be animated. */
11231 interface SVGAnimatedAngle {
11232     readonly animVal: SVGAngle;
11233     readonly baseVal: SVGAngle;
11234 }
11235
11236 declare var SVGAnimatedAngle: {
11237     prototype: SVGAnimatedAngle;
11238     new(): SVGAnimatedAngle;
11239 };
11240
11241 /** Used for attributes of type boolean which can be animated. */
11242 interface SVGAnimatedBoolean {
11243     readonly animVal: boolean;
11244     baseVal: boolean;
11245 }
11246
11247 declare var SVGAnimatedBoolean: {
11248     prototype: SVGAnimatedBoolean;
11249     new(): SVGAnimatedBoolean;
11250 };
11251
11252 /** Used for attributes whose value must be a constant from a particular enumeration and which can be animated. */
11253 interface SVGAnimatedEnumeration {
11254     readonly animVal: number;
11255     baseVal: number;
11256 }
11257
11258 declare var SVGAnimatedEnumeration: {
11259     prototype: SVGAnimatedEnumeration;
11260     new(): SVGAnimatedEnumeration;
11261 };
11262
11263 /** Used for attributes of basic type <integer> which can be animated. */
11264 interface SVGAnimatedInteger {
11265     readonly animVal: number;
11266     baseVal: number;
11267 }
11268
11269 declare var SVGAnimatedInteger: {
11270     prototype: SVGAnimatedInteger;
11271     new(): SVGAnimatedInteger;
11272 };
11273
11274 /** Used for attributes of basic type <length> which can be animated. */
11275 interface SVGAnimatedLength {
11276     readonly animVal: SVGLength;
11277     readonly baseVal: SVGLength;
11278 }
11279
11280 declare var SVGAnimatedLength: {
11281     prototype: SVGAnimatedLength;
11282     new(): SVGAnimatedLength;
11283 };
11284
11285 /** Used for attributes of type SVGLengthList which can be animated. */
11286 interface SVGAnimatedLengthList {
11287     readonly animVal: SVGLengthList;
11288     readonly baseVal: SVGLengthList;
11289 }
11290
11291 declare var SVGAnimatedLengthList: {
11292     prototype: SVGAnimatedLengthList;
11293     new(): SVGAnimatedLengthList;
11294 };
11295
11296 /** Used for attributes of basic type <Number> which can be animated. */
11297 interface SVGAnimatedNumber {
11298     readonly animVal: number;
11299     baseVal: number;
11300 }
11301
11302 declare var SVGAnimatedNumber: {
11303     prototype: SVGAnimatedNumber;
11304     new(): SVGAnimatedNumber;
11305 };
11306
11307 /** The SVGAnimatedNumber interface is used for attributes which take a list of numbers and which can be animated. */
11308 interface SVGAnimatedNumberList {
11309     readonly animVal: SVGNumberList;
11310     readonly baseVal: SVGNumberList;
11311 }
11312
11313 declare var SVGAnimatedNumberList: {
11314     prototype: SVGAnimatedNumberList;
11315     new(): SVGAnimatedNumberList;
11316 };
11317
11318 interface SVGAnimatedPoints {
11319     readonly animatedPoints: SVGPointList;
11320     readonly points: SVGPointList;
11321 }
11322
11323 /** Used for attributes of type SVGPreserveAspectRatio which can be animated. */
11324 interface SVGAnimatedPreserveAspectRatio {
11325     readonly animVal: SVGPreserveAspectRatio;
11326     readonly baseVal: SVGPreserveAspectRatio;
11327 }
11328
11329 declare var SVGAnimatedPreserveAspectRatio: {
11330     prototype: SVGAnimatedPreserveAspectRatio;
11331     new(): SVGAnimatedPreserveAspectRatio;
11332 };
11333
11334 /** Used for attributes of basic SVGRect which can be animated. */
11335 interface SVGAnimatedRect {
11336     readonly animVal: DOMRectReadOnly;
11337     readonly baseVal: DOMRect;
11338 }
11339
11340 declare var SVGAnimatedRect: {
11341     prototype: SVGAnimatedRect;
11342     new(): SVGAnimatedRect;
11343 };
11344
11345 /** 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. */
11346 interface SVGAnimatedString {
11347     readonly animVal: string;
11348     baseVal: string;
11349 }
11350
11351 declare var SVGAnimatedString: {
11352     prototype: SVGAnimatedString;
11353     new(): SVGAnimatedString;
11354 };
11355
11356 /** Used for attributes which take a list of numbers and which can be animated. */
11357 interface SVGAnimatedTransformList {
11358     readonly animVal: SVGTransformList;
11359     readonly baseVal: SVGTransformList;
11360 }
11361
11362 declare var SVGAnimatedTransformList: {
11363     prototype: SVGAnimatedTransformList;
11364     new(): SVGAnimatedTransformList;
11365 };
11366
11367 interface SVGAnimationElement extends SVGElement, SVGTests {
11368     readonly targetElement: SVGElement | null;
11369     beginElement(): void;
11370     beginElementAt(offset: number): void;
11371     endElement(): void;
11372     endElementAt(offset: number): void;
11373     getCurrentTime(): number;
11374     getSimpleDuration(): number;
11375     getStartTime(): number;
11376     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGAnimationElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11377     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11378     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGAnimationElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11379     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11380 }
11381
11382 declare var SVGAnimationElement: {
11383     prototype: SVGAnimationElement;
11384     new(): SVGAnimationElement;
11385 };
11386
11387 /** 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. */
11388 interface SVGCircleElement extends SVGGeometryElement {
11389     readonly cx: SVGAnimatedLength;
11390     readonly cy: SVGAnimatedLength;
11391     readonly r: SVGAnimatedLength;
11392     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGCircleElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11393     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11394     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGCircleElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11395     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11396 }
11397
11398 declare var SVGCircleElement: {
11399     prototype: SVGCircleElement;
11400     new(): SVGCircleElement;
11401 };
11402
11403 /** Provides access to the properties of <clipPath> elements, as well as methods to manipulate them. */
11404 interface SVGClipPathElement extends SVGElement {
11405     readonly clipPathUnits: SVGAnimatedEnumeration;
11406     readonly transform: SVGAnimatedTransformList;
11407     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGClipPathElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11408     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11409     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGClipPathElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11410     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11411 }
11412
11413 declare var SVGClipPathElement: {
11414     prototype: SVGClipPathElement;
11415     new(): SVGClipPathElement;
11416 };
11417
11418 /** A base interface used by the component transfer function interfaces. */
11419 interface SVGComponentTransferFunctionElement extends SVGElement {
11420     readonly amplitude: SVGAnimatedNumber;
11421     readonly exponent: SVGAnimatedNumber;
11422     readonly intercept: SVGAnimatedNumber;
11423     readonly offset: SVGAnimatedNumber;
11424     readonly slope: SVGAnimatedNumber;
11425     readonly tableValues: SVGAnimatedNumberList;
11426     readonly type: SVGAnimatedEnumeration;
11427     readonly SVG_FECOMPONENTTRANSFER_TYPE_DISCRETE: number;
11428     readonly SVG_FECOMPONENTTRANSFER_TYPE_GAMMA: number;
11429     readonly SVG_FECOMPONENTTRANSFER_TYPE_IDENTITY: number;
11430     readonly SVG_FECOMPONENTTRANSFER_TYPE_LINEAR: number;
11431     readonly SVG_FECOMPONENTTRANSFER_TYPE_TABLE: number;
11432     readonly SVG_FECOMPONENTTRANSFER_TYPE_UNKNOWN: number;
11433     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGComponentTransferFunctionElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11434     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11435     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGComponentTransferFunctionElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11436     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11437 }
11438
11439 declare var SVGComponentTransferFunctionElement: {
11440     prototype: SVGComponentTransferFunctionElement;
11441     new(): SVGComponentTransferFunctionElement;
11442     readonly SVG_FECOMPONENTTRANSFER_TYPE_DISCRETE: number;
11443     readonly SVG_FECOMPONENTTRANSFER_TYPE_GAMMA: number;
11444     readonly SVG_FECOMPONENTTRANSFER_TYPE_IDENTITY: number;
11445     readonly SVG_FECOMPONENTTRANSFER_TYPE_LINEAR: number;
11446     readonly SVG_FECOMPONENTTRANSFER_TYPE_TABLE: number;
11447     readonly SVG_FECOMPONENTTRANSFER_TYPE_UNKNOWN: number;
11448 };
11449
11450 /** Corresponds to the <defs> element. */
11451 interface SVGDefsElement extends SVGGraphicsElement {
11452     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGDefsElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11453     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11454     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGDefsElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11455     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11456 }
11457
11458 declare var SVGDefsElement: {
11459     prototype: SVGDefsElement;
11460     new(): SVGDefsElement;
11461 };
11462
11463 /** Corresponds to the <desc> element. */
11464 interface SVGDescElement extends SVGElement {
11465     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGDescElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11466     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11467     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGDescElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11468     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11469 }
11470
11471 declare var SVGDescElement: {
11472     prototype: SVGDescElement;
11473     new(): SVGDescElement;
11474 };
11475
11476 interface SVGElementEventMap extends ElementEventMap, DocumentAndElementEventHandlersEventMap, GlobalEventHandlersEventMap {
11477 }
11478
11479 /** All of the SVG DOM interfaces that correspond directly to elements in the SVG language derive from the SVGElement interface. */
11480 interface SVGElement extends Element, DocumentAndElementEventHandlers, ElementCSSInlineStyle, GlobalEventHandlers, HTMLOrSVGElement {
11481     /** @deprecated */
11482     readonly className: any;
11483     readonly ownerSVGElement: SVGSVGElement | null;
11484     readonly viewportElement: SVGElement | null;
11485     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11486     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11487     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11488     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11489 }
11490
11491 declare var SVGElement: {
11492     prototype: SVGElement;
11493     new(): SVGElement;
11494 };
11495
11496 /** Provides access to the properties of <ellipse> elements. */
11497 interface SVGEllipseElement extends SVGGeometryElement {
11498     readonly cx: SVGAnimatedLength;
11499     readonly cy: SVGAnimatedLength;
11500     readonly rx: SVGAnimatedLength;
11501     readonly ry: SVGAnimatedLength;
11502     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGEllipseElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11503     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11504     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGEllipseElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11505     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11506 }
11507
11508 declare var SVGEllipseElement: {
11509     prototype: SVGEllipseElement;
11510     new(): SVGEllipseElement;
11511 };
11512
11513 /** Corresponds to the <feBlend> element. */
11514 interface SVGFEBlendElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
11515     readonly in1: SVGAnimatedString;
11516     readonly in2: SVGAnimatedString;
11517     readonly mode: SVGAnimatedEnumeration;
11518     readonly SVG_FEBLEND_MODE_COLOR: number;
11519     readonly SVG_FEBLEND_MODE_COLOR_BURN: number;
11520     readonly SVG_FEBLEND_MODE_COLOR_DODGE: number;
11521     readonly SVG_FEBLEND_MODE_DARKEN: number;
11522     readonly SVG_FEBLEND_MODE_DIFFERENCE: number;
11523     readonly SVG_FEBLEND_MODE_EXCLUSION: number;
11524     readonly SVG_FEBLEND_MODE_HARD_LIGHT: number;
11525     readonly SVG_FEBLEND_MODE_HUE: number;
11526     readonly SVG_FEBLEND_MODE_LIGHTEN: number;
11527     readonly SVG_FEBLEND_MODE_LUMINOSITY: number;
11528     readonly SVG_FEBLEND_MODE_MULTIPLY: number;
11529     readonly SVG_FEBLEND_MODE_NORMAL: number;
11530     readonly SVG_FEBLEND_MODE_OVERLAY: number;
11531     readonly SVG_FEBLEND_MODE_SATURATION: number;
11532     readonly SVG_FEBLEND_MODE_SCREEN: number;
11533     readonly SVG_FEBLEND_MODE_SOFT_LIGHT: number;
11534     readonly SVG_FEBLEND_MODE_UNKNOWN: number;
11535     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEBlendElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11536     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11537     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEBlendElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11538     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11539 }
11540
11541 declare var SVGFEBlendElement: {
11542     prototype: SVGFEBlendElement;
11543     new(): SVGFEBlendElement;
11544     readonly SVG_FEBLEND_MODE_COLOR: number;
11545     readonly SVG_FEBLEND_MODE_COLOR_BURN: number;
11546     readonly SVG_FEBLEND_MODE_COLOR_DODGE: number;
11547     readonly SVG_FEBLEND_MODE_DARKEN: number;
11548     readonly SVG_FEBLEND_MODE_DIFFERENCE: number;
11549     readonly SVG_FEBLEND_MODE_EXCLUSION: number;
11550     readonly SVG_FEBLEND_MODE_HARD_LIGHT: number;
11551     readonly SVG_FEBLEND_MODE_HUE: number;
11552     readonly SVG_FEBLEND_MODE_LIGHTEN: number;
11553     readonly SVG_FEBLEND_MODE_LUMINOSITY: number;
11554     readonly SVG_FEBLEND_MODE_MULTIPLY: number;
11555     readonly SVG_FEBLEND_MODE_NORMAL: number;
11556     readonly SVG_FEBLEND_MODE_OVERLAY: number;
11557     readonly SVG_FEBLEND_MODE_SATURATION: number;
11558     readonly SVG_FEBLEND_MODE_SCREEN: number;
11559     readonly SVG_FEBLEND_MODE_SOFT_LIGHT: number;
11560     readonly SVG_FEBLEND_MODE_UNKNOWN: number;
11561 };
11562
11563 /** Corresponds to the <feColorMatrix> element. */
11564 interface SVGFEColorMatrixElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
11565     readonly in1: SVGAnimatedString;
11566     readonly type: SVGAnimatedEnumeration;
11567     readonly values: SVGAnimatedNumberList;
11568     readonly SVG_FECOLORMATRIX_TYPE_HUEROTATE: number;
11569     readonly SVG_FECOLORMATRIX_TYPE_LUMINANCETOALPHA: number;
11570     readonly SVG_FECOLORMATRIX_TYPE_MATRIX: number;
11571     readonly SVG_FECOLORMATRIX_TYPE_SATURATE: number;
11572     readonly SVG_FECOLORMATRIX_TYPE_UNKNOWN: number;
11573     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEColorMatrixElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11574     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11575     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEColorMatrixElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11576     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11577 }
11578
11579 declare var SVGFEColorMatrixElement: {
11580     prototype: SVGFEColorMatrixElement;
11581     new(): SVGFEColorMatrixElement;
11582     readonly SVG_FECOLORMATRIX_TYPE_HUEROTATE: number;
11583     readonly SVG_FECOLORMATRIX_TYPE_LUMINANCETOALPHA: number;
11584     readonly SVG_FECOLORMATRIX_TYPE_MATRIX: number;
11585     readonly SVG_FECOLORMATRIX_TYPE_SATURATE: number;
11586     readonly SVG_FECOLORMATRIX_TYPE_UNKNOWN: number;
11587 };
11588
11589 /** Corresponds to the <feComponentTransfer> element. */
11590 interface SVGFEComponentTransferElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
11591     readonly in1: SVGAnimatedString;
11592     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEComponentTransferElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11593     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11594     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEComponentTransferElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11595     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11596 }
11597
11598 declare var SVGFEComponentTransferElement: {
11599     prototype: SVGFEComponentTransferElement;
11600     new(): SVGFEComponentTransferElement;
11601 };
11602
11603 /** Corresponds to the <feComposite> element. */
11604 interface SVGFECompositeElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
11605     readonly in1: SVGAnimatedString;
11606     readonly in2: SVGAnimatedString;
11607     readonly k1: SVGAnimatedNumber;
11608     readonly k2: SVGAnimatedNumber;
11609     readonly k3: SVGAnimatedNumber;
11610     readonly k4: SVGAnimatedNumber;
11611     readonly operator: SVGAnimatedEnumeration;
11612     readonly SVG_FECOMPOSITE_OPERATOR_ARITHMETIC: number;
11613     readonly SVG_FECOMPOSITE_OPERATOR_ATOP: number;
11614     readonly SVG_FECOMPOSITE_OPERATOR_IN: number;
11615     readonly SVG_FECOMPOSITE_OPERATOR_OUT: number;
11616     readonly SVG_FECOMPOSITE_OPERATOR_OVER: number;
11617     readonly SVG_FECOMPOSITE_OPERATOR_UNKNOWN: number;
11618     readonly SVG_FECOMPOSITE_OPERATOR_XOR: number;
11619     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFECompositeElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11620     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11621     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFECompositeElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11622     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11623 }
11624
11625 declare var SVGFECompositeElement: {
11626     prototype: SVGFECompositeElement;
11627     new(): SVGFECompositeElement;
11628     readonly SVG_FECOMPOSITE_OPERATOR_ARITHMETIC: number;
11629     readonly SVG_FECOMPOSITE_OPERATOR_ATOP: number;
11630     readonly SVG_FECOMPOSITE_OPERATOR_IN: number;
11631     readonly SVG_FECOMPOSITE_OPERATOR_OUT: number;
11632     readonly SVG_FECOMPOSITE_OPERATOR_OVER: number;
11633     readonly SVG_FECOMPOSITE_OPERATOR_UNKNOWN: number;
11634     readonly SVG_FECOMPOSITE_OPERATOR_XOR: number;
11635 };
11636
11637 /** Corresponds to the <feConvolveMatrix> element. */
11638 interface SVGFEConvolveMatrixElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
11639     readonly bias: SVGAnimatedNumber;
11640     readonly divisor: SVGAnimatedNumber;
11641     readonly edgeMode: SVGAnimatedEnumeration;
11642     readonly in1: SVGAnimatedString;
11643     readonly kernelMatrix: SVGAnimatedNumberList;
11644     readonly kernelUnitLengthX: SVGAnimatedNumber;
11645     readonly kernelUnitLengthY: SVGAnimatedNumber;
11646     readonly orderX: SVGAnimatedInteger;
11647     readonly orderY: SVGAnimatedInteger;
11648     readonly preserveAlpha: SVGAnimatedBoolean;
11649     readonly targetX: SVGAnimatedInteger;
11650     readonly targetY: SVGAnimatedInteger;
11651     readonly SVG_EDGEMODE_DUPLICATE: number;
11652     readonly SVG_EDGEMODE_NONE: number;
11653     readonly SVG_EDGEMODE_UNKNOWN: number;
11654     readonly SVG_EDGEMODE_WRAP: number;
11655     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEConvolveMatrixElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11656     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11657     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEConvolveMatrixElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11658     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11659 }
11660
11661 declare var SVGFEConvolveMatrixElement: {
11662     prototype: SVGFEConvolveMatrixElement;
11663     new(): SVGFEConvolveMatrixElement;
11664     readonly SVG_EDGEMODE_DUPLICATE: number;
11665     readonly SVG_EDGEMODE_NONE: number;
11666     readonly SVG_EDGEMODE_UNKNOWN: number;
11667     readonly SVG_EDGEMODE_WRAP: number;
11668 };
11669
11670 /** Corresponds to the <feDiffuseLighting> element. */
11671 interface SVGFEDiffuseLightingElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
11672     readonly diffuseConstant: SVGAnimatedNumber;
11673     readonly in1: SVGAnimatedString;
11674     readonly kernelUnitLengthX: SVGAnimatedNumber;
11675     readonly kernelUnitLengthY: SVGAnimatedNumber;
11676     readonly surfaceScale: SVGAnimatedNumber;
11677     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEDiffuseLightingElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11678     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11679     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEDiffuseLightingElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11680     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11681 }
11682
11683 declare var SVGFEDiffuseLightingElement: {
11684     prototype: SVGFEDiffuseLightingElement;
11685     new(): SVGFEDiffuseLightingElement;
11686 };
11687
11688 /** Corresponds to the <feDisplacementMap> element. */
11689 interface SVGFEDisplacementMapElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
11690     readonly in1: SVGAnimatedString;
11691     readonly in2: SVGAnimatedString;
11692     readonly scale: SVGAnimatedNumber;
11693     readonly xChannelSelector: SVGAnimatedEnumeration;
11694     readonly yChannelSelector: SVGAnimatedEnumeration;
11695     readonly SVG_CHANNEL_A: number;
11696     readonly SVG_CHANNEL_B: number;
11697     readonly SVG_CHANNEL_G: number;
11698     readonly SVG_CHANNEL_R: number;
11699     readonly SVG_CHANNEL_UNKNOWN: number;
11700     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEDisplacementMapElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11701     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11702     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEDisplacementMapElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11703     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11704 }
11705
11706 declare var SVGFEDisplacementMapElement: {
11707     prototype: SVGFEDisplacementMapElement;
11708     new(): SVGFEDisplacementMapElement;
11709     readonly SVG_CHANNEL_A: number;
11710     readonly SVG_CHANNEL_B: number;
11711     readonly SVG_CHANNEL_G: number;
11712     readonly SVG_CHANNEL_R: number;
11713     readonly SVG_CHANNEL_UNKNOWN: number;
11714 };
11715
11716 /** Corresponds to the <feDistantLight> element. */
11717 interface SVGFEDistantLightElement extends SVGElement {
11718     readonly azimuth: SVGAnimatedNumber;
11719     readonly elevation: SVGAnimatedNumber;
11720     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEDistantLightElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11721     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11722     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEDistantLightElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11723     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11724 }
11725
11726 declare var SVGFEDistantLightElement: {
11727     prototype: SVGFEDistantLightElement;
11728     new(): SVGFEDistantLightElement;
11729 };
11730
11731 interface SVGFEDropShadowElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
11732     readonly dx: SVGAnimatedNumber;
11733     readonly dy: SVGAnimatedNumber;
11734     readonly in1: SVGAnimatedString;
11735     readonly stdDeviationX: SVGAnimatedNumber;
11736     readonly stdDeviationY: SVGAnimatedNumber;
11737     setStdDeviation(stdDeviationX: number, stdDeviationY: number): void;
11738     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEDropShadowElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11739     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11740     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEDropShadowElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11741     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11742 }
11743
11744 declare var SVGFEDropShadowElement: {
11745     prototype: SVGFEDropShadowElement;
11746     new(): SVGFEDropShadowElement;
11747 };
11748
11749 /** Corresponds to the <feFlood> element. */
11750 interface SVGFEFloodElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
11751     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEFloodElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11752     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11753     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEFloodElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11754     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11755 }
11756
11757 declare var SVGFEFloodElement: {
11758     prototype: SVGFEFloodElement;
11759     new(): SVGFEFloodElement;
11760 };
11761
11762 /** Corresponds to the <feFuncA> element. */
11763 interface SVGFEFuncAElement extends SVGComponentTransferFunctionElement {
11764     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEFuncAElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11765     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11766     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEFuncAElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11767     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11768 }
11769
11770 declare var SVGFEFuncAElement: {
11771     prototype: SVGFEFuncAElement;
11772     new(): SVGFEFuncAElement;
11773 };
11774
11775 /** Corresponds to the <feFuncB> element. */
11776 interface SVGFEFuncBElement extends SVGComponentTransferFunctionElement {
11777     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEFuncBElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11778     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11779     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEFuncBElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11780     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11781 }
11782
11783 declare var SVGFEFuncBElement: {
11784     prototype: SVGFEFuncBElement;
11785     new(): SVGFEFuncBElement;
11786 };
11787
11788 /** Corresponds to the <feFuncG> element. */
11789 interface SVGFEFuncGElement extends SVGComponentTransferFunctionElement {
11790     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEFuncGElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11791     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11792     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEFuncGElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11793     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11794 }
11795
11796 declare var SVGFEFuncGElement: {
11797     prototype: SVGFEFuncGElement;
11798     new(): SVGFEFuncGElement;
11799 };
11800
11801 /** Corresponds to the <feFuncR> element. */
11802 interface SVGFEFuncRElement extends SVGComponentTransferFunctionElement {
11803     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEFuncRElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11804     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11805     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEFuncRElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11806     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11807 }
11808
11809 declare var SVGFEFuncRElement: {
11810     prototype: SVGFEFuncRElement;
11811     new(): SVGFEFuncRElement;
11812 };
11813
11814 /** Corresponds to the <feGaussianBlur> element. */
11815 interface SVGFEGaussianBlurElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
11816     readonly in1: SVGAnimatedString;
11817     readonly stdDeviationX: SVGAnimatedNumber;
11818     readonly stdDeviationY: SVGAnimatedNumber;
11819     setStdDeviation(stdDeviationX: number, stdDeviationY: number): void;
11820     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEGaussianBlurElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11821     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11822     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEGaussianBlurElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11823     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11824 }
11825
11826 declare var SVGFEGaussianBlurElement: {
11827     prototype: SVGFEGaussianBlurElement;
11828     new(): SVGFEGaussianBlurElement;
11829 };
11830
11831 /** Corresponds to the <feImage> element. */
11832 interface SVGFEImageElement extends SVGElement, SVGFilterPrimitiveStandardAttributes, SVGURIReference {
11833     readonly preserveAspectRatio: SVGAnimatedPreserveAspectRatio;
11834     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEImageElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11835     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11836     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEImageElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11837     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11838 }
11839
11840 declare var SVGFEImageElement: {
11841     prototype: SVGFEImageElement;
11842     new(): SVGFEImageElement;
11843 };
11844
11845 /** Corresponds to the <feMerge> element. */
11846 interface SVGFEMergeElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
11847     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEMergeElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11848     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11849     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEMergeElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11850     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11851 }
11852
11853 declare var SVGFEMergeElement: {
11854     prototype: SVGFEMergeElement;
11855     new(): SVGFEMergeElement;
11856 };
11857
11858 /** Corresponds to the <feMergeNode> element. */
11859 interface SVGFEMergeNodeElement extends SVGElement {
11860     readonly in1: SVGAnimatedString;
11861     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEMergeNodeElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11862     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11863     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEMergeNodeElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11864     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11865 }
11866
11867 declare var SVGFEMergeNodeElement: {
11868     prototype: SVGFEMergeNodeElement;
11869     new(): SVGFEMergeNodeElement;
11870 };
11871
11872 /** Corresponds to the <feMorphology> element. */
11873 interface SVGFEMorphologyElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
11874     readonly in1: SVGAnimatedString;
11875     readonly operator: SVGAnimatedEnumeration;
11876     readonly radiusX: SVGAnimatedNumber;
11877     readonly radiusY: SVGAnimatedNumber;
11878     readonly SVG_MORPHOLOGY_OPERATOR_DILATE: number;
11879     readonly SVG_MORPHOLOGY_OPERATOR_ERODE: number;
11880     readonly SVG_MORPHOLOGY_OPERATOR_UNKNOWN: number;
11881     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEMorphologyElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11882     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11883     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEMorphologyElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11884     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11885 }
11886
11887 declare var SVGFEMorphologyElement: {
11888     prototype: SVGFEMorphologyElement;
11889     new(): SVGFEMorphologyElement;
11890     readonly SVG_MORPHOLOGY_OPERATOR_DILATE: number;
11891     readonly SVG_MORPHOLOGY_OPERATOR_ERODE: number;
11892     readonly SVG_MORPHOLOGY_OPERATOR_UNKNOWN: number;
11893 };
11894
11895 /** Corresponds to the <feOffset> element. */
11896 interface SVGFEOffsetElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
11897     readonly dx: SVGAnimatedNumber;
11898     readonly dy: SVGAnimatedNumber;
11899     readonly in1: SVGAnimatedString;
11900     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEOffsetElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11901     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11902     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEOffsetElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11903     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11904 }
11905
11906 declare var SVGFEOffsetElement: {
11907     prototype: SVGFEOffsetElement;
11908     new(): SVGFEOffsetElement;
11909 };
11910
11911 /** Corresponds to the <fePointLight> element. */
11912 interface SVGFEPointLightElement extends SVGElement {
11913     readonly x: SVGAnimatedNumber;
11914     readonly y: SVGAnimatedNumber;
11915     readonly z: SVGAnimatedNumber;
11916     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEPointLightElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11917     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11918     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEPointLightElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11919     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11920 }
11921
11922 declare var SVGFEPointLightElement: {
11923     prototype: SVGFEPointLightElement;
11924     new(): SVGFEPointLightElement;
11925 };
11926
11927 /** Corresponds to the <feSpecularLighting> element. */
11928 interface SVGFESpecularLightingElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
11929     readonly in1: SVGAnimatedString;
11930     readonly kernelUnitLengthX: SVGAnimatedNumber;
11931     readonly kernelUnitLengthY: SVGAnimatedNumber;
11932     readonly specularConstant: SVGAnimatedNumber;
11933     readonly specularExponent: SVGAnimatedNumber;
11934     readonly surfaceScale: SVGAnimatedNumber;
11935     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFESpecularLightingElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11936     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11937     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFESpecularLightingElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11938     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11939 }
11940
11941 declare var SVGFESpecularLightingElement: {
11942     prototype: SVGFESpecularLightingElement;
11943     new(): SVGFESpecularLightingElement;
11944 };
11945
11946 /** Corresponds to the <feSpotLight> element. */
11947 interface SVGFESpotLightElement extends SVGElement {
11948     readonly limitingConeAngle: SVGAnimatedNumber;
11949     readonly pointsAtX: SVGAnimatedNumber;
11950     readonly pointsAtY: SVGAnimatedNumber;
11951     readonly pointsAtZ: SVGAnimatedNumber;
11952     readonly specularExponent: SVGAnimatedNumber;
11953     readonly x: SVGAnimatedNumber;
11954     readonly y: SVGAnimatedNumber;
11955     readonly z: SVGAnimatedNumber;
11956     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFESpotLightElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11957     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11958     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFESpotLightElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11959     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11960 }
11961
11962 declare var SVGFESpotLightElement: {
11963     prototype: SVGFESpotLightElement;
11964     new(): SVGFESpotLightElement;
11965 };
11966
11967 /** Corresponds to the <feTile> element. */
11968 interface SVGFETileElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
11969     readonly in1: SVGAnimatedString;
11970     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFETileElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11971     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11972     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFETileElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11973     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11974 }
11975
11976 declare var SVGFETileElement: {
11977     prototype: SVGFETileElement;
11978     new(): SVGFETileElement;
11979 };
11980
11981 /** Corresponds to the <feTurbulence> element. */
11982 interface SVGFETurbulenceElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
11983     readonly baseFrequencyX: SVGAnimatedNumber;
11984     readonly baseFrequencyY: SVGAnimatedNumber;
11985     readonly numOctaves: SVGAnimatedInteger;
11986     readonly seed: SVGAnimatedNumber;
11987     readonly stitchTiles: SVGAnimatedEnumeration;
11988     readonly type: SVGAnimatedEnumeration;
11989     readonly SVG_STITCHTYPE_NOSTITCH: number;
11990     readonly SVG_STITCHTYPE_STITCH: number;
11991     readonly SVG_STITCHTYPE_UNKNOWN: number;
11992     readonly SVG_TURBULENCE_TYPE_FRACTALNOISE: number;
11993     readonly SVG_TURBULENCE_TYPE_TURBULENCE: number;
11994     readonly SVG_TURBULENCE_TYPE_UNKNOWN: number;
11995     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFETurbulenceElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11996     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11997     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFETurbulenceElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11998     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11999 }
12000
12001 declare var SVGFETurbulenceElement: {
12002     prototype: SVGFETurbulenceElement;
12003     new(): SVGFETurbulenceElement;
12004     readonly SVG_STITCHTYPE_NOSTITCH: number;
12005     readonly SVG_STITCHTYPE_STITCH: number;
12006     readonly SVG_STITCHTYPE_UNKNOWN: number;
12007     readonly SVG_TURBULENCE_TYPE_FRACTALNOISE: number;
12008     readonly SVG_TURBULENCE_TYPE_TURBULENCE: number;
12009     readonly SVG_TURBULENCE_TYPE_UNKNOWN: number;
12010 };
12011
12012 /** Provides access to the properties of <filter> elements, as well as methods to manipulate them. */
12013 interface SVGFilterElement extends SVGElement, SVGURIReference {
12014     readonly filterUnits: SVGAnimatedEnumeration;
12015     readonly height: SVGAnimatedLength;
12016     readonly primitiveUnits: SVGAnimatedEnumeration;
12017     readonly width: SVGAnimatedLength;
12018     readonly x: SVGAnimatedLength;
12019     readonly y: SVGAnimatedLength;
12020     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFilterElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12021     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12022     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFilterElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12023     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12024 }
12025
12026 declare var SVGFilterElement: {
12027     prototype: SVGFilterElement;
12028     new(): SVGFilterElement;
12029 };
12030
12031 interface SVGFilterPrimitiveStandardAttributes {
12032     readonly height: SVGAnimatedLength;
12033     readonly result: SVGAnimatedString;
12034     readonly width: SVGAnimatedLength;
12035     readonly x: SVGAnimatedLength;
12036     readonly y: SVGAnimatedLength;
12037 }
12038
12039 interface SVGFitToViewBox {
12040     readonly preserveAspectRatio: SVGAnimatedPreserveAspectRatio;
12041     readonly viewBox: SVGAnimatedRect;
12042 }
12043
12044 /** Provides access to the properties of <foreignObject> elements, as well as methods to manipulate them. */
12045 interface SVGForeignObjectElement extends SVGGraphicsElement {
12046     readonly height: SVGAnimatedLength;
12047     readonly width: SVGAnimatedLength;
12048     readonly x: SVGAnimatedLength;
12049     readonly y: SVGAnimatedLength;
12050     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGForeignObjectElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12051     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12052     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGForeignObjectElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12053     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12054 }
12055
12056 declare var SVGForeignObjectElement: {
12057     prototype: SVGForeignObjectElement;
12058     new(): SVGForeignObjectElement;
12059 };
12060
12061 /** Corresponds to the <g> element. */
12062 interface SVGGElement extends SVGGraphicsElement {
12063     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGGElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12064     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12065     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGGElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12066     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12067 }
12068
12069 declare var SVGGElement: {
12070     prototype: SVGGElement;
12071     new(): SVGGElement;
12072 };
12073
12074 interface SVGGeometryElement extends SVGGraphicsElement {
12075     readonly pathLength: SVGAnimatedNumber;
12076     getPointAtLength(distance: number): DOMPoint;
12077     getTotalLength(): number;
12078     isPointInFill(point?: DOMPointInit): boolean;
12079     isPointInStroke(point?: DOMPointInit): boolean;
12080     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGGeometryElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12081     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12082     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGGeometryElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12083     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12084 }
12085
12086 declare var SVGGeometryElement: {
12087     prototype: SVGGeometryElement;
12088     new(): SVGGeometryElement;
12089 };
12090
12091 /** The SVGGradient interface is a base interface used by SVGLinearGradientElement and SVGRadialGradientElement. */
12092 interface SVGGradientElement extends SVGElement, SVGURIReference {
12093     readonly gradientTransform: SVGAnimatedTransformList;
12094     readonly gradientUnits: SVGAnimatedEnumeration;
12095     readonly spreadMethod: SVGAnimatedEnumeration;
12096     readonly SVG_SPREADMETHOD_PAD: number;
12097     readonly SVG_SPREADMETHOD_REFLECT: number;
12098     readonly SVG_SPREADMETHOD_REPEAT: number;
12099     readonly SVG_SPREADMETHOD_UNKNOWN: number;
12100     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGGradientElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12101     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12102     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGGradientElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12103     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12104 }
12105
12106 declare var SVGGradientElement: {
12107     prototype: SVGGradientElement;
12108     new(): SVGGradientElement;
12109     readonly SVG_SPREADMETHOD_PAD: number;
12110     readonly SVG_SPREADMETHOD_REFLECT: number;
12111     readonly SVG_SPREADMETHOD_REPEAT: number;
12112     readonly SVG_SPREADMETHOD_UNKNOWN: number;
12113 };
12114
12115 /** SVG elements whose primary purpose is to directly render graphics into a group. */
12116 interface SVGGraphicsElement extends SVGElement, SVGTests {
12117     readonly transform: SVGAnimatedTransformList;
12118     getBBox(options?: SVGBoundingBoxOptions): DOMRect;
12119     getCTM(): DOMMatrix | null;
12120     getScreenCTM(): DOMMatrix | null;
12121     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGGraphicsElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12122     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12123     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGGraphicsElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12124     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12125 }
12126
12127 declare var SVGGraphicsElement: {
12128     prototype: SVGGraphicsElement;
12129     new(): SVGGraphicsElement;
12130 };
12131
12132 /** Corresponds to the <image> element. */
12133 interface SVGImageElement extends SVGGraphicsElement, SVGURIReference {
12134     readonly height: SVGAnimatedLength;
12135     readonly preserveAspectRatio: SVGAnimatedPreserveAspectRatio;
12136     readonly width: SVGAnimatedLength;
12137     readonly x: SVGAnimatedLength;
12138     readonly y: SVGAnimatedLength;
12139     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGImageElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12140     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12141     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGImageElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12142     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12143 }
12144
12145 declare var SVGImageElement: {
12146     prototype: SVGImageElement;
12147     new(): SVGImageElement;
12148 };
12149
12150 /** Correspond to the <length> basic data type. */
12151 interface SVGLength {
12152     readonly unitType: number;
12153     value: number;
12154     valueAsString: string;
12155     valueInSpecifiedUnits: number;
12156     convertToSpecifiedUnits(unitType: number): void;
12157     newValueSpecifiedUnits(unitType: number, valueInSpecifiedUnits: number): void;
12158     readonly SVG_LENGTHTYPE_CM: number;
12159     readonly SVG_LENGTHTYPE_EMS: number;
12160     readonly SVG_LENGTHTYPE_EXS: number;
12161     readonly SVG_LENGTHTYPE_IN: number;
12162     readonly SVG_LENGTHTYPE_MM: number;
12163     readonly SVG_LENGTHTYPE_NUMBER: number;
12164     readonly SVG_LENGTHTYPE_PC: number;
12165     readonly SVG_LENGTHTYPE_PERCENTAGE: number;
12166     readonly SVG_LENGTHTYPE_PT: number;
12167     readonly SVG_LENGTHTYPE_PX: number;
12168     readonly SVG_LENGTHTYPE_UNKNOWN: number;
12169 }
12170
12171 declare var SVGLength: {
12172     prototype: SVGLength;
12173     new(): SVGLength;
12174     readonly SVG_LENGTHTYPE_CM: number;
12175     readonly SVG_LENGTHTYPE_EMS: number;
12176     readonly SVG_LENGTHTYPE_EXS: number;
12177     readonly SVG_LENGTHTYPE_IN: number;
12178     readonly SVG_LENGTHTYPE_MM: number;
12179     readonly SVG_LENGTHTYPE_NUMBER: number;
12180     readonly SVG_LENGTHTYPE_PC: number;
12181     readonly SVG_LENGTHTYPE_PERCENTAGE: number;
12182     readonly SVG_LENGTHTYPE_PT: number;
12183     readonly SVG_LENGTHTYPE_PX: number;
12184     readonly SVG_LENGTHTYPE_UNKNOWN: number;
12185 };
12186
12187 /** The SVGLengthList defines a list of SVGLength objects. */
12188 interface SVGLengthList {
12189     readonly length: number;
12190     readonly numberOfItems: number;
12191     appendItem(newItem: SVGLength): SVGLength;
12192     clear(): void;
12193     getItem(index: number): SVGLength;
12194     initialize(newItem: SVGLength): SVGLength;
12195     insertItemBefore(newItem: SVGLength, index: number): SVGLength;
12196     removeItem(index: number): SVGLength;
12197     replaceItem(newItem: SVGLength, index: number): SVGLength;
12198     [index: number]: SVGLength;
12199 }
12200
12201 declare var SVGLengthList: {
12202     prototype: SVGLengthList;
12203     new(): SVGLengthList;
12204 };
12205
12206 /** Provides access to the properties of <line> elements, as well as methods to manipulate them. */
12207 interface SVGLineElement extends SVGGeometryElement {
12208     readonly x1: SVGAnimatedLength;
12209     readonly x2: SVGAnimatedLength;
12210     readonly y1: SVGAnimatedLength;
12211     readonly y2: SVGAnimatedLength;
12212     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGLineElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12213     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12214     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGLineElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12215     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12216 }
12217
12218 declare var SVGLineElement: {
12219     prototype: SVGLineElement;
12220     new(): SVGLineElement;
12221 };
12222
12223 /** Corresponds to the <linearGradient> element. */
12224 interface SVGLinearGradientElement extends SVGGradientElement {
12225     readonly x1: SVGAnimatedLength;
12226     readonly x2: SVGAnimatedLength;
12227     readonly y1: SVGAnimatedLength;
12228     readonly y2: SVGAnimatedLength;
12229     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGLinearGradientElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12230     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12231     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGLinearGradientElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12232     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12233 }
12234
12235 declare var SVGLinearGradientElement: {
12236     prototype: SVGLinearGradientElement;
12237     new(): SVGLinearGradientElement;
12238 };
12239
12240 interface SVGMPathElement extends SVGElement, SVGURIReference {
12241     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGMPathElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12242     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12243     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGMPathElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12244     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12245 }
12246
12247 declare var SVGMPathElement: {
12248     prototype: SVGMPathElement;
12249     new(): SVGMPathElement;
12250 };
12251
12252 interface SVGMarkerElement extends SVGElement, SVGFitToViewBox {
12253     readonly markerHeight: SVGAnimatedLength;
12254     readonly markerUnits: SVGAnimatedEnumeration;
12255     readonly markerWidth: SVGAnimatedLength;
12256     readonly orientAngle: SVGAnimatedAngle;
12257     readonly orientType: SVGAnimatedEnumeration;
12258     readonly refX: SVGAnimatedLength;
12259     readonly refY: SVGAnimatedLength;
12260     setOrientToAngle(angle: SVGAngle): void;
12261     setOrientToAuto(): void;
12262     readonly SVG_MARKERUNITS_STROKEWIDTH: number;
12263     readonly SVG_MARKERUNITS_UNKNOWN: number;
12264     readonly SVG_MARKERUNITS_USERSPACEONUSE: number;
12265     readonly SVG_MARKER_ORIENT_ANGLE: number;
12266     readonly SVG_MARKER_ORIENT_AUTO: number;
12267     readonly SVG_MARKER_ORIENT_UNKNOWN: number;
12268     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGMarkerElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12269     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12270     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGMarkerElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12271     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12272 }
12273
12274 declare var SVGMarkerElement: {
12275     prototype: SVGMarkerElement;
12276     new(): SVGMarkerElement;
12277     readonly SVG_MARKERUNITS_STROKEWIDTH: number;
12278     readonly SVG_MARKERUNITS_UNKNOWN: number;
12279     readonly SVG_MARKERUNITS_USERSPACEONUSE: number;
12280     readonly SVG_MARKER_ORIENT_ANGLE: number;
12281     readonly SVG_MARKER_ORIENT_AUTO: number;
12282     readonly SVG_MARKER_ORIENT_UNKNOWN: number;
12283 };
12284
12285 /** Provides access to the properties of <mask> elements, as well as methods to manipulate them. */
12286 interface SVGMaskElement extends SVGElement {
12287     readonly height: SVGAnimatedLength;
12288     readonly maskContentUnits: SVGAnimatedEnumeration;
12289     readonly maskUnits: SVGAnimatedEnumeration;
12290     readonly width: SVGAnimatedLength;
12291     readonly x: SVGAnimatedLength;
12292     readonly y: SVGAnimatedLength;
12293     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGMaskElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12294     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12295     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGMaskElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12296     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12297 }
12298
12299 declare var SVGMaskElement: {
12300     prototype: SVGMaskElement;
12301     new(): SVGMaskElement;
12302 };
12303
12304 /** Corresponds to the <metadata> element. */
12305 interface SVGMetadataElement extends SVGElement {
12306     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGMetadataElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12307     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12308     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGMetadataElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12309     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12310 }
12311
12312 declare var SVGMetadataElement: {
12313     prototype: SVGMetadataElement;
12314     new(): SVGMetadataElement;
12315 };
12316
12317 /** Corresponds to the <number> basic data type. */
12318 interface SVGNumber {
12319     value: number;
12320 }
12321
12322 declare var SVGNumber: {
12323     prototype: SVGNumber;
12324     new(): SVGNumber;
12325 };
12326
12327 /** The SVGNumberList defines a list of SVGNumber objects. */
12328 interface SVGNumberList {
12329     readonly length: number;
12330     readonly numberOfItems: number;
12331     appendItem(newItem: SVGNumber): SVGNumber;
12332     clear(): void;
12333     getItem(index: number): SVGNumber;
12334     initialize(newItem: SVGNumber): SVGNumber;
12335     insertItemBefore(newItem: SVGNumber, index: number): SVGNumber;
12336     removeItem(index: number): SVGNumber;
12337     replaceItem(newItem: SVGNumber, index: number): SVGNumber;
12338     [index: number]: SVGNumber;
12339 }
12340
12341 declare var SVGNumberList: {
12342     prototype: SVGNumberList;
12343     new(): SVGNumberList;
12344 };
12345
12346 /** Corresponds to the <path> element. */
12347 interface SVGPathElement extends SVGGeometryElement {
12348     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGPathElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12349     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12350     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGPathElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12351     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12352 }
12353
12354 declare var SVGPathElement: {
12355     prototype: SVGPathElement;
12356     new(): SVGPathElement;
12357 };
12358
12359 /** Corresponds to the <pattern> element. */
12360 interface SVGPatternElement extends SVGElement, SVGFitToViewBox, SVGURIReference {
12361     readonly height: SVGAnimatedLength;
12362     readonly patternContentUnits: SVGAnimatedEnumeration;
12363     readonly patternTransform: SVGAnimatedTransformList;
12364     readonly patternUnits: SVGAnimatedEnumeration;
12365     readonly width: SVGAnimatedLength;
12366     readonly x: SVGAnimatedLength;
12367     readonly y: SVGAnimatedLength;
12368     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGPatternElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12369     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12370     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGPatternElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12371     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12372 }
12373
12374 declare var SVGPatternElement: {
12375     prototype: SVGPatternElement;
12376     new(): SVGPatternElement;
12377 };
12378
12379 interface SVGPointList {
12380     readonly length: number;
12381     readonly numberOfItems: number;
12382     appendItem(newItem: DOMPoint): DOMPoint;
12383     clear(): void;
12384     getItem(index: number): DOMPoint;
12385     initialize(newItem: DOMPoint): DOMPoint;
12386     insertItemBefore(newItem: DOMPoint, index: number): DOMPoint;
12387     removeItem(index: number): DOMPoint;
12388     replaceItem(newItem: DOMPoint, index: number): DOMPoint;
12389     [index: number]: DOMPoint;
12390 }
12391
12392 declare var SVGPointList: {
12393     prototype: SVGPointList;
12394     new(): SVGPointList;
12395 };
12396
12397 /** Provides access to the properties of <polygon> elements, as well as methods to manipulate them. */
12398 interface SVGPolygonElement extends SVGGeometryElement, SVGAnimatedPoints {
12399     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGPolygonElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12400     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12401     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGPolygonElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12402     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12403 }
12404
12405 declare var SVGPolygonElement: {
12406     prototype: SVGPolygonElement;
12407     new(): SVGPolygonElement;
12408 };
12409
12410 /** Provides access to the properties of <polyline> elements, as well as methods to manipulate them. */
12411 interface SVGPolylineElement extends SVGGeometryElement, SVGAnimatedPoints {
12412     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGPolylineElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12413     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12414     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGPolylineElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12415     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12416 }
12417
12418 declare var SVGPolylineElement: {
12419     prototype: SVGPolylineElement;
12420     new(): SVGPolylineElement;
12421 };
12422
12423 /** Corresponds to the preserveAspectRatio attribute, which is available for some of SVG's elements. */
12424 interface SVGPreserveAspectRatio {
12425     align: number;
12426     meetOrSlice: number;
12427     readonly SVG_MEETORSLICE_MEET: number;
12428     readonly SVG_MEETORSLICE_SLICE: number;
12429     readonly SVG_MEETORSLICE_UNKNOWN: number;
12430     readonly SVG_PRESERVEASPECTRATIO_NONE: number;
12431     readonly SVG_PRESERVEASPECTRATIO_UNKNOWN: number;
12432     readonly SVG_PRESERVEASPECTRATIO_XMAXYMAX: number;
12433     readonly SVG_PRESERVEASPECTRATIO_XMAXYMID: number;
12434     readonly SVG_PRESERVEASPECTRATIO_XMAXYMIN: number;
12435     readonly SVG_PRESERVEASPECTRATIO_XMIDYMAX: number;
12436     readonly SVG_PRESERVEASPECTRATIO_XMIDYMID: number;
12437     readonly SVG_PRESERVEASPECTRATIO_XMIDYMIN: number;
12438     readonly SVG_PRESERVEASPECTRATIO_XMINYMAX: number;
12439     readonly SVG_PRESERVEASPECTRATIO_XMINYMID: number;
12440     readonly SVG_PRESERVEASPECTRATIO_XMINYMIN: number;
12441 }
12442
12443 declare var SVGPreserveAspectRatio: {
12444     prototype: SVGPreserveAspectRatio;
12445     new(): SVGPreserveAspectRatio;
12446     readonly SVG_MEETORSLICE_MEET: number;
12447     readonly SVG_MEETORSLICE_SLICE: number;
12448     readonly SVG_MEETORSLICE_UNKNOWN: number;
12449     readonly SVG_PRESERVEASPECTRATIO_NONE: number;
12450     readonly SVG_PRESERVEASPECTRATIO_UNKNOWN: number;
12451     readonly SVG_PRESERVEASPECTRATIO_XMAXYMAX: number;
12452     readonly SVG_PRESERVEASPECTRATIO_XMAXYMID: number;
12453     readonly SVG_PRESERVEASPECTRATIO_XMAXYMIN: number;
12454     readonly SVG_PRESERVEASPECTRATIO_XMIDYMAX: number;
12455     readonly SVG_PRESERVEASPECTRATIO_XMIDYMID: number;
12456     readonly SVG_PRESERVEASPECTRATIO_XMIDYMIN: number;
12457     readonly SVG_PRESERVEASPECTRATIO_XMINYMAX: number;
12458     readonly SVG_PRESERVEASPECTRATIO_XMINYMID: number;
12459     readonly SVG_PRESERVEASPECTRATIO_XMINYMIN: number;
12460 };
12461
12462 /** Corresponds to the <RadialGradient> element. */
12463 interface SVGRadialGradientElement extends SVGGradientElement {
12464     readonly cx: SVGAnimatedLength;
12465     readonly cy: SVGAnimatedLength;
12466     readonly fr: SVGAnimatedLength;
12467     readonly fx: SVGAnimatedLength;
12468     readonly fy: SVGAnimatedLength;
12469     readonly r: SVGAnimatedLength;
12470     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGRadialGradientElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12471     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12472     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGRadialGradientElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12473     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12474 }
12475
12476 declare var SVGRadialGradientElement: {
12477     prototype: SVGRadialGradientElement;
12478     new(): SVGRadialGradientElement;
12479 };
12480
12481 /** Provides access to the properties of <rect> elements, as well as methods to manipulate them. */
12482 interface SVGRectElement extends SVGGeometryElement {
12483     readonly height: SVGAnimatedLength;
12484     readonly rx: SVGAnimatedLength;
12485     readonly ry: SVGAnimatedLength;
12486     readonly width: SVGAnimatedLength;
12487     readonly x: SVGAnimatedLength;
12488     readonly y: SVGAnimatedLength;
12489     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGRectElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12490     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12491     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGRectElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12492     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12493 }
12494
12495 declare var SVGRectElement: {
12496     prototype: SVGRectElement;
12497     new(): SVGRectElement;
12498 };
12499
12500 interface SVGSVGElementEventMap extends SVGElementEventMap, WindowEventHandlersEventMap {
12501 }
12502
12503 /** 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. */
12504 interface SVGSVGElement extends SVGGraphicsElement, SVGFitToViewBox, WindowEventHandlers {
12505     currentScale: number;
12506     readonly currentTranslate: DOMPointReadOnly;
12507     readonly height: SVGAnimatedLength;
12508     readonly width: SVGAnimatedLength;
12509     readonly x: SVGAnimatedLength;
12510     readonly y: SVGAnimatedLength;
12511     animationsPaused(): boolean;
12512     checkEnclosure(element: SVGElement, rect: DOMRectReadOnly): boolean;
12513     checkIntersection(element: SVGElement, rect: DOMRectReadOnly): boolean;
12514     createSVGAngle(): SVGAngle;
12515     createSVGLength(): SVGLength;
12516     createSVGMatrix(): DOMMatrix;
12517     createSVGNumber(): SVGNumber;
12518     createSVGPoint(): DOMPoint;
12519     createSVGRect(): DOMRect;
12520     createSVGTransform(): SVGTransform;
12521     createSVGTransformFromMatrix(matrix?: DOMMatrix2DInit): SVGTransform;
12522     deselectAll(): void;
12523     /** @deprecated */
12524     forceRedraw(): void;
12525     getCurrentTime(): number;
12526     getElementById(elementId: string): Element;
12527     getEnclosureList(rect: DOMRectReadOnly, referenceElement: SVGElement | null): NodeListOf<SVGCircleElement | SVGEllipseElement | SVGImageElement | SVGLineElement | SVGPathElement | SVGPolygonElement | SVGPolylineElement | SVGRectElement | SVGTextElement | SVGUseElement>;
12528     getIntersectionList(rect: DOMRectReadOnly, referenceElement: SVGElement | null): NodeListOf<SVGCircleElement | SVGEllipseElement | SVGImageElement | SVGLineElement | SVGPathElement | SVGPolygonElement | SVGPolylineElement | SVGRectElement | SVGTextElement | SVGUseElement>;
12529     pauseAnimations(): void;
12530     setCurrentTime(seconds: number): void;
12531     /** @deprecated */
12532     suspendRedraw(maxWaitMilliseconds: number): number;
12533     unpauseAnimations(): void;
12534     /** @deprecated */
12535     unsuspendRedraw(suspendHandleID: number): void;
12536     /** @deprecated */
12537     unsuspendRedrawAll(): void;
12538     addEventListener<K extends keyof SVGSVGElementEventMap>(type: K, listener: (this: SVGSVGElement, ev: SVGSVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12539     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12540     removeEventListener<K extends keyof SVGSVGElementEventMap>(type: K, listener: (this: SVGSVGElement, ev: SVGSVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12541     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12542 }
12543
12544 declare var SVGSVGElement: {
12545     prototype: SVGSVGElement;
12546     new(): SVGSVGElement;
12547 };
12548
12549 /** Corresponds to the SVG <script> element. */
12550 interface SVGScriptElement extends SVGElement, SVGURIReference {
12551     type: string;
12552     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGScriptElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12553     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12554     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGScriptElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12555     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12556 }
12557
12558 declare var SVGScriptElement: {
12559     prototype: SVGScriptElement;
12560     new(): SVGScriptElement;
12561 };
12562
12563 interface SVGSetElement extends SVGAnimationElement {
12564     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGSetElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12565     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12566     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGSetElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12567     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12568 }
12569
12570 declare var SVGSetElement: {
12571     prototype: SVGSetElement;
12572     new(): SVGSetElement;
12573 };
12574
12575 /** Corresponds to the <stop> element. */
12576 interface SVGStopElement extends SVGElement {
12577     readonly offset: SVGAnimatedNumber;
12578     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGStopElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12579     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12580     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGStopElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12581     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12582 }
12583
12584 declare var SVGStopElement: {
12585     prototype: SVGStopElement;
12586     new(): SVGStopElement;
12587 };
12588
12589 /** The SVGStringList defines a list of DOMString objects. */
12590 interface SVGStringList {
12591     readonly length: number;
12592     readonly numberOfItems: number;
12593     appendItem(newItem: string): string;
12594     clear(): void;
12595     getItem(index: number): string;
12596     initialize(newItem: string): string;
12597     insertItemBefore(newItem: string, index: number): string;
12598     removeItem(index: number): string;
12599     replaceItem(newItem: string, index: number): string;
12600     [index: number]: string;
12601 }
12602
12603 declare var SVGStringList: {
12604     prototype: SVGStringList;
12605     new(): SVGStringList;
12606 };
12607
12608 /** Corresponds to the SVG <style> element. */
12609 interface SVGStyleElement extends SVGElement, LinkStyle {
12610     disabled: boolean;
12611     media: string;
12612     title: string;
12613     type: string;
12614     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGStyleElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12615     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12616     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGStyleElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12617     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12618 }
12619
12620 declare var SVGStyleElement: {
12621     prototype: SVGStyleElement;
12622     new(): SVGStyleElement;
12623 };
12624
12625 /** Corresponds to the <switch> element. */
12626 interface SVGSwitchElement extends SVGGraphicsElement {
12627     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGSwitchElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12628     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12629     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGSwitchElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12630     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12631 }
12632
12633 declare var SVGSwitchElement: {
12634     prototype: SVGSwitchElement;
12635     new(): SVGSwitchElement;
12636 };
12637
12638 /** Corresponds to the <symbol> element. */
12639 interface SVGSymbolElement extends SVGElement, SVGFitToViewBox {
12640     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGSymbolElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12641     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12642     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGSymbolElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12643     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12644 }
12645
12646 declare var SVGSymbolElement: {
12647     prototype: SVGSymbolElement;
12648     new(): SVGSymbolElement;
12649 };
12650
12651 /** A <tspan> element. */
12652 interface SVGTSpanElement extends SVGTextPositioningElement {
12653     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTSpanElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12654     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12655     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTSpanElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12656     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12657 }
12658
12659 declare var SVGTSpanElement: {
12660     prototype: SVGTSpanElement;
12661     new(): SVGTSpanElement;
12662 };
12663
12664 interface SVGTests {
12665     readonly requiredExtensions: SVGStringList;
12666     readonly systemLanguage: SVGStringList;
12667 }
12668
12669 /** 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. */
12670 interface SVGTextContentElement extends SVGGraphicsElement {
12671     readonly lengthAdjust: SVGAnimatedEnumeration;
12672     readonly textLength: SVGAnimatedLength;
12673     getCharNumAtPosition(point?: DOMPointInit): number;
12674     getComputedTextLength(): number;
12675     getEndPositionOfChar(charnum: number): DOMPoint;
12676     getExtentOfChar(charnum: number): DOMRect;
12677     getNumberOfChars(): number;
12678     getRotationOfChar(charnum: number): number;
12679     getStartPositionOfChar(charnum: number): DOMPoint;
12680     getSubStringLength(charnum: number, nchars: number): number;
12681     /** @deprecated */
12682     selectSubString(charnum: number, nchars: number): void;
12683     readonly LENGTHADJUST_SPACING: number;
12684     readonly LENGTHADJUST_SPACINGANDGLYPHS: number;
12685     readonly LENGTHADJUST_UNKNOWN: number;
12686     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTextContentElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12687     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12688     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTextContentElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12689     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12690 }
12691
12692 declare var SVGTextContentElement: {
12693     prototype: SVGTextContentElement;
12694     new(): SVGTextContentElement;
12695     readonly LENGTHADJUST_SPACING: number;
12696     readonly LENGTHADJUST_SPACINGANDGLYPHS: number;
12697     readonly LENGTHADJUST_UNKNOWN: number;
12698 };
12699
12700 /** Corresponds to the <text> elements. */
12701 interface SVGTextElement extends SVGTextPositioningElement {
12702     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTextElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12703     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12704     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTextElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12705     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12706 }
12707
12708 declare var SVGTextElement: {
12709     prototype: SVGTextElement;
12710     new(): SVGTextElement;
12711 };
12712
12713 /** Corresponds to the <textPath> element. */
12714 interface SVGTextPathElement extends SVGTextContentElement, SVGURIReference {
12715     readonly method: SVGAnimatedEnumeration;
12716     readonly spacing: SVGAnimatedEnumeration;
12717     readonly startOffset: SVGAnimatedLength;
12718     readonly TEXTPATH_METHODTYPE_ALIGN: number;
12719     readonly TEXTPATH_METHODTYPE_STRETCH: number;
12720     readonly TEXTPATH_METHODTYPE_UNKNOWN: number;
12721     readonly TEXTPATH_SPACINGTYPE_AUTO: number;
12722     readonly TEXTPATH_SPACINGTYPE_EXACT: number;
12723     readonly TEXTPATH_SPACINGTYPE_UNKNOWN: number;
12724     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTextPathElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12725     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12726     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTextPathElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12727     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12728 }
12729
12730 declare var SVGTextPathElement: {
12731     prototype: SVGTextPathElement;
12732     new(): SVGTextPathElement;
12733     readonly TEXTPATH_METHODTYPE_ALIGN: number;
12734     readonly TEXTPATH_METHODTYPE_STRETCH: number;
12735     readonly TEXTPATH_METHODTYPE_UNKNOWN: number;
12736     readonly TEXTPATH_SPACINGTYPE_AUTO: number;
12737     readonly TEXTPATH_SPACINGTYPE_EXACT: number;
12738     readonly TEXTPATH_SPACINGTYPE_UNKNOWN: number;
12739 };
12740
12741 /** Implemented by elements that support attributes that position individual text glyphs. It is inherited by SVGTextElement, SVGTSpanElement, SVGTRefElement and SVGAltGlyphElement. */
12742 interface SVGTextPositioningElement extends SVGTextContentElement {
12743     readonly dx: SVGAnimatedLengthList;
12744     readonly dy: SVGAnimatedLengthList;
12745     readonly rotate: SVGAnimatedNumberList;
12746     readonly x: SVGAnimatedLengthList;
12747     readonly y: SVGAnimatedLengthList;
12748     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTextPositioningElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12749     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12750     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTextPositioningElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12751     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12752 }
12753
12754 declare var SVGTextPositioningElement: {
12755     prototype: SVGTextPositioningElement;
12756     new(): SVGTextPositioningElement;
12757 };
12758
12759 /** Corresponds to the <title> element. */
12760 interface SVGTitleElement extends SVGElement {
12761     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTitleElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12762     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12763     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTitleElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12764     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12765 }
12766
12767 declare var SVGTitleElement: {
12768     prototype: SVGTitleElement;
12769     new(): SVGTitleElement;
12770 };
12771
12772 /** 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. */
12773 interface SVGTransform {
12774     readonly angle: number;
12775     readonly matrix: DOMMatrix;
12776     readonly type: number;
12777     setMatrix(matrix?: DOMMatrix2DInit): void;
12778     setRotate(angle: number, cx: number, cy: number): void;
12779     setScale(sx: number, sy: number): void;
12780     setSkewX(angle: number): void;
12781     setSkewY(angle: number): void;
12782     setTranslate(tx: number, ty: number): void;
12783     readonly SVG_TRANSFORM_MATRIX: number;
12784     readonly SVG_TRANSFORM_ROTATE: number;
12785     readonly SVG_TRANSFORM_SCALE: number;
12786     readonly SVG_TRANSFORM_SKEWX: number;
12787     readonly SVG_TRANSFORM_SKEWY: number;
12788     readonly SVG_TRANSFORM_TRANSLATE: number;
12789     readonly SVG_TRANSFORM_UNKNOWN: number;
12790 }
12791
12792 declare var SVGTransform: {
12793     prototype: SVGTransform;
12794     new(): SVGTransform;
12795     readonly SVG_TRANSFORM_MATRIX: number;
12796     readonly SVG_TRANSFORM_ROTATE: number;
12797     readonly SVG_TRANSFORM_SCALE: number;
12798     readonly SVG_TRANSFORM_SKEWX: number;
12799     readonly SVG_TRANSFORM_SKEWY: number;
12800     readonly SVG_TRANSFORM_TRANSLATE: number;
12801     readonly SVG_TRANSFORM_UNKNOWN: number;
12802 };
12803
12804 /** The SVGTransformList defines a list of SVGTransform objects. */
12805 interface SVGTransformList {
12806     readonly length: number;
12807     readonly numberOfItems: number;
12808     appendItem(newItem: SVGTransform): SVGTransform;
12809     clear(): void;
12810     consolidate(): SVGTransform | null;
12811     createSVGTransformFromMatrix(matrix?: DOMMatrix2DInit): SVGTransform;
12812     getItem(index: number): SVGTransform;
12813     initialize(newItem: SVGTransform): SVGTransform;
12814     insertItemBefore(newItem: SVGTransform, index: number): SVGTransform;
12815     removeItem(index: number): SVGTransform;
12816     replaceItem(newItem: SVGTransform, index: number): SVGTransform;
12817     [index: number]: SVGTransform;
12818 }
12819
12820 declare var SVGTransformList: {
12821     prototype: SVGTransformList;
12822     new(): SVGTransformList;
12823 };
12824
12825 interface SVGURIReference {
12826     readonly href: SVGAnimatedString;
12827 }
12828
12829 /** A commonly used set of constants used for reflecting gradientUnits, patternContentUnits and other similar attributes. */
12830 interface SVGUnitTypes {
12831     readonly SVG_UNIT_TYPE_OBJECTBOUNDINGBOX: number;
12832     readonly SVG_UNIT_TYPE_UNKNOWN: number;
12833     readonly SVG_UNIT_TYPE_USERSPACEONUSE: number;
12834 }
12835
12836 declare var SVGUnitTypes: {
12837     prototype: SVGUnitTypes;
12838     new(): SVGUnitTypes;
12839     readonly SVG_UNIT_TYPE_OBJECTBOUNDINGBOX: number;
12840     readonly SVG_UNIT_TYPE_UNKNOWN: number;
12841     readonly SVG_UNIT_TYPE_USERSPACEONUSE: number;
12842 };
12843
12844 /** Corresponds to the <use> element. */
12845 interface SVGUseElement extends SVGGraphicsElement, SVGURIReference {
12846     readonly height: SVGAnimatedLength;
12847     readonly width: SVGAnimatedLength;
12848     readonly x: SVGAnimatedLength;
12849     readonly y: SVGAnimatedLength;
12850     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGUseElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12851     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12852     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGUseElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12853     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12854 }
12855
12856 declare var SVGUseElement: {
12857     prototype: SVGUseElement;
12858     new(): SVGUseElement;
12859 };
12860
12861 /** Provides access to the properties of <view> elements, as well as methods to manipulate them. */
12862 interface SVGViewElement extends SVGElement, SVGFitToViewBox {
12863     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGViewElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12864     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12865     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGViewElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12866     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12867 }
12868
12869 declare var SVGViewElement: {
12870     prototype: SVGViewElement;
12871     new(): SVGViewElement;
12872 };
12873
12874 /** A screen, usually the one on which the current window is being rendered, and is obtained using window.screen. */
12875 interface Screen {
12876     readonly availHeight: number;
12877     readonly availWidth: number;
12878     readonly colorDepth: number;
12879     readonly height: number;
12880     readonly orientation: ScreenOrientation;
12881     readonly pixelDepth: number;
12882     readonly width: number;
12883 }
12884
12885 declare var Screen: {
12886     prototype: Screen;
12887     new(): Screen;
12888 };
12889
12890 interface ScreenOrientationEventMap {
12891     "change": Event;
12892 }
12893
12894 interface ScreenOrientation extends EventTarget {
12895     readonly angle: number;
12896     onchange: ((this: ScreenOrientation, ev: Event) => any) | null;
12897     readonly type: OrientationType;
12898     lock(orientation: OrientationLockType): Promise<void>;
12899     unlock(): void;
12900     addEventListener<K extends keyof ScreenOrientationEventMap>(type: K, listener: (this: ScreenOrientation, ev: ScreenOrientationEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12901     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12902     removeEventListener<K extends keyof ScreenOrientationEventMap>(type: K, listener: (this: ScreenOrientation, ev: ScreenOrientationEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12903     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12904 }
12905
12906 declare var ScreenOrientation: {
12907     prototype: ScreenOrientation;
12908     new(): ScreenOrientation;
12909 };
12910
12911 interface ScriptProcessorNodeEventMap {
12912     "audioprocess": AudioProcessingEvent;
12913 }
12914
12915 /**
12916  * Allows the generation, processing, or analyzing of audio using JavaScript.
12917  * @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).
12918  */
12919 interface ScriptProcessorNode extends AudioNode {
12920     /** @deprecated */
12921     readonly bufferSize: number;
12922     /** @deprecated */
12923     onaudioprocess: ((this: ScriptProcessorNode, ev: AudioProcessingEvent) => any) | null;
12924     addEventListener<K extends keyof ScriptProcessorNodeEventMap>(type: K, listener: (this: ScriptProcessorNode, ev: ScriptProcessorNodeEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12925     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12926     removeEventListener<K extends keyof ScriptProcessorNodeEventMap>(type: K, listener: (this: ScriptProcessorNode, ev: ScriptProcessorNodeEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12927     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12928 }
12929
12930 /** @deprecated */
12931 declare var ScriptProcessorNode: {
12932     prototype: ScriptProcessorNode;
12933     new(): ScriptProcessorNode;
12934 };
12935
12936 /** Inherits from Event, and represents the event object of an event sent on a document or worker when its content security policy is violated. */
12937 interface SecurityPolicyViolationEvent extends Event {
12938     readonly blockedURI: string;
12939     readonly columnNumber: number;
12940     readonly disposition: SecurityPolicyViolationEventDisposition;
12941     readonly documentURI: string;
12942     readonly effectiveDirective: string;
12943     readonly lineNumber: number;
12944     readonly originalPolicy: string;
12945     readonly referrer: string;
12946     readonly sample: string;
12947     readonly sourceFile: string;
12948     readonly statusCode: number;
12949     readonly violatedDirective: string;
12950 }
12951
12952 declare var SecurityPolicyViolationEvent: {
12953     prototype: SecurityPolicyViolationEvent;
12954     new(type: string, eventInitDict?: SecurityPolicyViolationEventInit): SecurityPolicyViolationEvent;
12955 };
12956
12957 /** 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(). */
12958 interface Selection {
12959     readonly anchorNode: Node | null;
12960     readonly anchorOffset: number;
12961     readonly focusNode: Node | null;
12962     readonly focusOffset: number;
12963     readonly isCollapsed: boolean;
12964     readonly rangeCount: number;
12965     readonly type: string;
12966     addRange(range: Range): void;
12967     collapse(node: Node | null, offset?: number): void;
12968     collapseToEnd(): void;
12969     collapseToStart(): void;
12970     containsNode(node: Node, allowPartialContainment?: boolean): boolean;
12971     deleteFromDocument(): void;
12972     empty(): void;
12973     extend(node: Node, offset?: number): void;
12974     getRangeAt(index: number): Range;
12975     removeAllRanges(): void;
12976     removeRange(range: Range): void;
12977     selectAllChildren(node: Node): void;
12978     setBaseAndExtent(anchorNode: Node, anchorOffset: number, focusNode: Node, focusOffset: number): void;
12979     setPosition(node: Node | null, offset?: number): void;
12980     toString(): string;
12981 }
12982
12983 declare var Selection: {
12984     prototype: Selection;
12985     new(): Selection;
12986     toString(): string;
12987 };
12988
12989 interface ServiceWorkerEventMap extends AbstractWorkerEventMap {
12990     "statechange": Event;
12991 }
12992
12993 /**
12994  * 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.
12995  * Available only in secure contexts.
12996  */
12997 interface ServiceWorker extends EventTarget, AbstractWorker {
12998     onstatechange: ((this: ServiceWorker, ev: Event) => any) | null;
12999     readonly scriptURL: string;
13000     readonly state: ServiceWorkerState;
13001     postMessage(message: any, transfer: Transferable[]): void;
13002     postMessage(message: any, options?: StructuredSerializeOptions): void;
13003     addEventListener<K extends keyof ServiceWorkerEventMap>(type: K, listener: (this: ServiceWorker, ev: ServiceWorkerEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13004     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13005     removeEventListener<K extends keyof ServiceWorkerEventMap>(type: K, listener: (this: ServiceWorker, ev: ServiceWorkerEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13006     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13007 }
13008
13009 declare var ServiceWorker: {
13010     prototype: ServiceWorker;
13011     new(): ServiceWorker;
13012 };
13013
13014 interface ServiceWorkerContainerEventMap {
13015     "controllerchange": Event;
13016     "message": MessageEvent;
13017     "messageerror": MessageEvent;
13018 }
13019
13020 /**
13021  * 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.
13022  * Available only in secure contexts.
13023  */
13024 interface ServiceWorkerContainer extends EventTarget {
13025     readonly controller: ServiceWorker | null;
13026     oncontrollerchange: ((this: ServiceWorkerContainer, ev: Event) => any) | null;
13027     onmessage: ((this: ServiceWorkerContainer, ev: MessageEvent) => any) | null;
13028     onmessageerror: ((this: ServiceWorkerContainer, ev: MessageEvent) => any) | null;
13029     readonly ready: Promise<ServiceWorkerRegistration>;
13030     getRegistration(clientURL?: string | URL): Promise<ServiceWorkerRegistration | undefined>;
13031     getRegistrations(): Promise<ReadonlyArray<ServiceWorkerRegistration>>;
13032     register(scriptURL: string | URL, options?: RegistrationOptions): Promise<ServiceWorkerRegistration>;
13033     startMessages(): void;
13034     addEventListener<K extends keyof ServiceWorkerContainerEventMap>(type: K, listener: (this: ServiceWorkerContainer, ev: ServiceWorkerContainerEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13035     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13036     removeEventListener<K extends keyof ServiceWorkerContainerEventMap>(type: K, listener: (this: ServiceWorkerContainer, ev: ServiceWorkerContainerEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13037     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13038 }
13039
13040 declare var ServiceWorkerContainer: {
13041     prototype: ServiceWorkerContainer;
13042     new(): ServiceWorkerContainer;
13043 };
13044
13045 interface ServiceWorkerRegistrationEventMap {
13046     "updatefound": Event;
13047 }
13048
13049 /**
13050  * 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.
13051  * Available only in secure contexts.
13052  */
13053 interface ServiceWorkerRegistration extends EventTarget {
13054     readonly active: ServiceWorker | null;
13055     readonly installing: ServiceWorker | null;
13056     onupdatefound: ((this: ServiceWorkerRegistration, ev: Event) => any) | null;
13057     readonly pushManager: PushManager;
13058     readonly scope: string;
13059     readonly updateViaCache: ServiceWorkerUpdateViaCache;
13060     readonly waiting: ServiceWorker | null;
13061     getNotifications(filter?: GetNotificationOptions): Promise<Notification[]>;
13062     showNotification(title: string, options?: NotificationOptions): Promise<void>;
13063     unregister(): Promise<boolean>;
13064     update(): Promise<void>;
13065     addEventListener<K extends keyof ServiceWorkerRegistrationEventMap>(type: K, listener: (this: ServiceWorkerRegistration, ev: ServiceWorkerRegistrationEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13066     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13067     removeEventListener<K extends keyof ServiceWorkerRegistrationEventMap>(type: K, listener: (this: ServiceWorkerRegistration, ev: ServiceWorkerRegistrationEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13068     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13069 }
13070
13071 declare var ServiceWorkerRegistration: {
13072     prototype: ServiceWorkerRegistration;
13073     new(): ServiceWorkerRegistration;
13074 };
13075
13076 interface ShadowRoot extends DocumentFragment, DocumentOrShadowRoot, InnerHTML {
13077     readonly delegatesFocus: boolean;
13078     readonly host: Element;
13079     readonly mode: ShadowRootMode;
13080     /** Throws a "NotSupportedError" DOMException if context object is a shadow root. */
13081 }
13082
13083 declare var ShadowRoot: {
13084     prototype: ShadowRoot;
13085     new(): ShadowRoot;
13086 };
13087
13088 interface SharedWorker extends EventTarget, AbstractWorker {
13089     /** Returns sharedWorker's MessagePort object which can be used to communicate with the global environment. */
13090     readonly port: MessagePort;
13091     addEventListener<K extends keyof AbstractWorkerEventMap>(type: K, listener: (this: SharedWorker, ev: AbstractWorkerEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13092     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13093     removeEventListener<K extends keyof AbstractWorkerEventMap>(type: K, listener: (this: SharedWorker, ev: AbstractWorkerEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13094     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13095 }
13096
13097 declare var SharedWorker: {
13098     prototype: SharedWorker;
13099     new(scriptURL: string | URL, options?: string | WorkerOptions): SharedWorker;
13100 };
13101
13102 interface Slottable {
13103     readonly assignedSlot: HTMLSlotElement | null;
13104 }
13105
13106 interface SourceBufferEventMap {
13107     "abort": Event;
13108     "error": Event;
13109     "update": Event;
13110     "updateend": Event;
13111     "updatestart": Event;
13112 }
13113
13114 /** 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. */
13115 interface SourceBuffer extends EventTarget {
13116     appendWindowEnd: number;
13117     appendWindowStart: number;
13118     readonly buffered: TimeRanges;
13119     mode: AppendMode;
13120     onabort: ((this: SourceBuffer, ev: Event) => any) | null;
13121     onerror: ((this: SourceBuffer, ev: Event) => any) | null;
13122     onupdate: ((this: SourceBuffer, ev: Event) => any) | null;
13123     onupdateend: ((this: SourceBuffer, ev: Event) => any) | null;
13124     onupdatestart: ((this: SourceBuffer, ev: Event) => any) | null;
13125     timestampOffset: number;
13126     readonly updating: boolean;
13127     abort(): void;
13128     appendBuffer(data: BufferSource): void;
13129     changeType(type: string): void;
13130     remove(start: number, end: number): void;
13131     addEventListener<K extends keyof SourceBufferEventMap>(type: K, listener: (this: SourceBuffer, ev: SourceBufferEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13132     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13133     removeEventListener<K extends keyof SourceBufferEventMap>(type: K, listener: (this: SourceBuffer, ev: SourceBufferEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13134     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13135 }
13136
13137 declare var SourceBuffer: {
13138     prototype: SourceBuffer;
13139     new(): SourceBuffer;
13140 };
13141
13142 interface SourceBufferListEventMap {
13143     "addsourcebuffer": Event;
13144     "removesourcebuffer": Event;
13145 }
13146
13147 /** A simple container list for multiple SourceBuffer objects. */
13148 interface SourceBufferList extends EventTarget {
13149     readonly length: number;
13150     onaddsourcebuffer: ((this: SourceBufferList, ev: Event) => any) | null;
13151     onremovesourcebuffer: ((this: SourceBufferList, ev: Event) => any) | null;
13152     addEventListener<K extends keyof SourceBufferListEventMap>(type: K, listener: (this: SourceBufferList, ev: SourceBufferListEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13153     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13154     removeEventListener<K extends keyof SourceBufferListEventMap>(type: K, listener: (this: SourceBufferList, ev: SourceBufferListEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13155     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13156     [index: number]: SourceBuffer;
13157 }
13158
13159 declare var SourceBufferList: {
13160     prototype: SourceBufferList;
13161     new(): SourceBufferList;
13162 };
13163
13164 interface SpeechRecognitionAlternative {
13165     readonly confidence: number;
13166     readonly transcript: string;
13167 }
13168
13169 declare var SpeechRecognitionAlternative: {
13170     prototype: SpeechRecognitionAlternative;
13171     new(): SpeechRecognitionAlternative;
13172 };
13173
13174 interface SpeechRecognitionResult {
13175     readonly isFinal: boolean;
13176     readonly length: number;
13177     item(index: number): SpeechRecognitionAlternative;
13178     [index: number]: SpeechRecognitionAlternative;
13179 }
13180
13181 declare var SpeechRecognitionResult: {
13182     prototype: SpeechRecognitionResult;
13183     new(): SpeechRecognitionResult;
13184 };
13185
13186 interface SpeechRecognitionResultList {
13187     readonly length: number;
13188     item(index: number): SpeechRecognitionResult;
13189     [index: number]: SpeechRecognitionResult;
13190 }
13191
13192 declare var SpeechRecognitionResultList: {
13193     prototype: SpeechRecognitionResultList;
13194     new(): SpeechRecognitionResultList;
13195 };
13196
13197 interface SpeechSynthesisEventMap {
13198     "voiceschanged": Event;
13199 }
13200
13201 /** 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. */
13202 interface SpeechSynthesis extends EventTarget {
13203     onvoiceschanged: ((this: SpeechSynthesis, ev: Event) => any) | null;
13204     readonly paused: boolean;
13205     readonly pending: boolean;
13206     readonly speaking: boolean;
13207     cancel(): void;
13208     getVoices(): SpeechSynthesisVoice[];
13209     pause(): void;
13210     resume(): void;
13211     speak(utterance: SpeechSynthesisUtterance): void;
13212     addEventListener<K extends keyof SpeechSynthesisEventMap>(type: K, listener: (this: SpeechSynthesis, ev: SpeechSynthesisEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13213     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13214     removeEventListener<K extends keyof SpeechSynthesisEventMap>(type: K, listener: (this: SpeechSynthesis, ev: SpeechSynthesisEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13215     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13216 }
13217
13218 declare var SpeechSynthesis: {
13219     prototype: SpeechSynthesis;
13220     new(): SpeechSynthesis;
13221 };
13222
13223 interface SpeechSynthesisErrorEvent extends SpeechSynthesisEvent {
13224     readonly error: SpeechSynthesisErrorCode;
13225 }
13226
13227 declare var SpeechSynthesisErrorEvent: {
13228     prototype: SpeechSynthesisErrorEvent;
13229     new(type: string, eventInitDict: SpeechSynthesisErrorEventInit): SpeechSynthesisErrorEvent;
13230 };
13231
13232 /** This Web Speech API interface contains information about the current state of SpeechSynthesisUtterance objects that have been processed in the speech service. */
13233 interface SpeechSynthesisEvent extends Event {
13234     readonly charIndex: number;
13235     readonly charLength: number;
13236     readonly elapsedTime: number;
13237     readonly name: string;
13238     readonly utterance: SpeechSynthesisUtterance;
13239 }
13240
13241 declare var SpeechSynthesisEvent: {
13242     prototype: SpeechSynthesisEvent;
13243     new(type: string, eventInitDict: SpeechSynthesisEventInit): SpeechSynthesisEvent;
13244 };
13245
13246 interface SpeechSynthesisUtteranceEventMap {
13247     "boundary": SpeechSynthesisEvent;
13248     "end": SpeechSynthesisEvent;
13249     "error": SpeechSynthesisErrorEvent;
13250     "mark": SpeechSynthesisEvent;
13251     "pause": SpeechSynthesisEvent;
13252     "resume": SpeechSynthesisEvent;
13253     "start": SpeechSynthesisEvent;
13254 }
13255
13256 /** 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.) */
13257 interface SpeechSynthesisUtterance extends EventTarget {
13258     lang: string;
13259     onboundary: ((this: SpeechSynthesisUtterance, ev: SpeechSynthesisEvent) => any) | null;
13260     onend: ((this: SpeechSynthesisUtterance, ev: SpeechSynthesisEvent) => any) | null;
13261     onerror: ((this: SpeechSynthesisUtterance, ev: SpeechSynthesisErrorEvent) => any) | null;
13262     onmark: ((this: SpeechSynthesisUtterance, ev: SpeechSynthesisEvent) => any) | null;
13263     onpause: ((this: SpeechSynthesisUtterance, ev: SpeechSynthesisEvent) => any) | null;
13264     onresume: ((this: SpeechSynthesisUtterance, ev: SpeechSynthesisEvent) => any) | null;
13265     onstart: ((this: SpeechSynthesisUtterance, ev: SpeechSynthesisEvent) => any) | null;
13266     pitch: number;
13267     rate: number;
13268     text: string;
13269     voice: SpeechSynthesisVoice | null;
13270     volume: number;
13271     addEventListener<K extends keyof SpeechSynthesisUtteranceEventMap>(type: K, listener: (this: SpeechSynthesisUtterance, ev: SpeechSynthesisUtteranceEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13272     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13273     removeEventListener<K extends keyof SpeechSynthesisUtteranceEventMap>(type: K, listener: (this: SpeechSynthesisUtterance, ev: SpeechSynthesisUtteranceEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13274     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13275 }
13276
13277 declare var SpeechSynthesisUtterance: {
13278     prototype: SpeechSynthesisUtterance;
13279     new(text?: string): SpeechSynthesisUtterance;
13280 };
13281
13282 /** 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. */
13283 interface SpeechSynthesisVoice {
13284     readonly default: boolean;
13285     readonly lang: string;
13286     readonly localService: boolean;
13287     readonly name: string;
13288     readonly voiceURI: string;
13289 }
13290
13291 declare var SpeechSynthesisVoice: {
13292     prototype: SpeechSynthesisVoice;
13293     new(): SpeechSynthesisVoice;
13294 };
13295
13296 interface StaticRange extends AbstractRange {
13297 }
13298
13299 declare var StaticRange: {
13300     prototype: StaticRange;
13301     new(init: StaticRangeInit): StaticRange;
13302 };
13303
13304 /** 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. */
13305 interface StereoPannerNode extends AudioNode {
13306     readonly pan: AudioParam;
13307 }
13308
13309 declare var StereoPannerNode: {
13310     prototype: StereoPannerNode;
13311     new(context: BaseAudioContext, options?: StereoPannerOptions): StereoPannerNode;
13312 };
13313
13314 /** 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. */
13315 interface Storage {
13316     /** Returns the number of key/value pairs. */
13317     readonly length: number;
13318     /**
13319      * Removes all key/value pairs, if there are any.
13320      *
13321      * Dispatches a storage event on Window objects holding an equivalent Storage object.
13322      */
13323     clear(): void;
13324     /** Returns the current value associated with the given key, or null if the given key does not exist. */
13325     getItem(key: string): string | null;
13326     /** Returns the name of the nth key, or null if n is greater than or equal to the number of key/value pairs. */
13327     key(index: number): string | null;
13328     /**
13329      * Removes the key/value pair with the given key, if a key/value pair with the given key exists.
13330      *
13331      * Dispatches a storage event on Window objects holding an equivalent Storage object.
13332      */
13333     removeItem(key: string): void;
13334     /**
13335      * Sets the value of the pair identified by key to value, creating a new key/value pair if none existed for key previously.
13336      *
13337      * 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.)
13338      *
13339      * Dispatches a storage event on Window objects holding an equivalent Storage object.
13340      */
13341     setItem(key: string, value: string): void;
13342     [name: string]: any;
13343 }
13344
13345 declare var Storage: {
13346     prototype: Storage;
13347     new(): Storage;
13348 };
13349
13350 /** A StorageEvent is sent to a window when a storage area it has access to is changed within the context of another document. */
13351 interface StorageEvent extends Event {
13352     /** Returns the key of the storage item being changed. */
13353     readonly key: string | null;
13354     /** Returns the new value of the key of the storage item whose value is being changed. */
13355     readonly newValue: string | null;
13356     /** Returns the old value of the key of the storage item whose value is being changed. */
13357     readonly oldValue: string | null;
13358     /** Returns the Storage object that was affected. */
13359     readonly storageArea: Storage | null;
13360     /** Returns the URL of the document whose storage item changed. */
13361     readonly url: string;
13362     initStorageEvent(type: string, bubbles?: boolean, cancelable?: boolean, key?: string | null, oldValue?: string | null, newValue?: string | null, url?: string | URL, storageArea?: Storage | null): void;
13363 }
13364
13365 declare var StorageEvent: {
13366     prototype: StorageEvent;
13367     new(type: string, eventInitDict?: StorageEventInit): StorageEvent;
13368 };
13369
13370 /** Available only in secure contexts. */
13371 interface StorageManager {
13372     estimate(): Promise<StorageEstimate>;
13373     persist(): Promise<boolean>;
13374     persisted(): Promise<boolean>;
13375 }
13376
13377 declare var StorageManager: {
13378     prototype: StorageManager;
13379     new(): StorageManager;
13380 };
13381
13382 /** @deprecated */
13383 interface StyleMedia {
13384     type: string;
13385     matchMedium(mediaquery: string): boolean;
13386 }
13387
13388 /** A single style sheet. CSS style sheets will further implement the more specialized CSSStyleSheet interface. */
13389 interface StyleSheet {
13390     disabled: boolean;
13391     readonly href: string | null;
13392     readonly media: MediaList;
13393     readonly ownerNode: Element | ProcessingInstruction | null;
13394     readonly parentStyleSheet: CSSStyleSheet | null;
13395     readonly title: string | null;
13396     readonly type: string;
13397 }
13398
13399 declare var StyleSheet: {
13400     prototype: StyleSheet;
13401     new(): StyleSheet;
13402 };
13403
13404 /** A list of StyleSheet. */
13405 interface StyleSheetList {
13406     readonly length: number;
13407     item(index: number): CSSStyleSheet | null;
13408     [index: number]: CSSStyleSheet;
13409 }
13410
13411 declare var StyleSheetList: {
13412     prototype: StyleSheetList;
13413     new(): StyleSheetList;
13414 };
13415
13416 interface SubmitEvent extends Event {
13417     /** Returns the element representing the submit button that triggered the form submission, or null if the submission was not triggered by a button. */
13418     readonly submitter: HTMLElement | null;
13419 }
13420
13421 declare var SubmitEvent: {
13422     prototype: SubmitEvent;
13423     new(type: string, eventInitDict?: SubmitEventInit): SubmitEvent;
13424 };
13425
13426 /**
13427  * 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).
13428  * Available only in secure contexts.
13429  */
13430 interface SubtleCrypto {
13431     decrypt(algorithm: AlgorithmIdentifier | RsaOaepParams | AesCtrParams | AesCbcParams | AesGcmParams, key: CryptoKey, data: BufferSource): Promise<any>;
13432     deriveBits(algorithm: AlgorithmIdentifier | EcdhKeyDeriveParams | HkdfParams | Pbkdf2Params, baseKey: CryptoKey, length: number): Promise<ArrayBuffer>;
13433     deriveKey(algorithm: AlgorithmIdentifier | EcdhKeyDeriveParams | HkdfParams | Pbkdf2Params, baseKey: CryptoKey, derivedKeyType: AlgorithmIdentifier | AesDerivedKeyParams | HmacImportParams | HkdfParams | Pbkdf2Params, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey>;
13434     digest(algorithm: AlgorithmIdentifier, data: BufferSource): Promise<ArrayBuffer>;
13435     encrypt(algorithm: AlgorithmIdentifier | RsaOaepParams | AesCtrParams | AesCbcParams | AesGcmParams, key: CryptoKey, data: BufferSource): Promise<any>;
13436     exportKey(format: "jwk", key: CryptoKey): Promise<JsonWebKey>;
13437     exportKey(format: Exclude<KeyFormat, "jwk">, key: CryptoKey): Promise<ArrayBuffer>;
13438     generateKey(algorithm: RsaHashedKeyGenParams | EcKeyGenParams, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKeyPair>;
13439     generateKey(algorithm: AesKeyGenParams | HmacKeyGenParams | Pbkdf2Params, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey>;
13440     generateKey(algorithm: AlgorithmIdentifier, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKeyPair | CryptoKey>;
13441     importKey(format: "jwk", keyData: JsonWebKey, algorithm: AlgorithmIdentifier | RsaHashedImportParams | EcKeyImportParams | HmacImportParams | AesKeyAlgorithm, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey>;
13442     importKey(format: Exclude<KeyFormat, "jwk">, keyData: BufferSource, algorithm: AlgorithmIdentifier | RsaHashedImportParams | EcKeyImportParams | HmacImportParams | AesKeyAlgorithm, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey>;
13443     sign(algorithm: AlgorithmIdentifier | RsaPssParams | EcdsaParams, key: CryptoKey, data: BufferSource): Promise<ArrayBuffer>;
13444     unwrapKey(format: KeyFormat, wrappedKey: BufferSource, unwrappingKey: CryptoKey, unwrapAlgorithm: AlgorithmIdentifier | RsaOaepParams | AesCtrParams | AesCbcParams | AesGcmParams, unwrappedKeyAlgorithm: AlgorithmIdentifier | RsaHashedImportParams | EcKeyImportParams | HmacImportParams | AesKeyAlgorithm, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey>;
13445     verify(algorithm: AlgorithmIdentifier | RsaPssParams | EcdsaParams, key: CryptoKey, signature: BufferSource, data: BufferSource): Promise<boolean>;
13446     wrapKey(format: KeyFormat, key: CryptoKey, wrappingKey: CryptoKey, wrapAlgorithm: AlgorithmIdentifier | RsaOaepParams | AesCtrParams | AesCbcParams | AesGcmParams): Promise<ArrayBuffer>;
13447 }
13448
13449 declare var SubtleCrypto: {
13450     prototype: SubtleCrypto;
13451     new(): SubtleCrypto;
13452 };
13453
13454 /** 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. */
13455 interface Text extends CharacterData, Slottable {
13456     /** Returns the combined data of all direct Text node siblings. */
13457     readonly wholeText: string;
13458     /** Splits data at the given offset and returns the remainder as Text node. */
13459     splitText(offset: number): Text;
13460 }
13461
13462 declare var Text: {
13463     prototype: Text;
13464     new(data?: string): Text;
13465 };
13466
13467 /** 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. */
13468 interface TextDecoder extends TextDecoderCommon {
13469     /**
13470      * 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.
13471      *
13472      * ```
13473      * var string = "", decoder = new TextDecoder(encoding), buffer;
13474      * while(buffer = next_chunk()) {
13475      *   string += decoder.decode(buffer, {stream:true});
13476      * }
13477      * string += decoder.decode(); // end-of-queue
13478      * ```
13479      *
13480      * If the error mode is "fatal" and encoding's decoder returns error, throws a TypeError.
13481      */
13482     decode(input?: BufferSource, options?: TextDecodeOptions): string;
13483 }
13484
13485 declare var TextDecoder: {
13486     prototype: TextDecoder;
13487     new(label?: string, options?: TextDecoderOptions): TextDecoder;
13488 };
13489
13490 interface TextDecoderCommon {
13491     /** Returns encoding's name, lowercased. */
13492     readonly encoding: string;
13493     /** Returns true if error mode is "fatal", otherwise false. */
13494     readonly fatal: boolean;
13495     /** Returns the value of ignore BOM. */
13496     readonly ignoreBOM: boolean;
13497 }
13498
13499 interface TextDecoderStream extends GenericTransformStream, TextDecoderCommon {
13500     readonly readable: ReadableStream<string>;
13501     readonly writable: WritableStream<BufferSource>;
13502 }
13503
13504 declare var TextDecoderStream: {
13505     prototype: TextDecoderStream;
13506     new(label?: string, options?: TextDecoderOptions): TextDecoderStream;
13507 };
13508
13509 /** 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. */
13510 interface TextEncoder extends TextEncoderCommon {
13511     /** Returns the result of running UTF-8's encoder. */
13512     encode(input?: string): Uint8Array;
13513     /** 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. */
13514     encodeInto(source: string, destination: Uint8Array): TextEncoderEncodeIntoResult;
13515 }
13516
13517 declare var TextEncoder: {
13518     prototype: TextEncoder;
13519     new(): TextEncoder;
13520 };
13521
13522 interface TextEncoderCommon {
13523     /** Returns "utf-8". */
13524     readonly encoding: string;
13525 }
13526
13527 interface TextEncoderStream extends GenericTransformStream, TextEncoderCommon {
13528     readonly readable: ReadableStream<Uint8Array>;
13529     readonly writable: WritableStream<string>;
13530 }
13531
13532 declare var TextEncoderStream: {
13533     prototype: TextEncoderStream;
13534     new(): TextEncoderStream;
13535 };
13536
13537 /** The dimensions of a piece of text in the canvas, as created by the CanvasRenderingContext2D.measureText() method. */
13538 interface TextMetrics {
13539     /** Returns the measurement described below. */
13540     readonly actualBoundingBoxAscent: number;
13541     /** Returns the measurement described below. */
13542     readonly actualBoundingBoxDescent: number;
13543     /** Returns the measurement described below. */
13544     readonly actualBoundingBoxLeft: number;
13545     /** Returns the measurement described below. */
13546     readonly actualBoundingBoxRight: number;
13547     /** Returns the measurement described below. */
13548     readonly fontBoundingBoxAscent: number;
13549     /** Returns the measurement described below. */
13550     readonly fontBoundingBoxDescent: number;
13551     /** Returns the measurement described below. */
13552     readonly width: number;
13553 }
13554
13555 declare var TextMetrics: {
13556     prototype: TextMetrics;
13557     new(): TextMetrics;
13558 };
13559
13560 interface TextTrackEventMap {
13561     "cuechange": Event;
13562 }
13563
13564 /** This interface also inherits properties from EventTarget. */
13565 interface TextTrack extends EventTarget {
13566     /** 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. */
13567     readonly activeCues: TextTrackCueList | null;
13568     /** Returns the text track list of cues, as a TextTrackCueList object. */
13569     readonly cues: TextTrackCueList | null;
13570     /**
13571      * Returns the ID of the given track.
13572      *
13573      * 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.
13574      *
13575      * For TextTrack objects corresponding to track elements, this is the ID of the track element.
13576      */
13577     readonly id: string;
13578     /** Returns the text track in-band metadata track dispatch type string. */
13579     readonly inBandMetadataTrackDispatchType: string;
13580     /** Returns the text track kind string. */
13581     readonly kind: TextTrackKind;
13582     /** 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). */
13583     readonly label: string;
13584     /** Returns the text track language string. */
13585     readonly language: string;
13586     /**
13587      * Returns the text track mode, represented by a string from the following list:
13588      *
13589      * Can be set, to change the mode.
13590      */
13591     mode: TextTrackMode;
13592     oncuechange: ((this: TextTrack, ev: Event) => any) | null;
13593     /** Adds the given cue to textTrack's text track list of cues. */
13594     addCue(cue: TextTrackCue): void;
13595     /** Removes the given cue from textTrack's text track list of cues. */
13596     removeCue(cue: TextTrackCue): void;
13597     addEventListener<K extends keyof TextTrackEventMap>(type: K, listener: (this: TextTrack, ev: TextTrackEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13598     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13599     removeEventListener<K extends keyof TextTrackEventMap>(type: K, listener: (this: TextTrack, ev: TextTrackEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13600     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13601 }
13602
13603 declare var TextTrack: {
13604     prototype: TextTrack;
13605     new(): TextTrack;
13606 };
13607
13608 interface TextTrackCueEventMap {
13609     "enter": Event;
13610     "exit": Event;
13611 }
13612
13613 /** 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. */
13614 interface TextTrackCue extends EventTarget {
13615     /**
13616      * Returns the text track cue end time, in seconds.
13617      *
13618      * Can be set.
13619      */
13620     endTime: number;
13621     /**
13622      * Returns the text track cue identifier.
13623      *
13624      * Can be set.
13625      */
13626     id: string;
13627     onenter: ((this: TextTrackCue, ev: Event) => any) | null;
13628     onexit: ((this: TextTrackCue, ev: Event) => any) | null;
13629     /**
13630      * Returns true if the text track cue pause-on-exit flag is set, false otherwise.
13631      *
13632      * Can be set.
13633      */
13634     pauseOnExit: boolean;
13635     /**
13636      * Returns the text track cue start time, in seconds.
13637      *
13638      * Can be set.
13639      */
13640     startTime: number;
13641     /** Returns the TextTrack object to which this text track cue belongs, if any, or null otherwise. */
13642     readonly track: TextTrack | null;
13643     addEventListener<K extends keyof TextTrackCueEventMap>(type: K, listener: (this: TextTrackCue, ev: TextTrackCueEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13644     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13645     removeEventListener<K extends keyof TextTrackCueEventMap>(type: K, listener: (this: TextTrackCue, ev: TextTrackCueEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13646     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13647 }
13648
13649 declare var TextTrackCue: {
13650     prototype: TextTrackCue;
13651     new(): TextTrackCue;
13652 };
13653
13654 interface TextTrackCueList {
13655     /** Returns the number of cues in the list. */
13656     readonly length: number;
13657     /**
13658      * Returns the first text track cue (in text track cue order) with text track cue identifier id.
13659      *
13660      * Returns null if none of the cues have the given identifier or if the argument is the empty string.
13661      */
13662     getCueById(id: string): TextTrackCue | null;
13663     [index: number]: TextTrackCue;
13664 }
13665
13666 declare var TextTrackCueList: {
13667     prototype: TextTrackCueList;
13668     new(): TextTrackCueList;
13669 };
13670
13671 interface TextTrackListEventMap {
13672     "addtrack": TrackEvent;
13673     "change": Event;
13674     "removetrack": TrackEvent;
13675 }
13676
13677 interface TextTrackList extends EventTarget {
13678     readonly length: number;
13679     onaddtrack: ((this: TextTrackList, ev: TrackEvent) => any) | null;
13680     onchange: ((this: TextTrackList, ev: Event) => any) | null;
13681     onremovetrack: ((this: TextTrackList, ev: TrackEvent) => any) | null;
13682     getTrackById(id: string): TextTrack | null;
13683     addEventListener<K extends keyof TextTrackListEventMap>(type: K, listener: (this: TextTrackList, ev: TextTrackListEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13684     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13685     removeEventListener<K extends keyof TextTrackListEventMap>(type: K, listener: (this: TextTrackList, ev: TextTrackListEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13686     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13687     [index: number]: TextTrack;
13688 }
13689
13690 declare var TextTrackList: {
13691     prototype: TextTrackList;
13692     new(): TextTrackList;
13693 };
13694
13695 /** 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. */
13696 interface TimeRanges {
13697     /** Returns the number of ranges in the object. */
13698     readonly length: number;
13699     /**
13700      * Returns the time for the end of the range with the given index.
13701      *
13702      * Throws an "IndexSizeError" DOMException if the index is out of range.
13703      */
13704     end(index: number): number;
13705     /**
13706      * Returns the time for the start of the range with the given index.
13707      *
13708      * Throws an "IndexSizeError" DOMException if the index is out of range.
13709      */
13710     start(index: number): number;
13711 }
13712
13713 declare var TimeRanges: {
13714     prototype: TimeRanges;
13715     new(): TimeRanges;
13716 };
13717
13718 /** 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. */
13719 interface Touch {
13720     readonly clientX: number;
13721     readonly clientY: number;
13722     readonly force: number;
13723     readonly identifier: number;
13724     readonly pageX: number;
13725     readonly pageY: number;
13726     readonly radiusX: number;
13727     readonly radiusY: number;
13728     readonly rotationAngle: number;
13729     readonly screenX: number;
13730     readonly screenY: number;
13731     readonly target: EventTarget;
13732 }
13733
13734 declare var Touch: {
13735     prototype: Touch;
13736     new(touchInitDict: TouchInit): Touch;
13737 };
13738
13739 /** 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. */
13740 interface TouchEvent extends UIEvent {
13741     readonly altKey: boolean;
13742     readonly changedTouches: TouchList;
13743     readonly ctrlKey: boolean;
13744     readonly metaKey: boolean;
13745     readonly shiftKey: boolean;
13746     readonly targetTouches: TouchList;
13747     readonly touches: TouchList;
13748 }
13749
13750 declare var TouchEvent: {
13751     prototype: TouchEvent;
13752     new(type: string, eventInitDict?: TouchEventInit): TouchEvent;
13753 };
13754
13755 /** 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. */
13756 interface TouchList {
13757     readonly length: number;
13758     item(index: number): Touch | null;
13759     [index: number]: Touch;
13760 }
13761
13762 declare var TouchList: {
13763     prototype: TouchList;
13764     new(): TouchList;
13765 };
13766
13767 /** 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. */
13768 interface TrackEvent extends Event {
13769     /** Returns the track object (TextTrack, AudioTrack, or VideoTrack) to which the event relates. */
13770     readonly track: TextTrack | null;
13771 }
13772
13773 declare var TrackEvent: {
13774     prototype: TrackEvent;
13775     new(type: string, eventInitDict?: TrackEventInit): TrackEvent;
13776 };
13777
13778 interface TransformStream<I = any, O = any> {
13779     readonly readable: ReadableStream<O>;
13780     readonly writable: WritableStream<I>;
13781 }
13782
13783 declare var TransformStream: {
13784     prototype: TransformStream;
13785     new<I = any, O = any>(transformer?: Transformer<I, O>, writableStrategy?: QueuingStrategy<I>, readableStrategy?: QueuingStrategy<O>): TransformStream<I, O>;
13786 };
13787
13788 interface TransformStreamDefaultController<O = any> {
13789     readonly desiredSize: number | null;
13790     enqueue(chunk?: O): void;
13791     error(reason?: any): void;
13792     terminate(): void;
13793 }
13794
13795 declare var TransformStreamDefaultController: {
13796     prototype: TransformStreamDefaultController;
13797     new(): TransformStreamDefaultController;
13798 };
13799
13800 /** Events providing information related to transitions. */
13801 interface TransitionEvent extends Event {
13802     readonly elapsedTime: number;
13803     readonly propertyName: string;
13804     readonly pseudoElement: string;
13805 }
13806
13807 declare var TransitionEvent: {
13808     prototype: TransitionEvent;
13809     new(type: string, transitionEventInitDict?: TransitionEventInit): TransitionEvent;
13810 };
13811
13812 /** The nodes of a document subtree and a position within them. */
13813 interface TreeWalker {
13814     currentNode: Node;
13815     readonly filter: NodeFilter | null;
13816     readonly root: Node;
13817     readonly whatToShow: number;
13818     firstChild(): Node | null;
13819     lastChild(): Node | null;
13820     nextNode(): Node | null;
13821     nextSibling(): Node | null;
13822     parentNode(): Node | null;
13823     previousNode(): Node | null;
13824     previousSibling(): Node | null;
13825 }
13826
13827 declare var TreeWalker: {
13828     prototype: TreeWalker;
13829     new(): TreeWalker;
13830 };
13831
13832 /** Simple user interface events. */
13833 interface UIEvent extends Event {
13834     readonly detail: number;
13835     readonly view: Window | null;
13836     /** @deprecated */
13837     readonly which: number;
13838     /** @deprecated */
13839     initUIEvent(typeArg: string, bubblesArg?: boolean, cancelableArg?: boolean, viewArg?: Window | null, detailArg?: number): void;
13840 }
13841
13842 declare var UIEvent: {
13843     prototype: UIEvent;
13844     new(type: string, eventInitDict?: UIEventInit): UIEvent;
13845 };
13846
13847 /** The URL interface represents an object providing static methods used for creating object URLs. */
13848 interface URL {
13849     hash: string;
13850     host: string;
13851     hostname: string;
13852     href: string;
13853     toString(): string;
13854     readonly origin: string;
13855     password: string;
13856     pathname: string;
13857     port: string;
13858     protocol: string;
13859     search: string;
13860     readonly searchParams: URLSearchParams;
13861     username: string;
13862     toJSON(): string;
13863 }
13864
13865 declare var URL: {
13866     prototype: URL;
13867     new(url: string | URL, base?: string | URL): URL;
13868     createObjectURL(obj: Blob | MediaSource): string;
13869     revokeObjectURL(url: string): void;
13870 };
13871
13872 type webkitURL = URL;
13873 declare var webkitURL: typeof URL;
13874
13875 interface URLSearchParams {
13876     /** Appends a specified key/value pair as a new search parameter. */
13877     append(name: string, value: string): void;
13878     /** Deletes the given search parameter, and its associated value, from the list of all search parameters. */
13879     delete(name: string): void;
13880     /** Returns the first value associated to the given search parameter. */
13881     get(name: string): string | null;
13882     /** Returns all the values association with a given search parameter. */
13883     getAll(name: string): string[];
13884     /** Returns a Boolean indicating if such a search parameter exists. */
13885     has(name: string): boolean;
13886     /** Sets the value associated to a given search parameter to the given value. If there were several values, delete the others. */
13887     set(name: string, value: string): void;
13888     sort(): void;
13889     /** Returns a string containing a query string suitable for use in a URL. Does not include the question mark. */
13890     toString(): string;
13891     forEach(callbackfn: (value: string, key: string, parent: URLSearchParams) => void, thisArg?: any): void;
13892 }
13893
13894 declare var URLSearchParams: {
13895     prototype: URLSearchParams;
13896     new(init?: string[][] | Record<string, string> | string | URLSearchParams): URLSearchParams;
13897     toString(): string;
13898 };
13899
13900 interface VTTCue extends TextTrackCue {
13901     align: AlignSetting;
13902     line: LineAndPositionSetting;
13903     lineAlign: LineAlignSetting;
13904     position: LineAndPositionSetting;
13905     positionAlign: PositionAlignSetting;
13906     region: VTTRegion | null;
13907     size: number;
13908     snapToLines: boolean;
13909     text: string;
13910     vertical: DirectionSetting;
13911     getCueAsHTML(): DocumentFragment;
13912     addEventListener<K extends keyof TextTrackCueEventMap>(type: K, listener: (this: VTTCue, ev: TextTrackCueEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13913     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13914     removeEventListener<K extends keyof TextTrackCueEventMap>(type: K, listener: (this: VTTCue, ev: TextTrackCueEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13915     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13916 }
13917
13918 declare var VTTCue: {
13919     prototype: VTTCue;
13920     new(startTime: number, endTime: number, text: string): VTTCue;
13921 };
13922
13923 interface VTTRegion {
13924     id: string;
13925     lines: number;
13926     regionAnchorX: number;
13927     regionAnchorY: number;
13928     scroll: ScrollSetting;
13929     viewportAnchorX: number;
13930     viewportAnchorY: number;
13931     width: number;
13932 }
13933
13934 declare var VTTRegion: {
13935     prototype: VTTRegion;
13936     new(): VTTRegion;
13937 };
13938
13939 /** 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. */
13940 interface ValidityState {
13941     readonly badInput: boolean;
13942     readonly customError: boolean;
13943     readonly patternMismatch: boolean;
13944     readonly rangeOverflow: boolean;
13945     readonly rangeUnderflow: boolean;
13946     readonly stepMismatch: boolean;
13947     readonly tooLong: boolean;
13948     readonly tooShort: boolean;
13949     readonly typeMismatch: boolean;
13950     readonly valid: boolean;
13951     readonly valueMissing: boolean;
13952 }
13953
13954 declare var ValidityState: {
13955     prototype: ValidityState;
13956     new(): ValidityState;
13957 };
13958
13959 /** Returned by the HTMLVideoElement.getVideoPlaybackQuality() method and contains metrics that can be used to determine the playback quality of a video. */
13960 interface VideoPlaybackQuality {
13961     /** @deprecated */
13962     readonly corruptedVideoFrames: number;
13963     readonly creationTime: DOMHighResTimeStamp;
13964     readonly droppedVideoFrames: number;
13965     readonly totalVideoFrames: number;
13966 }
13967
13968 declare var VideoPlaybackQuality: {
13969     prototype: VideoPlaybackQuality;
13970     new(): VideoPlaybackQuality;
13971 };
13972
13973 interface VisualViewportEventMap {
13974     "resize": Event;
13975     "scroll": Event;
13976 }
13977
13978 interface VisualViewport extends EventTarget {
13979     readonly height: number;
13980     readonly offsetLeft: number;
13981     readonly offsetTop: number;
13982     onresize: ((this: VisualViewport, ev: Event) => any) | null;
13983     onscroll: ((this: VisualViewport, ev: Event) => any) | null;
13984     readonly pageLeft: number;
13985     readonly pageTop: number;
13986     readonly scale: number;
13987     readonly width: number;
13988     addEventListener<K extends keyof VisualViewportEventMap>(type: K, listener: (this: VisualViewport, ev: VisualViewportEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13989     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13990     removeEventListener<K extends keyof VisualViewportEventMap>(type: K, listener: (this: VisualViewport, ev: VisualViewportEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13991     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13992 }
13993
13994 declare var VisualViewport: {
13995     prototype: VisualViewport;
13996     new(): VisualViewport;
13997 };
13998
13999 interface WEBGL_color_buffer_float {
14000     readonly FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE_EXT: GLenum;
14001     readonly RGBA32F_EXT: GLenum;
14002     readonly UNSIGNED_NORMALIZED_EXT: GLenum;
14003 }
14004
14005 interface WEBGL_compressed_texture_astc {
14006     getSupportedProfiles(): string[];
14007     readonly COMPRESSED_RGBA_ASTC_10x10_KHR: GLenum;
14008     readonly COMPRESSED_RGBA_ASTC_10x5_KHR: GLenum;
14009     readonly COMPRESSED_RGBA_ASTC_10x6_KHR: GLenum;
14010     readonly COMPRESSED_RGBA_ASTC_10x8_KHR: GLenum;
14011     readonly COMPRESSED_RGBA_ASTC_12x10_KHR: GLenum;
14012     readonly COMPRESSED_RGBA_ASTC_12x12_KHR: GLenum;
14013     readonly COMPRESSED_RGBA_ASTC_4x4_KHR: GLenum;
14014     readonly COMPRESSED_RGBA_ASTC_5x4_KHR: GLenum;
14015     readonly COMPRESSED_RGBA_ASTC_5x5_KHR: GLenum;
14016     readonly COMPRESSED_RGBA_ASTC_6x5_KHR: GLenum;
14017     readonly COMPRESSED_RGBA_ASTC_6x6_KHR: GLenum;
14018     readonly COMPRESSED_RGBA_ASTC_8x5_KHR: GLenum;
14019     readonly COMPRESSED_RGBA_ASTC_8x6_KHR: GLenum;
14020     readonly COMPRESSED_RGBA_ASTC_8x8_KHR: GLenum;
14021     readonly COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR: GLenum;
14022     readonly COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR: GLenum;
14023     readonly COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR: GLenum;
14024     readonly COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR: GLenum;
14025     readonly COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR: GLenum;
14026     readonly COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR: GLenum;
14027     readonly COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR: GLenum;
14028     readonly COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR: GLenum;
14029     readonly COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR: GLenum;
14030     readonly COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR: GLenum;
14031     readonly COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR: GLenum;
14032     readonly COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR: GLenum;
14033     readonly COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR: GLenum;
14034     readonly COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR: GLenum;
14035 }
14036
14037 interface WEBGL_compressed_texture_etc {
14038     readonly COMPRESSED_R11_EAC: GLenum;
14039     readonly COMPRESSED_RG11_EAC: GLenum;
14040     readonly COMPRESSED_RGB8_ETC2: GLenum;
14041     readonly COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2: GLenum;
14042     readonly COMPRESSED_RGBA8_ETC2_EAC: GLenum;
14043     readonly COMPRESSED_SIGNED_R11_EAC: GLenum;
14044     readonly COMPRESSED_SIGNED_RG11_EAC: GLenum;
14045     readonly COMPRESSED_SRGB8_ALPHA8_ETC2_EAC: GLenum;
14046     readonly COMPRESSED_SRGB8_ETC2: GLenum;
14047     readonly COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2: GLenum;
14048 }
14049
14050 interface WEBGL_compressed_texture_etc1 {
14051     readonly COMPRESSED_RGB_ETC1_WEBGL: GLenum;
14052 }
14053
14054 interface WEBGL_compressed_texture_pvrtc {
14055     readonly COMPRESSED_RGBA_PVRTC_2BPPV1_IMG: GLenum;
14056     readonly COMPRESSED_RGBA_PVRTC_4BPPV1_IMG: GLenum;
14057     readonly COMPRESSED_RGB_PVRTC_2BPPV1_IMG: GLenum;
14058     readonly COMPRESSED_RGB_PVRTC_4BPPV1_IMG: GLenum;
14059 }
14060
14061 /** The WEBGL_compressed_texture_s3tc extension is part of the WebGL API and exposes four S3TC compressed texture formats. */
14062 interface WEBGL_compressed_texture_s3tc {
14063     readonly COMPRESSED_RGBA_S3TC_DXT1_EXT: GLenum;
14064     readonly COMPRESSED_RGBA_S3TC_DXT3_EXT: GLenum;
14065     readonly COMPRESSED_RGBA_S3TC_DXT5_EXT: GLenum;
14066     readonly COMPRESSED_RGB_S3TC_DXT1_EXT: GLenum;
14067 }
14068
14069 interface WEBGL_compressed_texture_s3tc_srgb {
14070     readonly COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT: GLenum;
14071     readonly COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT: GLenum;
14072     readonly COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT: GLenum;
14073     readonly COMPRESSED_SRGB_S3TC_DXT1_EXT: GLenum;
14074 }
14075
14076 /** 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. */
14077 interface WEBGL_debug_renderer_info {
14078     readonly UNMASKED_RENDERER_WEBGL: GLenum;
14079     readonly UNMASKED_VENDOR_WEBGL: GLenum;
14080 }
14081
14082 interface WEBGL_debug_shaders {
14083     getTranslatedShaderSource(shader: WebGLShader): string;
14084 }
14085
14086 /** The WEBGL_depth_texture extension is part of the WebGL API and defines 2D depth and depth-stencil textures. */
14087 interface WEBGL_depth_texture {
14088     readonly UNSIGNED_INT_24_8_WEBGL: GLenum;
14089 }
14090
14091 interface WEBGL_draw_buffers {
14092     drawBuffersWEBGL(buffers: GLenum[]): void;
14093     readonly COLOR_ATTACHMENT0_WEBGL: GLenum;
14094     readonly COLOR_ATTACHMENT10_WEBGL: GLenum;
14095     readonly COLOR_ATTACHMENT11_WEBGL: GLenum;
14096     readonly COLOR_ATTACHMENT12_WEBGL: GLenum;
14097     readonly COLOR_ATTACHMENT13_WEBGL: GLenum;
14098     readonly COLOR_ATTACHMENT14_WEBGL: GLenum;
14099     readonly COLOR_ATTACHMENT15_WEBGL: GLenum;
14100     readonly COLOR_ATTACHMENT1_WEBGL: GLenum;
14101     readonly COLOR_ATTACHMENT2_WEBGL: GLenum;
14102     readonly COLOR_ATTACHMENT3_WEBGL: GLenum;
14103     readonly COLOR_ATTACHMENT4_WEBGL: GLenum;
14104     readonly COLOR_ATTACHMENT5_WEBGL: GLenum;
14105     readonly COLOR_ATTACHMENT6_WEBGL: GLenum;
14106     readonly COLOR_ATTACHMENT7_WEBGL: GLenum;
14107     readonly COLOR_ATTACHMENT8_WEBGL: GLenum;
14108     readonly COLOR_ATTACHMENT9_WEBGL: GLenum;
14109     readonly DRAW_BUFFER0_WEBGL: GLenum;
14110     readonly DRAW_BUFFER10_WEBGL: GLenum;
14111     readonly DRAW_BUFFER11_WEBGL: GLenum;
14112     readonly DRAW_BUFFER12_WEBGL: GLenum;
14113     readonly DRAW_BUFFER13_WEBGL: GLenum;
14114     readonly DRAW_BUFFER14_WEBGL: GLenum;
14115     readonly DRAW_BUFFER15_WEBGL: GLenum;
14116     readonly DRAW_BUFFER1_WEBGL: GLenum;
14117     readonly DRAW_BUFFER2_WEBGL: GLenum;
14118     readonly DRAW_BUFFER3_WEBGL: GLenum;
14119     readonly DRAW_BUFFER4_WEBGL: GLenum;
14120     readonly DRAW_BUFFER5_WEBGL: GLenum;
14121     readonly DRAW_BUFFER6_WEBGL: GLenum;
14122     readonly DRAW_BUFFER7_WEBGL: GLenum;
14123     readonly DRAW_BUFFER8_WEBGL: GLenum;
14124     readonly DRAW_BUFFER9_WEBGL: GLenum;
14125     readonly MAX_COLOR_ATTACHMENTS_WEBGL: GLenum;
14126     readonly MAX_DRAW_BUFFERS_WEBGL: GLenum;
14127 }
14128
14129 interface WEBGL_lose_context {
14130     loseContext(): void;
14131     restoreContext(): void;
14132 }
14133
14134 /** A WaveShaperNode always has exactly one input and one output. */
14135 interface WaveShaperNode extends AudioNode {
14136     curve: Float32Array | null;
14137     oversample: OverSampleType;
14138 }
14139
14140 declare var WaveShaperNode: {
14141     prototype: WaveShaperNode;
14142     new(context: BaseAudioContext, options?: WaveShaperOptions): WaveShaperNode;
14143 };
14144
14145 interface WebGL2RenderingContext extends WebGL2RenderingContextBase, WebGL2RenderingContextOverloads, WebGLRenderingContextBase {
14146 }
14147
14148 declare var WebGL2RenderingContext: {
14149     prototype: WebGL2RenderingContext;
14150     new(): WebGL2RenderingContext;
14151     readonly ACTIVE_UNIFORM_BLOCKS: GLenum;
14152     readonly ALREADY_SIGNALED: GLenum;
14153     readonly ANY_SAMPLES_PASSED: GLenum;
14154     readonly ANY_SAMPLES_PASSED_CONSERVATIVE: GLenum;
14155     readonly COLOR: GLenum;
14156     readonly COLOR_ATTACHMENT1: GLenum;
14157     readonly COLOR_ATTACHMENT10: GLenum;
14158     readonly COLOR_ATTACHMENT11: GLenum;
14159     readonly COLOR_ATTACHMENT12: GLenum;
14160     readonly COLOR_ATTACHMENT13: GLenum;
14161     readonly COLOR_ATTACHMENT14: GLenum;
14162     readonly COLOR_ATTACHMENT15: GLenum;
14163     readonly COLOR_ATTACHMENT2: GLenum;
14164     readonly COLOR_ATTACHMENT3: GLenum;
14165     readonly COLOR_ATTACHMENT4: GLenum;
14166     readonly COLOR_ATTACHMENT5: GLenum;
14167     readonly COLOR_ATTACHMENT6: GLenum;
14168     readonly COLOR_ATTACHMENT7: GLenum;
14169     readonly COLOR_ATTACHMENT8: GLenum;
14170     readonly COLOR_ATTACHMENT9: GLenum;
14171     readonly COMPARE_REF_TO_TEXTURE: GLenum;
14172     readonly CONDITION_SATISFIED: GLenum;
14173     readonly COPY_READ_BUFFER: GLenum;
14174     readonly COPY_READ_BUFFER_BINDING: GLenum;
14175     readonly COPY_WRITE_BUFFER: GLenum;
14176     readonly COPY_WRITE_BUFFER_BINDING: GLenum;
14177     readonly CURRENT_QUERY: GLenum;
14178     readonly DEPTH: GLenum;
14179     readonly DEPTH24_STENCIL8: GLenum;
14180     readonly DEPTH32F_STENCIL8: GLenum;
14181     readonly DEPTH_COMPONENT24: GLenum;
14182     readonly DEPTH_COMPONENT32F: GLenum;
14183     readonly DRAW_BUFFER0: GLenum;
14184     readonly DRAW_BUFFER1: GLenum;
14185     readonly DRAW_BUFFER10: GLenum;
14186     readonly DRAW_BUFFER11: GLenum;
14187     readonly DRAW_BUFFER12: GLenum;
14188     readonly DRAW_BUFFER13: GLenum;
14189     readonly DRAW_BUFFER14: GLenum;
14190     readonly DRAW_BUFFER15: GLenum;
14191     readonly DRAW_BUFFER2: GLenum;
14192     readonly DRAW_BUFFER3: GLenum;
14193     readonly DRAW_BUFFER4: GLenum;
14194     readonly DRAW_BUFFER5: GLenum;
14195     readonly DRAW_BUFFER6: GLenum;
14196     readonly DRAW_BUFFER7: GLenum;
14197     readonly DRAW_BUFFER8: GLenum;
14198     readonly DRAW_BUFFER9: GLenum;
14199     readonly DRAW_FRAMEBUFFER: GLenum;
14200     readonly DRAW_FRAMEBUFFER_BINDING: GLenum;
14201     readonly DYNAMIC_COPY: GLenum;
14202     readonly DYNAMIC_READ: GLenum;
14203     readonly FLOAT_32_UNSIGNED_INT_24_8_REV: GLenum;
14204     readonly FLOAT_MAT2x3: GLenum;
14205     readonly FLOAT_MAT2x4: GLenum;
14206     readonly FLOAT_MAT3x2: GLenum;
14207     readonly FLOAT_MAT3x4: GLenum;
14208     readonly FLOAT_MAT4x2: GLenum;
14209     readonly FLOAT_MAT4x3: GLenum;
14210     readonly FRAGMENT_SHADER_DERIVATIVE_HINT: GLenum;
14211     readonly FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE: GLenum;
14212     readonly FRAMEBUFFER_ATTACHMENT_BLUE_SIZE: GLenum;
14213     readonly FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING: GLenum;
14214     readonly FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE: GLenum;
14215     readonly FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE: GLenum;
14216     readonly FRAMEBUFFER_ATTACHMENT_GREEN_SIZE: GLenum;
14217     readonly FRAMEBUFFER_ATTACHMENT_RED_SIZE: GLenum;
14218     readonly FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE: GLenum;
14219     readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER: GLenum;
14220     readonly FRAMEBUFFER_DEFAULT: GLenum;
14221     readonly FRAMEBUFFER_INCOMPLETE_MULTISAMPLE: GLenum;
14222     readonly HALF_FLOAT: GLenum;
14223     readonly INTERLEAVED_ATTRIBS: GLenum;
14224     readonly INT_2_10_10_10_REV: GLenum;
14225     readonly INT_SAMPLER_2D: GLenum;
14226     readonly INT_SAMPLER_2D_ARRAY: GLenum;
14227     readonly INT_SAMPLER_3D: GLenum;
14228     readonly INT_SAMPLER_CUBE: GLenum;
14229     readonly INVALID_INDEX: GLenum;
14230     readonly MAX: GLenum;
14231     readonly MAX_3D_TEXTURE_SIZE: GLenum;
14232     readonly MAX_ARRAY_TEXTURE_LAYERS: GLenum;
14233     readonly MAX_CLIENT_WAIT_TIMEOUT_WEBGL: GLenum;
14234     readonly MAX_COLOR_ATTACHMENTS: GLenum;
14235     readonly MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS: GLenum;
14236     readonly MAX_COMBINED_UNIFORM_BLOCKS: GLenum;
14237     readonly MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS: GLenum;
14238     readonly MAX_DRAW_BUFFERS: GLenum;
14239     readonly MAX_ELEMENTS_INDICES: GLenum;
14240     readonly MAX_ELEMENTS_VERTICES: GLenum;
14241     readonly MAX_ELEMENT_INDEX: GLenum;
14242     readonly MAX_FRAGMENT_INPUT_COMPONENTS: GLenum;
14243     readonly MAX_FRAGMENT_UNIFORM_BLOCKS: GLenum;
14244     readonly MAX_FRAGMENT_UNIFORM_COMPONENTS: GLenum;
14245     readonly MAX_PROGRAM_TEXEL_OFFSET: GLenum;
14246     readonly MAX_SAMPLES: GLenum;
14247     readonly MAX_SERVER_WAIT_TIMEOUT: GLenum;
14248     readonly MAX_TEXTURE_LOD_BIAS: GLenum;
14249     readonly MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS: GLenum;
14250     readonly MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS: GLenum;
14251     readonly MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS: GLenum;
14252     readonly MAX_UNIFORM_BLOCK_SIZE: GLenum;
14253     readonly MAX_UNIFORM_BUFFER_BINDINGS: GLenum;
14254     readonly MAX_VARYING_COMPONENTS: GLenum;
14255     readonly MAX_VERTEX_OUTPUT_COMPONENTS: GLenum;
14256     readonly MAX_VERTEX_UNIFORM_BLOCKS: GLenum;
14257     readonly MAX_VERTEX_UNIFORM_COMPONENTS: GLenum;
14258     readonly MIN: GLenum;
14259     readonly MIN_PROGRAM_TEXEL_OFFSET: GLenum;
14260     readonly OBJECT_TYPE: GLenum;
14261     readonly PACK_ROW_LENGTH: GLenum;
14262     readonly PACK_SKIP_PIXELS: GLenum;
14263     readonly PACK_SKIP_ROWS: GLenum;
14264     readonly PIXEL_PACK_BUFFER: GLenum;
14265     readonly PIXEL_PACK_BUFFER_BINDING: GLenum;
14266     readonly PIXEL_UNPACK_BUFFER: GLenum;
14267     readonly PIXEL_UNPACK_BUFFER_BINDING: GLenum;
14268     readonly QUERY_RESULT: GLenum;
14269     readonly QUERY_RESULT_AVAILABLE: GLenum;
14270     readonly R11F_G11F_B10F: GLenum;
14271     readonly R16F: GLenum;
14272     readonly R16I: GLenum;
14273     readonly R16UI: GLenum;
14274     readonly R32F: GLenum;
14275     readonly R32I: GLenum;
14276     readonly R32UI: GLenum;
14277     readonly R8: GLenum;
14278     readonly R8I: GLenum;
14279     readonly R8UI: GLenum;
14280     readonly R8_SNORM: GLenum;
14281     readonly RASTERIZER_DISCARD: GLenum;
14282     readonly READ_BUFFER: GLenum;
14283     readonly READ_FRAMEBUFFER: GLenum;
14284     readonly READ_FRAMEBUFFER_BINDING: GLenum;
14285     readonly RED: GLenum;
14286     readonly RED_INTEGER: GLenum;
14287     readonly RENDERBUFFER_SAMPLES: GLenum;
14288     readonly RG: GLenum;
14289     readonly RG16F: GLenum;
14290     readonly RG16I: GLenum;
14291     readonly RG16UI: GLenum;
14292     readonly RG32F: GLenum;
14293     readonly RG32I: GLenum;
14294     readonly RG32UI: GLenum;
14295     readonly RG8: GLenum;
14296     readonly RG8I: GLenum;
14297     readonly RG8UI: GLenum;
14298     readonly RG8_SNORM: GLenum;
14299     readonly RGB10_A2: GLenum;
14300     readonly RGB10_A2UI: GLenum;
14301     readonly RGB16F: GLenum;
14302     readonly RGB16I: GLenum;
14303     readonly RGB16UI: GLenum;
14304     readonly RGB32F: GLenum;
14305     readonly RGB32I: GLenum;
14306     readonly RGB32UI: GLenum;
14307     readonly RGB8: GLenum;
14308     readonly RGB8I: GLenum;
14309     readonly RGB8UI: GLenum;
14310     readonly RGB8_SNORM: GLenum;
14311     readonly RGB9_E5: GLenum;
14312     readonly RGBA16F: GLenum;
14313     readonly RGBA16I: GLenum;
14314     readonly RGBA16UI: GLenum;
14315     readonly RGBA32F: GLenum;
14316     readonly RGBA32I: GLenum;
14317     readonly RGBA32UI: GLenum;
14318     readonly RGBA8: GLenum;
14319     readonly RGBA8I: GLenum;
14320     readonly RGBA8UI: GLenum;
14321     readonly RGBA8_SNORM: GLenum;
14322     readonly RGBA_INTEGER: GLenum;
14323     readonly RGB_INTEGER: GLenum;
14324     readonly RG_INTEGER: GLenum;
14325     readonly SAMPLER_2D_ARRAY: GLenum;
14326     readonly SAMPLER_2D_ARRAY_SHADOW: GLenum;
14327     readonly SAMPLER_2D_SHADOW: GLenum;
14328     readonly SAMPLER_3D: GLenum;
14329     readonly SAMPLER_BINDING: GLenum;
14330     readonly SAMPLER_CUBE_SHADOW: GLenum;
14331     readonly SEPARATE_ATTRIBS: GLenum;
14332     readonly SIGNALED: GLenum;
14333     readonly SIGNED_NORMALIZED: GLenum;
14334     readonly SRGB: GLenum;
14335     readonly SRGB8: GLenum;
14336     readonly SRGB8_ALPHA8: GLenum;
14337     readonly STATIC_COPY: GLenum;
14338     readonly STATIC_READ: GLenum;
14339     readonly STENCIL: GLenum;
14340     readonly STREAM_COPY: GLenum;
14341     readonly STREAM_READ: GLenum;
14342     readonly SYNC_CONDITION: GLenum;
14343     readonly SYNC_FENCE: GLenum;
14344     readonly SYNC_FLAGS: GLenum;
14345     readonly SYNC_FLUSH_COMMANDS_BIT: GLenum;
14346     readonly SYNC_GPU_COMMANDS_COMPLETE: GLenum;
14347     readonly SYNC_STATUS: GLenum;
14348     readonly TEXTURE_2D_ARRAY: GLenum;
14349     readonly TEXTURE_3D: GLenum;
14350     readonly TEXTURE_BASE_LEVEL: GLenum;
14351     readonly TEXTURE_BINDING_2D_ARRAY: GLenum;
14352     readonly TEXTURE_BINDING_3D: GLenum;
14353     readonly TEXTURE_COMPARE_FUNC: GLenum;
14354     readonly TEXTURE_COMPARE_MODE: GLenum;
14355     readonly TEXTURE_IMMUTABLE_FORMAT: GLenum;
14356     readonly TEXTURE_IMMUTABLE_LEVELS: GLenum;
14357     readonly TEXTURE_MAX_LEVEL: GLenum;
14358     readonly TEXTURE_MAX_LOD: GLenum;
14359     readonly TEXTURE_MIN_LOD: GLenum;
14360     readonly TEXTURE_WRAP_R: GLenum;
14361     readonly TIMEOUT_EXPIRED: GLenum;
14362     readonly TIMEOUT_IGNORED: GLint64;
14363     readonly TRANSFORM_FEEDBACK: GLenum;
14364     readonly TRANSFORM_FEEDBACK_ACTIVE: GLenum;
14365     readonly TRANSFORM_FEEDBACK_BINDING: GLenum;
14366     readonly TRANSFORM_FEEDBACK_BUFFER: GLenum;
14367     readonly TRANSFORM_FEEDBACK_BUFFER_BINDING: GLenum;
14368     readonly TRANSFORM_FEEDBACK_BUFFER_MODE: GLenum;
14369     readonly TRANSFORM_FEEDBACK_BUFFER_SIZE: GLenum;
14370     readonly TRANSFORM_FEEDBACK_BUFFER_START: GLenum;
14371     readonly TRANSFORM_FEEDBACK_PAUSED: GLenum;
14372     readonly TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN: GLenum;
14373     readonly TRANSFORM_FEEDBACK_VARYINGS: GLenum;
14374     readonly UNIFORM_ARRAY_STRIDE: GLenum;
14375     readonly UNIFORM_BLOCK_ACTIVE_UNIFORMS: GLenum;
14376     readonly UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES: GLenum;
14377     readonly UNIFORM_BLOCK_BINDING: GLenum;
14378     readonly UNIFORM_BLOCK_DATA_SIZE: GLenum;
14379     readonly UNIFORM_BLOCK_INDEX: GLenum;
14380     readonly UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER: GLenum;
14381     readonly UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER: GLenum;
14382     readonly UNIFORM_BUFFER: GLenum;
14383     readonly UNIFORM_BUFFER_BINDING: GLenum;
14384     readonly UNIFORM_BUFFER_OFFSET_ALIGNMENT: GLenum;
14385     readonly UNIFORM_BUFFER_SIZE: GLenum;
14386     readonly UNIFORM_BUFFER_START: GLenum;
14387     readonly UNIFORM_IS_ROW_MAJOR: GLenum;
14388     readonly UNIFORM_MATRIX_STRIDE: GLenum;
14389     readonly UNIFORM_OFFSET: GLenum;
14390     readonly UNIFORM_SIZE: GLenum;
14391     readonly UNIFORM_TYPE: GLenum;
14392     readonly UNPACK_IMAGE_HEIGHT: GLenum;
14393     readonly UNPACK_ROW_LENGTH: GLenum;
14394     readonly UNPACK_SKIP_IMAGES: GLenum;
14395     readonly UNPACK_SKIP_PIXELS: GLenum;
14396     readonly UNPACK_SKIP_ROWS: GLenum;
14397     readonly UNSIGNALED: GLenum;
14398     readonly UNSIGNED_INT_10F_11F_11F_REV: GLenum;
14399     readonly UNSIGNED_INT_24_8: GLenum;
14400     readonly UNSIGNED_INT_2_10_10_10_REV: GLenum;
14401     readonly UNSIGNED_INT_5_9_9_9_REV: GLenum;
14402     readonly UNSIGNED_INT_SAMPLER_2D: GLenum;
14403     readonly UNSIGNED_INT_SAMPLER_2D_ARRAY: GLenum;
14404     readonly UNSIGNED_INT_SAMPLER_3D: GLenum;
14405     readonly UNSIGNED_INT_SAMPLER_CUBE: GLenum;
14406     readonly UNSIGNED_INT_VEC2: GLenum;
14407     readonly UNSIGNED_INT_VEC3: GLenum;
14408     readonly UNSIGNED_INT_VEC4: GLenum;
14409     readonly UNSIGNED_NORMALIZED: GLenum;
14410     readonly VERTEX_ARRAY_BINDING: GLenum;
14411     readonly VERTEX_ATTRIB_ARRAY_DIVISOR: GLenum;
14412     readonly VERTEX_ATTRIB_ARRAY_INTEGER: GLenum;
14413     readonly WAIT_FAILED: GLenum;
14414     readonly ACTIVE_ATTRIBUTES: GLenum;
14415     readonly ACTIVE_TEXTURE: GLenum;
14416     readonly ACTIVE_UNIFORMS: GLenum;
14417     readonly ALIASED_LINE_WIDTH_RANGE: GLenum;
14418     readonly ALIASED_POINT_SIZE_RANGE: GLenum;
14419     readonly ALPHA: GLenum;
14420     readonly ALPHA_BITS: GLenum;
14421     readonly ALWAYS: GLenum;
14422     readonly ARRAY_BUFFER: GLenum;
14423     readonly ARRAY_BUFFER_BINDING: GLenum;
14424     readonly ATTACHED_SHADERS: GLenum;
14425     readonly BACK: GLenum;
14426     readonly BLEND: GLenum;
14427     readonly BLEND_COLOR: GLenum;
14428     readonly BLEND_DST_ALPHA: GLenum;
14429     readonly BLEND_DST_RGB: GLenum;
14430     readonly BLEND_EQUATION: GLenum;
14431     readonly BLEND_EQUATION_ALPHA: GLenum;
14432     readonly BLEND_EQUATION_RGB: GLenum;
14433     readonly BLEND_SRC_ALPHA: GLenum;
14434     readonly BLEND_SRC_RGB: GLenum;
14435     readonly BLUE_BITS: GLenum;
14436     readonly BOOL: GLenum;
14437     readonly BOOL_VEC2: GLenum;
14438     readonly BOOL_VEC3: GLenum;
14439     readonly BOOL_VEC4: GLenum;
14440     readonly BROWSER_DEFAULT_WEBGL: GLenum;
14441     readonly BUFFER_SIZE: GLenum;
14442     readonly BUFFER_USAGE: GLenum;
14443     readonly BYTE: GLenum;
14444     readonly CCW: GLenum;
14445     readonly CLAMP_TO_EDGE: GLenum;
14446     readonly COLOR_ATTACHMENT0: GLenum;
14447     readonly COLOR_BUFFER_BIT: GLenum;
14448     readonly COLOR_CLEAR_VALUE: GLenum;
14449     readonly COLOR_WRITEMASK: GLenum;
14450     readonly COMPILE_STATUS: GLenum;
14451     readonly COMPRESSED_TEXTURE_FORMATS: GLenum;
14452     readonly CONSTANT_ALPHA: GLenum;
14453     readonly CONSTANT_COLOR: GLenum;
14454     readonly CONTEXT_LOST_WEBGL: GLenum;
14455     readonly CULL_FACE: GLenum;
14456     readonly CULL_FACE_MODE: GLenum;
14457     readonly CURRENT_PROGRAM: GLenum;
14458     readonly CURRENT_VERTEX_ATTRIB: GLenum;
14459     readonly CW: GLenum;
14460     readonly DECR: GLenum;
14461     readonly DECR_WRAP: GLenum;
14462     readonly DELETE_STATUS: GLenum;
14463     readonly DEPTH_ATTACHMENT: GLenum;
14464     readonly DEPTH_BITS: GLenum;
14465     readonly DEPTH_BUFFER_BIT: GLenum;
14466     readonly DEPTH_CLEAR_VALUE: GLenum;
14467     readonly DEPTH_COMPONENT: GLenum;
14468     readonly DEPTH_COMPONENT16: GLenum;
14469     readonly DEPTH_FUNC: GLenum;
14470     readonly DEPTH_RANGE: GLenum;
14471     readonly DEPTH_STENCIL: GLenum;
14472     readonly DEPTH_STENCIL_ATTACHMENT: GLenum;
14473     readonly DEPTH_TEST: GLenum;
14474     readonly DEPTH_WRITEMASK: GLenum;
14475     readonly DITHER: GLenum;
14476     readonly DONT_CARE: GLenum;
14477     readonly DST_ALPHA: GLenum;
14478     readonly DST_COLOR: GLenum;
14479     readonly DYNAMIC_DRAW: GLenum;
14480     readonly ELEMENT_ARRAY_BUFFER: GLenum;
14481     readonly ELEMENT_ARRAY_BUFFER_BINDING: GLenum;
14482     readonly EQUAL: GLenum;
14483     readonly FASTEST: GLenum;
14484     readonly FLOAT: GLenum;
14485     readonly FLOAT_MAT2: GLenum;
14486     readonly FLOAT_MAT3: GLenum;
14487     readonly FLOAT_MAT4: GLenum;
14488     readonly FLOAT_VEC2: GLenum;
14489     readonly FLOAT_VEC3: GLenum;
14490     readonly FLOAT_VEC4: GLenum;
14491     readonly FRAGMENT_SHADER: GLenum;
14492     readonly FRAMEBUFFER: GLenum;
14493     readonly FRAMEBUFFER_ATTACHMENT_OBJECT_NAME: GLenum;
14494     readonly FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE: GLenum;
14495     readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE: GLenum;
14496     readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL: GLenum;
14497     readonly FRAMEBUFFER_BINDING: GLenum;
14498     readonly FRAMEBUFFER_COMPLETE: GLenum;
14499     readonly FRAMEBUFFER_INCOMPLETE_ATTACHMENT: GLenum;
14500     readonly FRAMEBUFFER_INCOMPLETE_DIMENSIONS: GLenum;
14501     readonly FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: GLenum;
14502     readonly FRAMEBUFFER_UNSUPPORTED: GLenum;
14503     readonly FRONT: GLenum;
14504     readonly FRONT_AND_BACK: GLenum;
14505     readonly FRONT_FACE: GLenum;
14506     readonly FUNC_ADD: GLenum;
14507     readonly FUNC_REVERSE_SUBTRACT: GLenum;
14508     readonly FUNC_SUBTRACT: GLenum;
14509     readonly GENERATE_MIPMAP_HINT: GLenum;
14510     readonly GEQUAL: GLenum;
14511     readonly GREATER: GLenum;
14512     readonly GREEN_BITS: GLenum;
14513     readonly HIGH_FLOAT: GLenum;
14514     readonly HIGH_INT: GLenum;
14515     readonly IMPLEMENTATION_COLOR_READ_FORMAT: GLenum;
14516     readonly IMPLEMENTATION_COLOR_READ_TYPE: GLenum;
14517     readonly INCR: GLenum;
14518     readonly INCR_WRAP: GLenum;
14519     readonly INT: GLenum;
14520     readonly INT_VEC2: GLenum;
14521     readonly INT_VEC3: GLenum;
14522     readonly INT_VEC4: GLenum;
14523     readonly INVALID_ENUM: GLenum;
14524     readonly INVALID_FRAMEBUFFER_OPERATION: GLenum;
14525     readonly INVALID_OPERATION: GLenum;
14526     readonly INVALID_VALUE: GLenum;
14527     readonly INVERT: GLenum;
14528     readonly KEEP: GLenum;
14529     readonly LEQUAL: GLenum;
14530     readonly LESS: GLenum;
14531     readonly LINEAR: GLenum;
14532     readonly LINEAR_MIPMAP_LINEAR: GLenum;
14533     readonly LINEAR_MIPMAP_NEAREST: GLenum;
14534     readonly LINES: GLenum;
14535     readonly LINE_LOOP: GLenum;
14536     readonly LINE_STRIP: GLenum;
14537     readonly LINE_WIDTH: GLenum;
14538     readonly LINK_STATUS: GLenum;
14539     readonly LOW_FLOAT: GLenum;
14540     readonly LOW_INT: GLenum;
14541     readonly LUMINANCE: GLenum;
14542     readonly LUMINANCE_ALPHA: GLenum;
14543     readonly MAX_COMBINED_TEXTURE_IMAGE_UNITS: GLenum;
14544     readonly MAX_CUBE_MAP_TEXTURE_SIZE: GLenum;
14545     readonly MAX_FRAGMENT_UNIFORM_VECTORS: GLenum;
14546     readonly MAX_RENDERBUFFER_SIZE: GLenum;
14547     readonly MAX_TEXTURE_IMAGE_UNITS: GLenum;
14548     readonly MAX_TEXTURE_SIZE: GLenum;
14549     readonly MAX_VARYING_VECTORS: GLenum;
14550     readonly MAX_VERTEX_ATTRIBS: GLenum;
14551     readonly MAX_VERTEX_TEXTURE_IMAGE_UNITS: GLenum;
14552     readonly MAX_VERTEX_UNIFORM_VECTORS: GLenum;
14553     readonly MAX_VIEWPORT_DIMS: GLenum;
14554     readonly MEDIUM_FLOAT: GLenum;
14555     readonly MEDIUM_INT: GLenum;
14556     readonly MIRRORED_REPEAT: GLenum;
14557     readonly NEAREST: GLenum;
14558     readonly NEAREST_MIPMAP_LINEAR: GLenum;
14559     readonly NEAREST_MIPMAP_NEAREST: GLenum;
14560     readonly NEVER: GLenum;
14561     readonly NICEST: GLenum;
14562     readonly NONE: GLenum;
14563     readonly NOTEQUAL: GLenum;
14564     readonly NO_ERROR: GLenum;
14565     readonly ONE: GLenum;
14566     readonly ONE_MINUS_CONSTANT_ALPHA: GLenum;
14567     readonly ONE_MINUS_CONSTANT_COLOR: GLenum;
14568     readonly ONE_MINUS_DST_ALPHA: GLenum;
14569     readonly ONE_MINUS_DST_COLOR: GLenum;
14570     readonly ONE_MINUS_SRC_ALPHA: GLenum;
14571     readonly ONE_MINUS_SRC_COLOR: GLenum;
14572     readonly OUT_OF_MEMORY: GLenum;
14573     readonly PACK_ALIGNMENT: GLenum;
14574     readonly POINTS: GLenum;
14575     readonly POLYGON_OFFSET_FACTOR: GLenum;
14576     readonly POLYGON_OFFSET_FILL: GLenum;
14577     readonly POLYGON_OFFSET_UNITS: GLenum;
14578     readonly RED_BITS: GLenum;
14579     readonly RENDERBUFFER: GLenum;
14580     readonly RENDERBUFFER_ALPHA_SIZE: GLenum;
14581     readonly RENDERBUFFER_BINDING: GLenum;
14582     readonly RENDERBUFFER_BLUE_SIZE: GLenum;
14583     readonly RENDERBUFFER_DEPTH_SIZE: GLenum;
14584     readonly RENDERBUFFER_GREEN_SIZE: GLenum;
14585     readonly RENDERBUFFER_HEIGHT: GLenum;
14586     readonly RENDERBUFFER_INTERNAL_FORMAT: GLenum;
14587     readonly RENDERBUFFER_RED_SIZE: GLenum;
14588     readonly RENDERBUFFER_STENCIL_SIZE: GLenum;
14589     readonly RENDERBUFFER_WIDTH: GLenum;
14590     readonly RENDERER: GLenum;
14591     readonly REPEAT: GLenum;
14592     readonly REPLACE: GLenum;
14593     readonly RGB: GLenum;
14594     readonly RGB565: GLenum;
14595     readonly RGB5_A1: GLenum;
14596     readonly RGBA: GLenum;
14597     readonly RGBA4: GLenum;
14598     readonly SAMPLER_2D: GLenum;
14599     readonly SAMPLER_CUBE: GLenum;
14600     readonly SAMPLES: GLenum;
14601     readonly SAMPLE_ALPHA_TO_COVERAGE: GLenum;
14602     readonly SAMPLE_BUFFERS: GLenum;
14603     readonly SAMPLE_COVERAGE: GLenum;
14604     readonly SAMPLE_COVERAGE_INVERT: GLenum;
14605     readonly SAMPLE_COVERAGE_VALUE: GLenum;
14606     readonly SCISSOR_BOX: GLenum;
14607     readonly SCISSOR_TEST: GLenum;
14608     readonly SHADER_TYPE: GLenum;
14609     readonly SHADING_LANGUAGE_VERSION: GLenum;
14610     readonly SHORT: GLenum;
14611     readonly SRC_ALPHA: GLenum;
14612     readonly SRC_ALPHA_SATURATE: GLenum;
14613     readonly SRC_COLOR: GLenum;
14614     readonly STATIC_DRAW: GLenum;
14615     readonly STENCIL_ATTACHMENT: GLenum;
14616     readonly STENCIL_BACK_FAIL: GLenum;
14617     readonly STENCIL_BACK_FUNC: GLenum;
14618     readonly STENCIL_BACK_PASS_DEPTH_FAIL: GLenum;
14619     readonly STENCIL_BACK_PASS_DEPTH_PASS: GLenum;
14620     readonly STENCIL_BACK_REF: GLenum;
14621     readonly STENCIL_BACK_VALUE_MASK: GLenum;
14622     readonly STENCIL_BACK_WRITEMASK: GLenum;
14623     readonly STENCIL_BITS: GLenum;
14624     readonly STENCIL_BUFFER_BIT: GLenum;
14625     readonly STENCIL_CLEAR_VALUE: GLenum;
14626     readonly STENCIL_FAIL: GLenum;
14627     readonly STENCIL_FUNC: GLenum;
14628     readonly STENCIL_INDEX8: GLenum;
14629     readonly STENCIL_PASS_DEPTH_FAIL: GLenum;
14630     readonly STENCIL_PASS_DEPTH_PASS: GLenum;
14631     readonly STENCIL_REF: GLenum;
14632     readonly STENCIL_TEST: GLenum;
14633     readonly STENCIL_VALUE_MASK: GLenum;
14634     readonly STENCIL_WRITEMASK: GLenum;
14635     readonly STREAM_DRAW: GLenum;
14636     readonly SUBPIXEL_BITS: GLenum;
14637     readonly TEXTURE: GLenum;
14638     readonly TEXTURE0: GLenum;
14639     readonly TEXTURE1: GLenum;
14640     readonly TEXTURE10: GLenum;
14641     readonly TEXTURE11: GLenum;
14642     readonly TEXTURE12: GLenum;
14643     readonly TEXTURE13: GLenum;
14644     readonly TEXTURE14: GLenum;
14645     readonly TEXTURE15: GLenum;
14646     readonly TEXTURE16: GLenum;
14647     readonly TEXTURE17: GLenum;
14648     readonly TEXTURE18: GLenum;
14649     readonly TEXTURE19: GLenum;
14650     readonly TEXTURE2: GLenum;
14651     readonly TEXTURE20: GLenum;
14652     readonly TEXTURE21: GLenum;
14653     readonly TEXTURE22: GLenum;
14654     readonly TEXTURE23: GLenum;
14655     readonly TEXTURE24: GLenum;
14656     readonly TEXTURE25: GLenum;
14657     readonly TEXTURE26: GLenum;
14658     readonly TEXTURE27: GLenum;
14659     readonly TEXTURE28: GLenum;
14660     readonly TEXTURE29: GLenum;
14661     readonly TEXTURE3: GLenum;
14662     readonly TEXTURE30: GLenum;
14663     readonly TEXTURE31: GLenum;
14664     readonly TEXTURE4: GLenum;
14665     readonly TEXTURE5: GLenum;
14666     readonly TEXTURE6: GLenum;
14667     readonly TEXTURE7: GLenum;
14668     readonly TEXTURE8: GLenum;
14669     readonly TEXTURE9: GLenum;
14670     readonly TEXTURE_2D: GLenum;
14671     readonly TEXTURE_BINDING_2D: GLenum;
14672     readonly TEXTURE_BINDING_CUBE_MAP: GLenum;
14673     readonly TEXTURE_CUBE_MAP: GLenum;
14674     readonly TEXTURE_CUBE_MAP_NEGATIVE_X: GLenum;
14675     readonly TEXTURE_CUBE_MAP_NEGATIVE_Y: GLenum;
14676     readonly TEXTURE_CUBE_MAP_NEGATIVE_Z: GLenum;
14677     readonly TEXTURE_CUBE_MAP_POSITIVE_X: GLenum;
14678     readonly TEXTURE_CUBE_MAP_POSITIVE_Y: GLenum;
14679     readonly TEXTURE_CUBE_MAP_POSITIVE_Z: GLenum;
14680     readonly TEXTURE_MAG_FILTER: GLenum;
14681     readonly TEXTURE_MIN_FILTER: GLenum;
14682     readonly TEXTURE_WRAP_S: GLenum;
14683     readonly TEXTURE_WRAP_T: GLenum;
14684     readonly TRIANGLES: GLenum;
14685     readonly TRIANGLE_FAN: GLenum;
14686     readonly TRIANGLE_STRIP: GLenum;
14687     readonly UNPACK_ALIGNMENT: GLenum;
14688     readonly UNPACK_COLORSPACE_CONVERSION_WEBGL: GLenum;
14689     readonly UNPACK_FLIP_Y_WEBGL: GLenum;
14690     readonly UNPACK_PREMULTIPLY_ALPHA_WEBGL: GLenum;
14691     readonly UNSIGNED_BYTE: GLenum;
14692     readonly UNSIGNED_INT: GLenum;
14693     readonly UNSIGNED_SHORT: GLenum;
14694     readonly UNSIGNED_SHORT_4_4_4_4: GLenum;
14695     readonly UNSIGNED_SHORT_5_5_5_1: GLenum;
14696     readonly UNSIGNED_SHORT_5_6_5: GLenum;
14697     readonly VALIDATE_STATUS: GLenum;
14698     readonly VENDOR: GLenum;
14699     readonly VERSION: GLenum;
14700     readonly VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: GLenum;
14701     readonly VERTEX_ATTRIB_ARRAY_ENABLED: GLenum;
14702     readonly VERTEX_ATTRIB_ARRAY_NORMALIZED: GLenum;
14703     readonly VERTEX_ATTRIB_ARRAY_POINTER: GLenum;
14704     readonly VERTEX_ATTRIB_ARRAY_SIZE: GLenum;
14705     readonly VERTEX_ATTRIB_ARRAY_STRIDE: GLenum;
14706     readonly VERTEX_ATTRIB_ARRAY_TYPE: GLenum;
14707     readonly VERTEX_SHADER: GLenum;
14708     readonly VIEWPORT: GLenum;
14709     readonly ZERO: GLenum;
14710 };
14711
14712 interface WebGL2RenderingContextBase {
14713     beginQuery(target: GLenum, query: WebGLQuery): void;
14714     beginTransformFeedback(primitiveMode: GLenum): void;
14715     bindBufferBase(target: GLenum, index: GLuint, buffer: WebGLBuffer | null): void;
14716     bindBufferRange(target: GLenum, index: GLuint, buffer: WebGLBuffer | null, offset: GLintptr, size: GLsizeiptr): void;
14717     bindSampler(unit: GLuint, sampler: WebGLSampler | null): void;
14718     bindTransformFeedback(target: GLenum, tf: WebGLTransformFeedback | null): void;
14719     bindVertexArray(array: WebGLVertexArrayObject | null): void;
14720     blitFramebuffer(srcX0: GLint, srcY0: GLint, srcX1: GLint, srcY1: GLint, dstX0: GLint, dstY0: GLint, dstX1: GLint, dstY1: GLint, mask: GLbitfield, filter: GLenum): void;
14721     clearBufferfi(buffer: GLenum, drawbuffer: GLint, depth: GLfloat, stencil: GLint): void;
14722     clearBufferfv(buffer: GLenum, drawbuffer: GLint, values: Float32List, srcOffset?: GLuint): void;
14723     clearBufferiv(buffer: GLenum, drawbuffer: GLint, values: Int32List, srcOffset?: GLuint): void;
14724     clearBufferuiv(buffer: GLenum, drawbuffer: GLint, values: Uint32List, srcOffset?: GLuint): void;
14725     clientWaitSync(sync: WebGLSync, flags: GLbitfield, timeout: GLuint64): GLenum;
14726     compressedTexImage3D(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, imageSize: GLsizei, offset: GLintptr): void;
14727     compressedTexImage3D(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, srcData: ArrayBufferView, srcOffset?: GLuint, srcLengthOverride?: GLuint): void;
14728     compressedTexSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, imageSize: GLsizei, offset: GLintptr): void;
14729     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;
14730     copyBufferSubData(readTarget: GLenum, writeTarget: GLenum, readOffset: GLintptr, writeOffset: GLintptr, size: GLsizeiptr): void;
14731     copyTexSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, x: GLint, y: GLint, width: GLsizei, height: GLsizei): void;
14732     createQuery(): WebGLQuery | null;
14733     createSampler(): WebGLSampler | null;
14734     createTransformFeedback(): WebGLTransformFeedback | null;
14735     createVertexArray(): WebGLVertexArrayObject | null;
14736     deleteQuery(query: WebGLQuery | null): void;
14737     deleteSampler(sampler: WebGLSampler | null): void;
14738     deleteSync(sync: WebGLSync | null): void;
14739     deleteTransformFeedback(tf: WebGLTransformFeedback | null): void;
14740     deleteVertexArray(vertexArray: WebGLVertexArrayObject | null): void;
14741     drawArraysInstanced(mode: GLenum, first: GLint, count: GLsizei, instanceCount: GLsizei): void;
14742     drawBuffers(buffers: GLenum[]): void;
14743     drawElementsInstanced(mode: GLenum, count: GLsizei, type: GLenum, offset: GLintptr, instanceCount: GLsizei): void;
14744     drawRangeElements(mode: GLenum, start: GLuint, end: GLuint, count: GLsizei, type: GLenum, offset: GLintptr): void;
14745     endQuery(target: GLenum): void;
14746     endTransformFeedback(): void;
14747     fenceSync(condition: GLenum, flags: GLbitfield): WebGLSync | null;
14748     framebufferTextureLayer(target: GLenum, attachment: GLenum, texture: WebGLTexture | null, level: GLint, layer: GLint): void;
14749     getActiveUniformBlockName(program: WebGLProgram, uniformBlockIndex: GLuint): string | null;
14750     getActiveUniformBlockParameter(program: WebGLProgram, uniformBlockIndex: GLuint, pname: GLenum): any;
14751     getActiveUniforms(program: WebGLProgram, uniformIndices: GLuint[], pname: GLenum): any;
14752     getBufferSubData(target: GLenum, srcByteOffset: GLintptr, dstBuffer: ArrayBufferView, dstOffset?: GLuint, length?: GLuint): void;
14753     getFragDataLocation(program: WebGLProgram, name: string): GLint;
14754     getIndexedParameter(target: GLenum, index: GLuint): any;
14755     getInternalformatParameter(target: GLenum, internalformat: GLenum, pname: GLenum): any;
14756     getQuery(target: GLenum, pname: GLenum): WebGLQuery | null;
14757     getQueryParameter(query: WebGLQuery, pname: GLenum): any;
14758     getSamplerParameter(sampler: WebGLSampler, pname: GLenum): any;
14759     getSyncParameter(sync: WebGLSync, pname: GLenum): any;
14760     getTransformFeedbackVarying(program: WebGLProgram, index: GLuint): WebGLActiveInfo | null;
14761     getUniformBlockIndex(program: WebGLProgram, uniformBlockName: string): GLuint;
14762     getUniformIndices(program: WebGLProgram, uniformNames: string[]): GLuint[] | null;
14763     invalidateFramebuffer(target: GLenum, attachments: GLenum[]): void;
14764     invalidateSubFramebuffer(target: GLenum, attachments: GLenum[], x: GLint, y: GLint, width: GLsizei, height: GLsizei): void;
14765     isQuery(query: WebGLQuery | null): GLboolean;
14766     isSampler(sampler: WebGLSampler | null): GLboolean;
14767     isSync(sync: WebGLSync | null): GLboolean;
14768     isTransformFeedback(tf: WebGLTransformFeedback | null): GLboolean;
14769     isVertexArray(vertexArray: WebGLVertexArrayObject | null): GLboolean;
14770     pauseTransformFeedback(): void;
14771     readBuffer(src: GLenum): void;
14772     renderbufferStorageMultisample(target: GLenum, samples: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei): void;
14773     resumeTransformFeedback(): void;
14774     samplerParameterf(sampler: WebGLSampler, pname: GLenum, param: GLfloat): void;
14775     samplerParameteri(sampler: WebGLSampler, pname: GLenum, param: GLint): void;
14776     texImage3D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, format: GLenum, type: GLenum, pboOffset: GLintptr): void;
14777     texImage3D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, format: GLenum, type: GLenum, source: TexImageSource): void;
14778     texImage3D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, format: GLenum, type: GLenum, srcData: ArrayBufferView | null): void;
14779     texImage3D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, format: GLenum, type: GLenum, srcData: ArrayBufferView, srcOffset: GLuint): void;
14780     texStorage2D(target: GLenum, levels: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei): void;
14781     texStorage3D(target: GLenum, levels: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei): void;
14782     texSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, type: GLenum, pboOffset: GLintptr): void;
14783     texSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, type: GLenum, source: TexImageSource): void;
14784     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;
14785     transformFeedbackVaryings(program: WebGLProgram, varyings: string[], bufferMode: GLenum): void;
14786     uniform1ui(location: WebGLUniformLocation | null, v0: GLuint): void;
14787     uniform1uiv(location: WebGLUniformLocation | null, data: Uint32List, srcOffset?: GLuint, srcLength?: GLuint): void;
14788     uniform2ui(location: WebGLUniformLocation | null, v0: GLuint, v1: GLuint): void;
14789     uniform2uiv(location: WebGLUniformLocation | null, data: Uint32List, srcOffset?: GLuint, srcLength?: GLuint): void;
14790     uniform3ui(location: WebGLUniformLocation | null, v0: GLuint, v1: GLuint, v2: GLuint): void;
14791     uniform3uiv(location: WebGLUniformLocation | null, data: Uint32List, srcOffset?: GLuint, srcLength?: GLuint): void;
14792     uniform4ui(location: WebGLUniformLocation | null, v0: GLuint, v1: GLuint, v2: GLuint, v3: GLuint): void;
14793     uniform4uiv(location: WebGLUniformLocation | null, data: Uint32List, srcOffset?: GLuint, srcLength?: GLuint): void;
14794     uniformBlockBinding(program: WebGLProgram, uniformBlockIndex: GLuint, uniformBlockBinding: GLuint): void;
14795     uniformMatrix2x3fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
14796     uniformMatrix2x4fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
14797     uniformMatrix3x2fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
14798     uniformMatrix3x4fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
14799     uniformMatrix4x2fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
14800     uniformMatrix4x3fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
14801     vertexAttribDivisor(index: GLuint, divisor: GLuint): void;
14802     vertexAttribI4i(index: GLuint, x: GLint, y: GLint, z: GLint, w: GLint): void;
14803     vertexAttribI4iv(index: GLuint, values: Int32List): void;
14804     vertexAttribI4ui(index: GLuint, x: GLuint, y: GLuint, z: GLuint, w: GLuint): void;
14805     vertexAttribI4uiv(index: GLuint, values: Uint32List): void;
14806     vertexAttribIPointer(index: GLuint, size: GLint, type: GLenum, stride: GLsizei, offset: GLintptr): void;
14807     waitSync(sync: WebGLSync, flags: GLbitfield, timeout: GLint64): void;
14808     readonly ACTIVE_UNIFORM_BLOCKS: GLenum;
14809     readonly ALREADY_SIGNALED: GLenum;
14810     readonly ANY_SAMPLES_PASSED: GLenum;
14811     readonly ANY_SAMPLES_PASSED_CONSERVATIVE: GLenum;
14812     readonly COLOR: GLenum;
14813     readonly COLOR_ATTACHMENT1: GLenum;
14814     readonly COLOR_ATTACHMENT10: GLenum;
14815     readonly COLOR_ATTACHMENT11: GLenum;
14816     readonly COLOR_ATTACHMENT12: GLenum;
14817     readonly COLOR_ATTACHMENT13: GLenum;
14818     readonly COLOR_ATTACHMENT14: GLenum;
14819     readonly COLOR_ATTACHMENT15: GLenum;
14820     readonly COLOR_ATTACHMENT2: GLenum;
14821     readonly COLOR_ATTACHMENT3: GLenum;
14822     readonly COLOR_ATTACHMENT4: GLenum;
14823     readonly COLOR_ATTACHMENT5: GLenum;
14824     readonly COLOR_ATTACHMENT6: GLenum;
14825     readonly COLOR_ATTACHMENT7: GLenum;
14826     readonly COLOR_ATTACHMENT8: GLenum;
14827     readonly COLOR_ATTACHMENT9: GLenum;
14828     readonly COMPARE_REF_TO_TEXTURE: GLenum;
14829     readonly CONDITION_SATISFIED: GLenum;
14830     readonly COPY_READ_BUFFER: GLenum;
14831     readonly COPY_READ_BUFFER_BINDING: GLenum;
14832     readonly COPY_WRITE_BUFFER: GLenum;
14833     readonly COPY_WRITE_BUFFER_BINDING: GLenum;
14834     readonly CURRENT_QUERY: GLenum;
14835     readonly DEPTH: GLenum;
14836     readonly DEPTH24_STENCIL8: GLenum;
14837     readonly DEPTH32F_STENCIL8: GLenum;
14838     readonly DEPTH_COMPONENT24: GLenum;
14839     readonly DEPTH_COMPONENT32F: GLenum;
14840     readonly DRAW_BUFFER0: GLenum;
14841     readonly DRAW_BUFFER1: GLenum;
14842     readonly DRAW_BUFFER10: GLenum;
14843     readonly DRAW_BUFFER11: GLenum;
14844     readonly DRAW_BUFFER12: GLenum;
14845     readonly DRAW_BUFFER13: GLenum;
14846     readonly DRAW_BUFFER14: GLenum;
14847     readonly DRAW_BUFFER15: GLenum;
14848     readonly DRAW_BUFFER2: GLenum;
14849     readonly DRAW_BUFFER3: GLenum;
14850     readonly DRAW_BUFFER4: GLenum;
14851     readonly DRAW_BUFFER5: GLenum;
14852     readonly DRAW_BUFFER6: GLenum;
14853     readonly DRAW_BUFFER7: GLenum;
14854     readonly DRAW_BUFFER8: GLenum;
14855     readonly DRAW_BUFFER9: GLenum;
14856     readonly DRAW_FRAMEBUFFER: GLenum;
14857     readonly DRAW_FRAMEBUFFER_BINDING: GLenum;
14858     readonly DYNAMIC_COPY: GLenum;
14859     readonly DYNAMIC_READ: GLenum;
14860     readonly FLOAT_32_UNSIGNED_INT_24_8_REV: GLenum;
14861     readonly FLOAT_MAT2x3: GLenum;
14862     readonly FLOAT_MAT2x4: GLenum;
14863     readonly FLOAT_MAT3x2: GLenum;
14864     readonly FLOAT_MAT3x4: GLenum;
14865     readonly FLOAT_MAT4x2: GLenum;
14866     readonly FLOAT_MAT4x3: GLenum;
14867     readonly FRAGMENT_SHADER_DERIVATIVE_HINT: GLenum;
14868     readonly FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE: GLenum;
14869     readonly FRAMEBUFFER_ATTACHMENT_BLUE_SIZE: GLenum;
14870     readonly FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING: GLenum;
14871     readonly FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE: GLenum;
14872     readonly FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE: GLenum;
14873     readonly FRAMEBUFFER_ATTACHMENT_GREEN_SIZE: GLenum;
14874     readonly FRAMEBUFFER_ATTACHMENT_RED_SIZE: GLenum;
14875     readonly FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE: GLenum;
14876     readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER: GLenum;
14877     readonly FRAMEBUFFER_DEFAULT: GLenum;
14878     readonly FRAMEBUFFER_INCOMPLETE_MULTISAMPLE: GLenum;
14879     readonly HALF_FLOAT: GLenum;
14880     readonly INTERLEAVED_ATTRIBS: GLenum;
14881     readonly INT_2_10_10_10_REV: GLenum;
14882     readonly INT_SAMPLER_2D: GLenum;
14883     readonly INT_SAMPLER_2D_ARRAY: GLenum;
14884     readonly INT_SAMPLER_3D: GLenum;
14885     readonly INT_SAMPLER_CUBE: GLenum;
14886     readonly INVALID_INDEX: GLenum;
14887     readonly MAX: GLenum;
14888     readonly MAX_3D_TEXTURE_SIZE: GLenum;
14889     readonly MAX_ARRAY_TEXTURE_LAYERS: GLenum;
14890     readonly MAX_CLIENT_WAIT_TIMEOUT_WEBGL: GLenum;
14891     readonly MAX_COLOR_ATTACHMENTS: GLenum;
14892     readonly MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS: GLenum;
14893     readonly MAX_COMBINED_UNIFORM_BLOCKS: GLenum;
14894     readonly MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS: GLenum;
14895     readonly MAX_DRAW_BUFFERS: GLenum;
14896     readonly MAX_ELEMENTS_INDICES: GLenum;
14897     readonly MAX_ELEMENTS_VERTICES: GLenum;
14898     readonly MAX_ELEMENT_INDEX: GLenum;
14899     readonly MAX_FRAGMENT_INPUT_COMPONENTS: GLenum;
14900     readonly MAX_FRAGMENT_UNIFORM_BLOCKS: GLenum;
14901     readonly MAX_FRAGMENT_UNIFORM_COMPONENTS: GLenum;
14902     readonly MAX_PROGRAM_TEXEL_OFFSET: GLenum;
14903     readonly MAX_SAMPLES: GLenum;
14904     readonly MAX_SERVER_WAIT_TIMEOUT: GLenum;
14905     readonly MAX_TEXTURE_LOD_BIAS: GLenum;
14906     readonly MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS: GLenum;
14907     readonly MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS: GLenum;
14908     readonly MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS: GLenum;
14909     readonly MAX_UNIFORM_BLOCK_SIZE: GLenum;
14910     readonly MAX_UNIFORM_BUFFER_BINDINGS: GLenum;
14911     readonly MAX_VARYING_COMPONENTS: GLenum;
14912     readonly MAX_VERTEX_OUTPUT_COMPONENTS: GLenum;
14913     readonly MAX_VERTEX_UNIFORM_BLOCKS: GLenum;
14914     readonly MAX_VERTEX_UNIFORM_COMPONENTS: GLenum;
14915     readonly MIN: GLenum;
14916     readonly MIN_PROGRAM_TEXEL_OFFSET: GLenum;
14917     readonly OBJECT_TYPE: GLenum;
14918     readonly PACK_ROW_LENGTH: GLenum;
14919     readonly PACK_SKIP_PIXELS: GLenum;
14920     readonly PACK_SKIP_ROWS: GLenum;
14921     readonly PIXEL_PACK_BUFFER: GLenum;
14922     readonly PIXEL_PACK_BUFFER_BINDING: GLenum;
14923     readonly PIXEL_UNPACK_BUFFER: GLenum;
14924     readonly PIXEL_UNPACK_BUFFER_BINDING: GLenum;
14925     readonly QUERY_RESULT: GLenum;
14926     readonly QUERY_RESULT_AVAILABLE: GLenum;
14927     readonly R11F_G11F_B10F: GLenum;
14928     readonly R16F: GLenum;
14929     readonly R16I: GLenum;
14930     readonly R16UI: GLenum;
14931     readonly R32F: GLenum;
14932     readonly R32I: GLenum;
14933     readonly R32UI: GLenum;
14934     readonly R8: GLenum;
14935     readonly R8I: GLenum;
14936     readonly R8UI: GLenum;
14937     readonly R8_SNORM: GLenum;
14938     readonly RASTERIZER_DISCARD: GLenum;
14939     readonly READ_BUFFER: GLenum;
14940     readonly READ_FRAMEBUFFER: GLenum;
14941     readonly READ_FRAMEBUFFER_BINDING: GLenum;
14942     readonly RED: GLenum;
14943     readonly RED_INTEGER: GLenum;
14944     readonly RENDERBUFFER_SAMPLES: GLenum;
14945     readonly RG: GLenum;
14946     readonly RG16F: GLenum;
14947     readonly RG16I: GLenum;
14948     readonly RG16UI: GLenum;
14949     readonly RG32F: GLenum;
14950     readonly RG32I: GLenum;
14951     readonly RG32UI: GLenum;
14952     readonly RG8: GLenum;
14953     readonly RG8I: GLenum;
14954     readonly RG8UI: GLenum;
14955     readonly RG8_SNORM: GLenum;
14956     readonly RGB10_A2: GLenum;
14957     readonly RGB10_A2UI: GLenum;
14958     readonly RGB16F: GLenum;
14959     readonly RGB16I: GLenum;
14960     readonly RGB16UI: GLenum;
14961     readonly RGB32F: GLenum;
14962     readonly RGB32I: GLenum;
14963     readonly RGB32UI: GLenum;
14964     readonly RGB8: GLenum;
14965     readonly RGB8I: GLenum;
14966     readonly RGB8UI: GLenum;
14967     readonly RGB8_SNORM: GLenum;
14968     readonly RGB9_E5: GLenum;
14969     readonly RGBA16F: GLenum;
14970     readonly RGBA16I: GLenum;
14971     readonly RGBA16UI: GLenum;
14972     readonly RGBA32F: GLenum;
14973     readonly RGBA32I: GLenum;
14974     readonly RGBA32UI: GLenum;
14975     readonly RGBA8: GLenum;
14976     readonly RGBA8I: GLenum;
14977     readonly RGBA8UI: GLenum;
14978     readonly RGBA8_SNORM: GLenum;
14979     readonly RGBA_INTEGER: GLenum;
14980     readonly RGB_INTEGER: GLenum;
14981     readonly RG_INTEGER: GLenum;
14982     readonly SAMPLER_2D_ARRAY: GLenum;
14983     readonly SAMPLER_2D_ARRAY_SHADOW: GLenum;
14984     readonly SAMPLER_2D_SHADOW: GLenum;
14985     readonly SAMPLER_3D: GLenum;
14986     readonly SAMPLER_BINDING: GLenum;
14987     readonly SAMPLER_CUBE_SHADOW: GLenum;
14988     readonly SEPARATE_ATTRIBS: GLenum;
14989     readonly SIGNALED: GLenum;
14990     readonly SIGNED_NORMALIZED: GLenum;
14991     readonly SRGB: GLenum;
14992     readonly SRGB8: GLenum;
14993     readonly SRGB8_ALPHA8: GLenum;
14994     readonly STATIC_COPY: GLenum;
14995     readonly STATIC_READ: GLenum;
14996     readonly STENCIL: GLenum;
14997     readonly STREAM_COPY: GLenum;
14998     readonly STREAM_READ: GLenum;
14999     readonly SYNC_CONDITION: GLenum;
15000     readonly SYNC_FENCE: GLenum;
15001     readonly SYNC_FLAGS: GLenum;
15002     readonly SYNC_FLUSH_COMMANDS_BIT: GLenum;
15003     readonly SYNC_GPU_COMMANDS_COMPLETE: GLenum;
15004     readonly SYNC_STATUS: GLenum;
15005     readonly TEXTURE_2D_ARRAY: GLenum;
15006     readonly TEXTURE_3D: GLenum;
15007     readonly TEXTURE_BASE_LEVEL: GLenum;
15008     readonly TEXTURE_BINDING_2D_ARRAY: GLenum;
15009     readonly TEXTURE_BINDING_3D: GLenum;
15010     readonly TEXTURE_COMPARE_FUNC: GLenum;
15011     readonly TEXTURE_COMPARE_MODE: GLenum;
15012     readonly TEXTURE_IMMUTABLE_FORMAT: GLenum;
15013     readonly TEXTURE_IMMUTABLE_LEVELS: GLenum;
15014     readonly TEXTURE_MAX_LEVEL: GLenum;
15015     readonly TEXTURE_MAX_LOD: GLenum;
15016     readonly TEXTURE_MIN_LOD: GLenum;
15017     readonly TEXTURE_WRAP_R: GLenum;
15018     readonly TIMEOUT_EXPIRED: GLenum;
15019     readonly TIMEOUT_IGNORED: GLint64;
15020     readonly TRANSFORM_FEEDBACK: GLenum;
15021     readonly TRANSFORM_FEEDBACK_ACTIVE: GLenum;
15022     readonly TRANSFORM_FEEDBACK_BINDING: GLenum;
15023     readonly TRANSFORM_FEEDBACK_BUFFER: GLenum;
15024     readonly TRANSFORM_FEEDBACK_BUFFER_BINDING: GLenum;
15025     readonly TRANSFORM_FEEDBACK_BUFFER_MODE: GLenum;
15026     readonly TRANSFORM_FEEDBACK_BUFFER_SIZE: GLenum;
15027     readonly TRANSFORM_FEEDBACK_BUFFER_START: GLenum;
15028     readonly TRANSFORM_FEEDBACK_PAUSED: GLenum;
15029     readonly TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN: GLenum;
15030     readonly TRANSFORM_FEEDBACK_VARYINGS: GLenum;
15031     readonly UNIFORM_ARRAY_STRIDE: GLenum;
15032     readonly UNIFORM_BLOCK_ACTIVE_UNIFORMS: GLenum;
15033     readonly UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES: GLenum;
15034     readonly UNIFORM_BLOCK_BINDING: GLenum;
15035     readonly UNIFORM_BLOCK_DATA_SIZE: GLenum;
15036     readonly UNIFORM_BLOCK_INDEX: GLenum;
15037     readonly UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER: GLenum;
15038     readonly UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER: GLenum;
15039     readonly UNIFORM_BUFFER: GLenum;
15040     readonly UNIFORM_BUFFER_BINDING: GLenum;
15041     readonly UNIFORM_BUFFER_OFFSET_ALIGNMENT: GLenum;
15042     readonly UNIFORM_BUFFER_SIZE: GLenum;
15043     readonly UNIFORM_BUFFER_START: GLenum;
15044     readonly UNIFORM_IS_ROW_MAJOR: GLenum;
15045     readonly UNIFORM_MATRIX_STRIDE: GLenum;
15046     readonly UNIFORM_OFFSET: GLenum;
15047     readonly UNIFORM_SIZE: GLenum;
15048     readonly UNIFORM_TYPE: GLenum;
15049     readonly UNPACK_IMAGE_HEIGHT: GLenum;
15050     readonly UNPACK_ROW_LENGTH: GLenum;
15051     readonly UNPACK_SKIP_IMAGES: GLenum;
15052     readonly UNPACK_SKIP_PIXELS: GLenum;
15053     readonly UNPACK_SKIP_ROWS: GLenum;
15054     readonly UNSIGNALED: GLenum;
15055     readonly UNSIGNED_INT_10F_11F_11F_REV: GLenum;
15056     readonly UNSIGNED_INT_24_8: GLenum;
15057     readonly UNSIGNED_INT_2_10_10_10_REV: GLenum;
15058     readonly UNSIGNED_INT_5_9_9_9_REV: GLenum;
15059     readonly UNSIGNED_INT_SAMPLER_2D: GLenum;
15060     readonly UNSIGNED_INT_SAMPLER_2D_ARRAY: GLenum;
15061     readonly UNSIGNED_INT_SAMPLER_3D: GLenum;
15062     readonly UNSIGNED_INT_SAMPLER_CUBE: GLenum;
15063     readonly UNSIGNED_INT_VEC2: GLenum;
15064     readonly UNSIGNED_INT_VEC3: GLenum;
15065     readonly UNSIGNED_INT_VEC4: GLenum;
15066     readonly UNSIGNED_NORMALIZED: GLenum;
15067     readonly VERTEX_ARRAY_BINDING: GLenum;
15068     readonly VERTEX_ATTRIB_ARRAY_DIVISOR: GLenum;
15069     readonly VERTEX_ATTRIB_ARRAY_INTEGER: GLenum;
15070     readonly WAIT_FAILED: GLenum;
15071 }
15072
15073 interface WebGL2RenderingContextOverloads {
15074     bufferData(target: GLenum, size: GLsizeiptr, usage: GLenum): void;
15075     bufferData(target: GLenum, srcData: BufferSource | null, usage: GLenum): void;
15076     bufferData(target: GLenum, srcData: ArrayBufferView, usage: GLenum, srcOffset: GLuint, length?: GLuint): void;
15077     bufferSubData(target: GLenum, dstByteOffset: GLintptr, srcData: BufferSource): void;
15078     bufferSubData(target: GLenum, dstByteOffset: GLintptr, srcData: ArrayBufferView, srcOffset: GLuint, length?: GLuint): void;
15079     compressedTexImage2D(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, border: GLint, imageSize: GLsizei, offset: GLintptr): void;
15080     compressedTexImage2D(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, border: GLint, srcData: ArrayBufferView, srcOffset?: GLuint, srcLengthOverride?: GLuint): void;
15081     compressedTexSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, imageSize: GLsizei, offset: GLintptr): void;
15082     compressedTexSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, srcData: ArrayBufferView, srcOffset?: GLuint, srcLengthOverride?: GLuint): void;
15083     readPixels(x: GLint, y: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, dstData: ArrayBufferView | null): void;
15084     readPixels(x: GLint, y: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, offset: GLintptr): void;
15085     readPixels(x: GLint, y: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, dstData: ArrayBufferView, dstOffset: GLuint): void;
15086     texImage2D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, border: GLint, format: GLenum, type: GLenum, pixels: ArrayBufferView | null): void;
15087     texImage2D(target: GLenum, level: GLint, internalformat: GLint, format: GLenum, type: GLenum, source: TexImageSource): void;
15088     texImage2D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, border: GLint, format: GLenum, type: GLenum, pboOffset: GLintptr): void;
15089     texImage2D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, border: GLint, format: GLenum, type: GLenum, source: TexImageSource): void;
15090     texImage2D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, border: GLint, format: GLenum, type: GLenum, srcData: ArrayBufferView, srcOffset: GLuint): void;
15091     texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, pixels: ArrayBufferView | null): void;
15092     texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, format: GLenum, type: GLenum, source: TexImageSource): void;
15093     texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, pboOffset: GLintptr): void;
15094     texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, source: TexImageSource): void;
15095     texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, srcData: ArrayBufferView, srcOffset: GLuint): void;
15096     uniform1fv(location: WebGLUniformLocation | null, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
15097     uniform1iv(location: WebGLUniformLocation | null, data: Int32List, srcOffset?: GLuint, srcLength?: GLuint): void;
15098     uniform2fv(location: WebGLUniformLocation | null, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
15099     uniform2iv(location: WebGLUniformLocation | null, data: Int32List, srcOffset?: GLuint, srcLength?: GLuint): void;
15100     uniform3fv(location: WebGLUniformLocation | null, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
15101     uniform3iv(location: WebGLUniformLocation | null, data: Int32List, srcOffset?: GLuint, srcLength?: GLuint): void;
15102     uniform4fv(location: WebGLUniformLocation | null, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
15103     uniform4iv(location: WebGLUniformLocation | null, data: Int32List, srcOffset?: GLuint, srcLength?: GLuint): void;
15104     uniformMatrix2fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
15105     uniformMatrix3fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
15106     uniformMatrix4fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
15107 }
15108
15109 /** Part of the WebGL API and represents the information returned by calling the WebGLRenderingContext.getActiveAttrib() and WebGLRenderingContext.getActiveUniform() methods. */
15110 interface WebGLActiveInfo {
15111     readonly name: string;
15112     readonly size: GLint;
15113     readonly type: GLenum;
15114 }
15115
15116 declare var WebGLActiveInfo: {
15117     prototype: WebGLActiveInfo;
15118     new(): WebGLActiveInfo;
15119 };
15120
15121 /** Part of the WebGL API and represents an opaque buffer object storing data such as vertices or colors. */
15122 interface WebGLBuffer {
15123 }
15124
15125 declare var WebGLBuffer: {
15126     prototype: WebGLBuffer;
15127     new(): WebGLBuffer;
15128 };
15129
15130 /** 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. */
15131 interface WebGLContextEvent extends Event {
15132     readonly statusMessage: string;
15133 }
15134
15135 declare var WebGLContextEvent: {
15136     prototype: WebGLContextEvent;
15137     new(type: string, eventInit?: WebGLContextEventInit): WebGLContextEvent;
15138 };
15139
15140 /** Part of the WebGL API and represents a collection of buffers that serve as a rendering destination. */
15141 interface WebGLFramebuffer {
15142 }
15143
15144 declare var WebGLFramebuffer: {
15145     prototype: WebGLFramebuffer;
15146     new(): WebGLFramebuffer;
15147 };
15148
15149 /** 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). */
15150 interface WebGLProgram {
15151 }
15152
15153 declare var WebGLProgram: {
15154     prototype: WebGLProgram;
15155     new(): WebGLProgram;
15156 };
15157
15158 interface WebGLQuery {
15159 }
15160
15161 declare var WebGLQuery: {
15162     prototype: WebGLQuery;
15163     new(): WebGLQuery;
15164 };
15165
15166 /** Part of the WebGL API and represents a buffer that can contain an image, or can be source or target of an rendering operation. */
15167 interface WebGLRenderbuffer {
15168 }
15169
15170 declare var WebGLRenderbuffer: {
15171     prototype: WebGLRenderbuffer;
15172     new(): WebGLRenderbuffer;
15173 };
15174
15175 /** Provides an interface to the OpenGL ES 2.0 graphics rendering context for the drawing surface of an HTML <canvas> element. */
15176 interface WebGLRenderingContext extends WebGLRenderingContextBase, WebGLRenderingContextOverloads {
15177 }
15178
15179 declare var WebGLRenderingContext: {
15180     prototype: WebGLRenderingContext;
15181     new(): WebGLRenderingContext;
15182     readonly ACTIVE_ATTRIBUTES: GLenum;
15183     readonly ACTIVE_TEXTURE: GLenum;
15184     readonly ACTIVE_UNIFORMS: GLenum;
15185     readonly ALIASED_LINE_WIDTH_RANGE: GLenum;
15186     readonly ALIASED_POINT_SIZE_RANGE: GLenum;
15187     readonly ALPHA: GLenum;
15188     readonly ALPHA_BITS: GLenum;
15189     readonly ALWAYS: GLenum;
15190     readonly ARRAY_BUFFER: GLenum;
15191     readonly ARRAY_BUFFER_BINDING: GLenum;
15192     readonly ATTACHED_SHADERS: GLenum;
15193     readonly BACK: GLenum;
15194     readonly BLEND: GLenum;
15195     readonly BLEND_COLOR: GLenum;
15196     readonly BLEND_DST_ALPHA: GLenum;
15197     readonly BLEND_DST_RGB: GLenum;
15198     readonly BLEND_EQUATION: GLenum;
15199     readonly BLEND_EQUATION_ALPHA: GLenum;
15200     readonly BLEND_EQUATION_RGB: GLenum;
15201     readonly BLEND_SRC_ALPHA: GLenum;
15202     readonly BLEND_SRC_RGB: GLenum;
15203     readonly BLUE_BITS: GLenum;
15204     readonly BOOL: GLenum;
15205     readonly BOOL_VEC2: GLenum;
15206     readonly BOOL_VEC3: GLenum;
15207     readonly BOOL_VEC4: GLenum;
15208     readonly BROWSER_DEFAULT_WEBGL: GLenum;
15209     readonly BUFFER_SIZE: GLenum;
15210     readonly BUFFER_USAGE: GLenum;
15211     readonly BYTE: GLenum;
15212     readonly CCW: GLenum;
15213     readonly CLAMP_TO_EDGE: GLenum;
15214     readonly COLOR_ATTACHMENT0: GLenum;
15215     readonly COLOR_BUFFER_BIT: GLenum;
15216     readonly COLOR_CLEAR_VALUE: GLenum;
15217     readonly COLOR_WRITEMASK: GLenum;
15218     readonly COMPILE_STATUS: GLenum;
15219     readonly COMPRESSED_TEXTURE_FORMATS: GLenum;
15220     readonly CONSTANT_ALPHA: GLenum;
15221     readonly CONSTANT_COLOR: GLenum;
15222     readonly CONTEXT_LOST_WEBGL: GLenum;
15223     readonly CULL_FACE: GLenum;
15224     readonly CULL_FACE_MODE: GLenum;
15225     readonly CURRENT_PROGRAM: GLenum;
15226     readonly CURRENT_VERTEX_ATTRIB: GLenum;
15227     readonly CW: GLenum;
15228     readonly DECR: GLenum;
15229     readonly DECR_WRAP: GLenum;
15230     readonly DELETE_STATUS: GLenum;
15231     readonly DEPTH_ATTACHMENT: GLenum;
15232     readonly DEPTH_BITS: GLenum;
15233     readonly DEPTH_BUFFER_BIT: GLenum;
15234     readonly DEPTH_CLEAR_VALUE: GLenum;
15235     readonly DEPTH_COMPONENT: GLenum;
15236     readonly DEPTH_COMPONENT16: GLenum;
15237     readonly DEPTH_FUNC: GLenum;
15238     readonly DEPTH_RANGE: GLenum;
15239     readonly DEPTH_STENCIL: GLenum;
15240     readonly DEPTH_STENCIL_ATTACHMENT: GLenum;
15241     readonly DEPTH_TEST: GLenum;
15242     readonly DEPTH_WRITEMASK: GLenum;
15243     readonly DITHER: GLenum;
15244     readonly DONT_CARE: GLenum;
15245     readonly DST_ALPHA: GLenum;
15246     readonly DST_COLOR: GLenum;
15247     readonly DYNAMIC_DRAW: GLenum;
15248     readonly ELEMENT_ARRAY_BUFFER: GLenum;
15249     readonly ELEMENT_ARRAY_BUFFER_BINDING: GLenum;
15250     readonly EQUAL: GLenum;
15251     readonly FASTEST: GLenum;
15252     readonly FLOAT: GLenum;
15253     readonly FLOAT_MAT2: GLenum;
15254     readonly FLOAT_MAT3: GLenum;
15255     readonly FLOAT_MAT4: GLenum;
15256     readonly FLOAT_VEC2: GLenum;
15257     readonly FLOAT_VEC3: GLenum;
15258     readonly FLOAT_VEC4: GLenum;
15259     readonly FRAGMENT_SHADER: GLenum;
15260     readonly FRAMEBUFFER: GLenum;
15261     readonly FRAMEBUFFER_ATTACHMENT_OBJECT_NAME: GLenum;
15262     readonly FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE: GLenum;
15263     readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE: GLenum;
15264     readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL: GLenum;
15265     readonly FRAMEBUFFER_BINDING: GLenum;
15266     readonly FRAMEBUFFER_COMPLETE: GLenum;
15267     readonly FRAMEBUFFER_INCOMPLETE_ATTACHMENT: GLenum;
15268     readonly FRAMEBUFFER_INCOMPLETE_DIMENSIONS: GLenum;
15269     readonly FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: GLenum;
15270     readonly FRAMEBUFFER_UNSUPPORTED: GLenum;
15271     readonly FRONT: GLenum;
15272     readonly FRONT_AND_BACK: GLenum;
15273     readonly FRONT_FACE: GLenum;
15274     readonly FUNC_ADD: GLenum;
15275     readonly FUNC_REVERSE_SUBTRACT: GLenum;
15276     readonly FUNC_SUBTRACT: GLenum;
15277     readonly GENERATE_MIPMAP_HINT: GLenum;
15278     readonly GEQUAL: GLenum;
15279     readonly GREATER: GLenum;
15280     readonly GREEN_BITS: GLenum;
15281     readonly HIGH_FLOAT: GLenum;
15282     readonly HIGH_INT: GLenum;
15283     readonly IMPLEMENTATION_COLOR_READ_FORMAT: GLenum;
15284     readonly IMPLEMENTATION_COLOR_READ_TYPE: GLenum;
15285     readonly INCR: GLenum;
15286     readonly INCR_WRAP: GLenum;
15287     readonly INT: GLenum;
15288     readonly INT_VEC2: GLenum;
15289     readonly INT_VEC3: GLenum;
15290     readonly INT_VEC4: GLenum;
15291     readonly INVALID_ENUM: GLenum;
15292     readonly INVALID_FRAMEBUFFER_OPERATION: GLenum;
15293     readonly INVALID_OPERATION: GLenum;
15294     readonly INVALID_VALUE: GLenum;
15295     readonly INVERT: GLenum;
15296     readonly KEEP: GLenum;
15297     readonly LEQUAL: GLenum;
15298     readonly LESS: GLenum;
15299     readonly LINEAR: GLenum;
15300     readonly LINEAR_MIPMAP_LINEAR: GLenum;
15301     readonly LINEAR_MIPMAP_NEAREST: GLenum;
15302     readonly LINES: GLenum;
15303     readonly LINE_LOOP: GLenum;
15304     readonly LINE_STRIP: GLenum;
15305     readonly LINE_WIDTH: GLenum;
15306     readonly LINK_STATUS: GLenum;
15307     readonly LOW_FLOAT: GLenum;
15308     readonly LOW_INT: GLenum;
15309     readonly LUMINANCE: GLenum;
15310     readonly LUMINANCE_ALPHA: GLenum;
15311     readonly MAX_COMBINED_TEXTURE_IMAGE_UNITS: GLenum;
15312     readonly MAX_CUBE_MAP_TEXTURE_SIZE: GLenum;
15313     readonly MAX_FRAGMENT_UNIFORM_VECTORS: GLenum;
15314     readonly MAX_RENDERBUFFER_SIZE: GLenum;
15315     readonly MAX_TEXTURE_IMAGE_UNITS: GLenum;
15316     readonly MAX_TEXTURE_SIZE: GLenum;
15317     readonly MAX_VARYING_VECTORS: GLenum;
15318     readonly MAX_VERTEX_ATTRIBS: GLenum;
15319     readonly MAX_VERTEX_TEXTURE_IMAGE_UNITS: GLenum;
15320     readonly MAX_VERTEX_UNIFORM_VECTORS: GLenum;
15321     readonly MAX_VIEWPORT_DIMS: GLenum;
15322     readonly MEDIUM_FLOAT: GLenum;
15323     readonly MEDIUM_INT: GLenum;
15324     readonly MIRRORED_REPEAT: GLenum;
15325     readonly NEAREST: GLenum;
15326     readonly NEAREST_MIPMAP_LINEAR: GLenum;
15327     readonly NEAREST_MIPMAP_NEAREST: GLenum;
15328     readonly NEVER: GLenum;
15329     readonly NICEST: GLenum;
15330     readonly NONE: GLenum;
15331     readonly NOTEQUAL: GLenum;
15332     readonly NO_ERROR: GLenum;
15333     readonly ONE: GLenum;
15334     readonly ONE_MINUS_CONSTANT_ALPHA: GLenum;
15335     readonly ONE_MINUS_CONSTANT_COLOR: GLenum;
15336     readonly ONE_MINUS_DST_ALPHA: GLenum;
15337     readonly ONE_MINUS_DST_COLOR: GLenum;
15338     readonly ONE_MINUS_SRC_ALPHA: GLenum;
15339     readonly ONE_MINUS_SRC_COLOR: GLenum;
15340     readonly OUT_OF_MEMORY: GLenum;
15341     readonly PACK_ALIGNMENT: GLenum;
15342     readonly POINTS: GLenum;
15343     readonly POLYGON_OFFSET_FACTOR: GLenum;
15344     readonly POLYGON_OFFSET_FILL: GLenum;
15345     readonly POLYGON_OFFSET_UNITS: GLenum;
15346     readonly RED_BITS: GLenum;
15347     readonly RENDERBUFFER: GLenum;
15348     readonly RENDERBUFFER_ALPHA_SIZE: GLenum;
15349     readonly RENDERBUFFER_BINDING: GLenum;
15350     readonly RENDERBUFFER_BLUE_SIZE: GLenum;
15351     readonly RENDERBUFFER_DEPTH_SIZE: GLenum;
15352     readonly RENDERBUFFER_GREEN_SIZE: GLenum;
15353     readonly RENDERBUFFER_HEIGHT: GLenum;
15354     readonly RENDERBUFFER_INTERNAL_FORMAT: GLenum;
15355     readonly RENDERBUFFER_RED_SIZE: GLenum;
15356     readonly RENDERBUFFER_STENCIL_SIZE: GLenum;
15357     readonly RENDERBUFFER_WIDTH: GLenum;
15358     readonly RENDERER: GLenum;
15359     readonly REPEAT: GLenum;
15360     readonly REPLACE: GLenum;
15361     readonly RGB: GLenum;
15362     readonly RGB565: GLenum;
15363     readonly RGB5_A1: GLenum;
15364     readonly RGBA: GLenum;
15365     readonly RGBA4: GLenum;
15366     readonly SAMPLER_2D: GLenum;
15367     readonly SAMPLER_CUBE: GLenum;
15368     readonly SAMPLES: GLenum;
15369     readonly SAMPLE_ALPHA_TO_COVERAGE: GLenum;
15370     readonly SAMPLE_BUFFERS: GLenum;
15371     readonly SAMPLE_COVERAGE: GLenum;
15372     readonly SAMPLE_COVERAGE_INVERT: GLenum;
15373     readonly SAMPLE_COVERAGE_VALUE: GLenum;
15374     readonly SCISSOR_BOX: GLenum;
15375     readonly SCISSOR_TEST: GLenum;
15376     readonly SHADER_TYPE: GLenum;
15377     readonly SHADING_LANGUAGE_VERSION: GLenum;
15378     readonly SHORT: GLenum;
15379     readonly SRC_ALPHA: GLenum;
15380     readonly SRC_ALPHA_SATURATE: GLenum;
15381     readonly SRC_COLOR: GLenum;
15382     readonly STATIC_DRAW: GLenum;
15383     readonly STENCIL_ATTACHMENT: GLenum;
15384     readonly STENCIL_BACK_FAIL: GLenum;
15385     readonly STENCIL_BACK_FUNC: GLenum;
15386     readonly STENCIL_BACK_PASS_DEPTH_FAIL: GLenum;
15387     readonly STENCIL_BACK_PASS_DEPTH_PASS: GLenum;
15388     readonly STENCIL_BACK_REF: GLenum;
15389     readonly STENCIL_BACK_VALUE_MASK: GLenum;
15390     readonly STENCIL_BACK_WRITEMASK: GLenum;
15391     readonly STENCIL_BITS: GLenum;
15392     readonly STENCIL_BUFFER_BIT: GLenum;
15393     readonly STENCIL_CLEAR_VALUE: GLenum;
15394     readonly STENCIL_FAIL: GLenum;
15395     readonly STENCIL_FUNC: GLenum;
15396     readonly STENCIL_INDEX8: GLenum;
15397     readonly STENCIL_PASS_DEPTH_FAIL: GLenum;
15398     readonly STENCIL_PASS_DEPTH_PASS: GLenum;
15399     readonly STENCIL_REF: GLenum;
15400     readonly STENCIL_TEST: GLenum;
15401     readonly STENCIL_VALUE_MASK: GLenum;
15402     readonly STENCIL_WRITEMASK: GLenum;
15403     readonly STREAM_DRAW: GLenum;
15404     readonly SUBPIXEL_BITS: GLenum;
15405     readonly TEXTURE: GLenum;
15406     readonly TEXTURE0: GLenum;
15407     readonly TEXTURE1: GLenum;
15408     readonly TEXTURE10: GLenum;
15409     readonly TEXTURE11: GLenum;
15410     readonly TEXTURE12: GLenum;
15411     readonly TEXTURE13: GLenum;
15412     readonly TEXTURE14: GLenum;
15413     readonly TEXTURE15: GLenum;
15414     readonly TEXTURE16: GLenum;
15415     readonly TEXTURE17: GLenum;
15416     readonly TEXTURE18: GLenum;
15417     readonly TEXTURE19: GLenum;
15418     readonly TEXTURE2: GLenum;
15419     readonly TEXTURE20: GLenum;
15420     readonly TEXTURE21: GLenum;
15421     readonly TEXTURE22: GLenum;
15422     readonly TEXTURE23: GLenum;
15423     readonly TEXTURE24: GLenum;
15424     readonly TEXTURE25: GLenum;
15425     readonly TEXTURE26: GLenum;
15426     readonly TEXTURE27: GLenum;
15427     readonly TEXTURE28: GLenum;
15428     readonly TEXTURE29: GLenum;
15429     readonly TEXTURE3: GLenum;
15430     readonly TEXTURE30: GLenum;
15431     readonly TEXTURE31: GLenum;
15432     readonly TEXTURE4: GLenum;
15433     readonly TEXTURE5: GLenum;
15434     readonly TEXTURE6: GLenum;
15435     readonly TEXTURE7: GLenum;
15436     readonly TEXTURE8: GLenum;
15437     readonly TEXTURE9: GLenum;
15438     readonly TEXTURE_2D: GLenum;
15439     readonly TEXTURE_BINDING_2D: GLenum;
15440     readonly TEXTURE_BINDING_CUBE_MAP: GLenum;
15441     readonly TEXTURE_CUBE_MAP: GLenum;
15442     readonly TEXTURE_CUBE_MAP_NEGATIVE_X: GLenum;
15443     readonly TEXTURE_CUBE_MAP_NEGATIVE_Y: GLenum;
15444     readonly TEXTURE_CUBE_MAP_NEGATIVE_Z: GLenum;
15445     readonly TEXTURE_CUBE_MAP_POSITIVE_X: GLenum;
15446     readonly TEXTURE_CUBE_MAP_POSITIVE_Y: GLenum;
15447     readonly TEXTURE_CUBE_MAP_POSITIVE_Z: GLenum;
15448     readonly TEXTURE_MAG_FILTER: GLenum;
15449     readonly TEXTURE_MIN_FILTER: GLenum;
15450     readonly TEXTURE_WRAP_S: GLenum;
15451     readonly TEXTURE_WRAP_T: GLenum;
15452     readonly TRIANGLES: GLenum;
15453     readonly TRIANGLE_FAN: GLenum;
15454     readonly TRIANGLE_STRIP: GLenum;
15455     readonly UNPACK_ALIGNMENT: GLenum;
15456     readonly UNPACK_COLORSPACE_CONVERSION_WEBGL: GLenum;
15457     readonly UNPACK_FLIP_Y_WEBGL: GLenum;
15458     readonly UNPACK_PREMULTIPLY_ALPHA_WEBGL: GLenum;
15459     readonly UNSIGNED_BYTE: GLenum;
15460     readonly UNSIGNED_INT: GLenum;
15461     readonly UNSIGNED_SHORT: GLenum;
15462     readonly UNSIGNED_SHORT_4_4_4_4: GLenum;
15463     readonly UNSIGNED_SHORT_5_5_5_1: GLenum;
15464     readonly UNSIGNED_SHORT_5_6_5: GLenum;
15465     readonly VALIDATE_STATUS: GLenum;
15466     readonly VENDOR: GLenum;
15467     readonly VERSION: GLenum;
15468     readonly VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: GLenum;
15469     readonly VERTEX_ATTRIB_ARRAY_ENABLED: GLenum;
15470     readonly VERTEX_ATTRIB_ARRAY_NORMALIZED: GLenum;
15471     readonly VERTEX_ATTRIB_ARRAY_POINTER: GLenum;
15472     readonly VERTEX_ATTRIB_ARRAY_SIZE: GLenum;
15473     readonly VERTEX_ATTRIB_ARRAY_STRIDE: GLenum;
15474     readonly VERTEX_ATTRIB_ARRAY_TYPE: GLenum;
15475     readonly VERTEX_SHADER: GLenum;
15476     readonly VIEWPORT: GLenum;
15477     readonly ZERO: GLenum;
15478 };
15479
15480 interface WebGLRenderingContextBase {
15481     readonly canvas: HTMLCanvasElement;
15482     readonly drawingBufferHeight: GLsizei;
15483     readonly drawingBufferWidth: GLsizei;
15484     activeTexture(texture: GLenum): void;
15485     attachShader(program: WebGLProgram, shader: WebGLShader): void;
15486     bindAttribLocation(program: WebGLProgram, index: GLuint, name: string): void;
15487     bindBuffer(target: GLenum, buffer: WebGLBuffer | null): void;
15488     bindFramebuffer(target: GLenum, framebuffer: WebGLFramebuffer | null): void;
15489     bindRenderbuffer(target: GLenum, renderbuffer: WebGLRenderbuffer | null): void;
15490     bindTexture(target: GLenum, texture: WebGLTexture | null): void;
15491     blendColor(red: GLclampf, green: GLclampf, blue: GLclampf, alpha: GLclampf): void;
15492     blendEquation(mode: GLenum): void;
15493     blendEquationSeparate(modeRGB: GLenum, modeAlpha: GLenum): void;
15494     blendFunc(sfactor: GLenum, dfactor: GLenum): void;
15495     blendFuncSeparate(srcRGB: GLenum, dstRGB: GLenum, srcAlpha: GLenum, dstAlpha: GLenum): void;
15496     checkFramebufferStatus(target: GLenum): GLenum;
15497     clear(mask: GLbitfield): void;
15498     clearColor(red: GLclampf, green: GLclampf, blue: GLclampf, alpha: GLclampf): void;
15499     clearDepth(depth: GLclampf): void;
15500     clearStencil(s: GLint): void;
15501     colorMask(red: GLboolean, green: GLboolean, blue: GLboolean, alpha: GLboolean): void;
15502     compileShader(shader: WebGLShader): void;
15503     copyTexImage2D(target: GLenum, level: GLint, internalformat: GLenum, x: GLint, y: GLint, width: GLsizei, height: GLsizei, border: GLint): void;
15504     copyTexSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, x: GLint, y: GLint, width: GLsizei, height: GLsizei): void;
15505     createBuffer(): WebGLBuffer | null;
15506     createFramebuffer(): WebGLFramebuffer | null;
15507     createProgram(): WebGLProgram | null;
15508     createRenderbuffer(): WebGLRenderbuffer | null;
15509     createShader(type: GLenum): WebGLShader | null;
15510     createTexture(): WebGLTexture | null;
15511     cullFace(mode: GLenum): void;
15512     deleteBuffer(buffer: WebGLBuffer | null): void;
15513     deleteFramebuffer(framebuffer: WebGLFramebuffer | null): void;
15514     deleteProgram(program: WebGLProgram | null): void;
15515     deleteRenderbuffer(renderbuffer: WebGLRenderbuffer | null): void;
15516     deleteShader(shader: WebGLShader | null): void;
15517     deleteTexture(texture: WebGLTexture | null): void;
15518     depthFunc(func: GLenum): void;
15519     depthMask(flag: GLboolean): void;
15520     depthRange(zNear: GLclampf, zFar: GLclampf): void;
15521     detachShader(program: WebGLProgram, shader: WebGLShader): void;
15522     disable(cap: GLenum): void;
15523     disableVertexAttribArray(index: GLuint): void;
15524     drawArrays(mode: GLenum, first: GLint, count: GLsizei): void;
15525     drawElements(mode: GLenum, count: GLsizei, type: GLenum, offset: GLintptr): void;
15526     enable(cap: GLenum): void;
15527     enableVertexAttribArray(index: GLuint): void;
15528     finish(): void;
15529     flush(): void;
15530     framebufferRenderbuffer(target: GLenum, attachment: GLenum, renderbuffertarget: GLenum, renderbuffer: WebGLRenderbuffer | null): void;
15531     framebufferTexture2D(target: GLenum, attachment: GLenum, textarget: GLenum, texture: WebGLTexture | null, level: GLint): void;
15532     frontFace(mode: GLenum): void;
15533     generateMipmap(target: GLenum): void;
15534     getActiveAttrib(program: WebGLProgram, index: GLuint): WebGLActiveInfo | null;
15535     getActiveUniform(program: WebGLProgram, index: GLuint): WebGLActiveInfo | null;
15536     getAttachedShaders(program: WebGLProgram): WebGLShader[] | null;
15537     getAttribLocation(program: WebGLProgram, name: string): GLint;
15538     getBufferParameter(target: GLenum, pname: GLenum): any;
15539     getContextAttributes(): WebGLContextAttributes | null;
15540     getError(): GLenum;
15541     getExtension(extensionName: "EXT_blend_minmax"): EXT_blend_minmax | null;
15542     getExtension(extensionName: "EXT_color_buffer_float"): EXT_color_buffer_float | null;
15543     getExtension(extensionName: "EXT_color_buffer_half_float"): EXT_color_buffer_half_float | null;
15544     getExtension(extensionName: "EXT_float_blend"): EXT_float_blend | null;
15545     getExtension(extensionName: "EXT_texture_filter_anisotropic"): EXT_texture_filter_anisotropic | null;
15546     getExtension(extensionName: "EXT_frag_depth"): EXT_frag_depth | null;
15547     getExtension(extensionName: "EXT_shader_texture_lod"): EXT_shader_texture_lod | null;
15548     getExtension(extensionName: "EXT_sRGB"): EXT_sRGB | null;
15549     getExtension(extensionName: "KHR_parallel_shader_compile"): KHR_parallel_shader_compile | null;
15550     getExtension(extensionName: "OES_vertex_array_object"): OES_vertex_array_object | null;
15551     getExtension(extensionName: "OVR_multiview2"): OVR_multiview2 | null;
15552     getExtension(extensionName: "WEBGL_color_buffer_float"): WEBGL_color_buffer_float | null;
15553     getExtension(extensionName: "WEBGL_compressed_texture_astc"): WEBGL_compressed_texture_astc | null;
15554     getExtension(extensionName: "WEBGL_compressed_texture_etc"): WEBGL_compressed_texture_etc | null;
15555     getExtension(extensionName: "WEBGL_compressed_texture_etc1"): WEBGL_compressed_texture_etc1 | null;
15556     getExtension(extensionName: "WEBGL_compressed_texture_pvrtc"): WEBGL_compressed_texture_pvrtc | null;
15557     getExtension(extensionName: "WEBGL_compressed_texture_s3tc_srgb"): WEBGL_compressed_texture_s3tc_srgb | null;
15558     getExtension(extensionName: "WEBGL_debug_shaders"): WEBGL_debug_shaders | null;
15559     getExtension(extensionName: "WEBGL_draw_buffers"): WEBGL_draw_buffers | null;
15560     getExtension(extensionName: "WEBGL_lose_context"): WEBGL_lose_context | null;
15561     getExtension(extensionName: "WEBGL_depth_texture"): WEBGL_depth_texture | null;
15562     getExtension(extensionName: "WEBGL_debug_renderer_info"): WEBGL_debug_renderer_info | null;
15563     getExtension(extensionName: "WEBGL_compressed_texture_s3tc"): WEBGL_compressed_texture_s3tc | null;
15564     getExtension(extensionName: "OES_texture_half_float_linear"): OES_texture_half_float_linear | null;
15565     getExtension(extensionName: "OES_texture_half_float"): OES_texture_half_float | null;
15566     getExtension(extensionName: "OES_texture_float_linear"): OES_texture_float_linear | null;
15567     getExtension(extensionName: "OES_texture_float"): OES_texture_float | null;
15568     getExtension(extensionName: "OES_standard_derivatives"): OES_standard_derivatives | null;
15569     getExtension(extensionName: "OES_element_index_uint"): OES_element_index_uint | null;
15570     getExtension(extensionName: "ANGLE_instanced_arrays"): ANGLE_instanced_arrays | null;
15571     getExtension(name: string): any;
15572     getFramebufferAttachmentParameter(target: GLenum, attachment: GLenum, pname: GLenum): any;
15573     getParameter(pname: GLenum): any;
15574     getProgramInfoLog(program: WebGLProgram): string | null;
15575     getProgramParameter(program: WebGLProgram, pname: GLenum): any;
15576     getRenderbufferParameter(target: GLenum, pname: GLenum): any;
15577     getShaderInfoLog(shader: WebGLShader): string | null;
15578     getShaderParameter(shader: WebGLShader, pname: GLenum): any;
15579     getShaderPrecisionFormat(shadertype: GLenum, precisiontype: GLenum): WebGLShaderPrecisionFormat | null;
15580     getShaderSource(shader: WebGLShader): string | null;
15581     getSupportedExtensions(): string[] | null;
15582     getTexParameter(target: GLenum, pname: GLenum): any;
15583     getUniform(program: WebGLProgram, location: WebGLUniformLocation): any;
15584     getUniformLocation(program: WebGLProgram, name: string): WebGLUniformLocation | null;
15585     getVertexAttrib(index: GLuint, pname: GLenum): any;
15586     getVertexAttribOffset(index: GLuint, pname: GLenum): GLintptr;
15587     hint(target: GLenum, mode: GLenum): void;
15588     isBuffer(buffer: WebGLBuffer | null): GLboolean;
15589     isContextLost(): boolean;
15590     isEnabled(cap: GLenum): GLboolean;
15591     isFramebuffer(framebuffer: WebGLFramebuffer | null): GLboolean;
15592     isProgram(program: WebGLProgram | null): GLboolean;
15593     isRenderbuffer(renderbuffer: WebGLRenderbuffer | null): GLboolean;
15594     isShader(shader: WebGLShader | null): GLboolean;
15595     isTexture(texture: WebGLTexture | null): GLboolean;
15596     lineWidth(width: GLfloat): void;
15597     linkProgram(program: WebGLProgram): void;
15598     pixelStorei(pname: GLenum, param: GLint | GLboolean): void;
15599     polygonOffset(factor: GLfloat, units: GLfloat): void;
15600     renderbufferStorage(target: GLenum, internalformat: GLenum, width: GLsizei, height: GLsizei): void;
15601     sampleCoverage(value: GLclampf, invert: GLboolean): void;
15602     scissor(x: GLint, y: GLint, width: GLsizei, height: GLsizei): void;
15603     shaderSource(shader: WebGLShader, source: string): void;
15604     stencilFunc(func: GLenum, ref: GLint, mask: GLuint): void;
15605     stencilFuncSeparate(face: GLenum, func: GLenum, ref: GLint, mask: GLuint): void;
15606     stencilMask(mask: GLuint): void;
15607     stencilMaskSeparate(face: GLenum, mask: GLuint): void;
15608     stencilOp(fail: GLenum, zfail: GLenum, zpass: GLenum): void;
15609     stencilOpSeparate(face: GLenum, fail: GLenum, zfail: GLenum, zpass: GLenum): void;
15610     texParameterf(target: GLenum, pname: GLenum, param: GLfloat): void;
15611     texParameteri(target: GLenum, pname: GLenum, param: GLint): void;
15612     uniform1f(location: WebGLUniformLocation | null, x: GLfloat): void;
15613     uniform1i(location: WebGLUniformLocation | null, x: GLint): void;
15614     uniform2f(location: WebGLUniformLocation | null, x: GLfloat, y: GLfloat): void;
15615     uniform2i(location: WebGLUniformLocation | null, x: GLint, y: GLint): void;
15616     uniform3f(location: WebGLUniformLocation | null, x: GLfloat, y: GLfloat, z: GLfloat): void;
15617     uniform3i(location: WebGLUniformLocation | null, x: GLint, y: GLint, z: GLint): void;
15618     uniform4f(location: WebGLUniformLocation | null, x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat): void;
15619     uniform4i(location: WebGLUniformLocation | null, x: GLint, y: GLint, z: GLint, w: GLint): void;
15620     useProgram(program: WebGLProgram | null): void;
15621     validateProgram(program: WebGLProgram): void;
15622     vertexAttrib1f(index: GLuint, x: GLfloat): void;
15623     vertexAttrib1fv(index: GLuint, values: Float32List): void;
15624     vertexAttrib2f(index: GLuint, x: GLfloat, y: GLfloat): void;
15625     vertexAttrib2fv(index: GLuint, values: Float32List): void;
15626     vertexAttrib3f(index: GLuint, x: GLfloat, y: GLfloat, z: GLfloat): void;
15627     vertexAttrib3fv(index: GLuint, values: Float32List): void;
15628     vertexAttrib4f(index: GLuint, x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat): void;
15629     vertexAttrib4fv(index: GLuint, values: Float32List): void;
15630     vertexAttribPointer(index: GLuint, size: GLint, type: GLenum, normalized: GLboolean, stride: GLsizei, offset: GLintptr): void;
15631     viewport(x: GLint, y: GLint, width: GLsizei, height: GLsizei): void;
15632     readonly ACTIVE_ATTRIBUTES: GLenum;
15633     readonly ACTIVE_TEXTURE: GLenum;
15634     readonly ACTIVE_UNIFORMS: GLenum;
15635     readonly ALIASED_LINE_WIDTH_RANGE: GLenum;
15636     readonly ALIASED_POINT_SIZE_RANGE: GLenum;
15637     readonly ALPHA: GLenum;
15638     readonly ALPHA_BITS: GLenum;
15639     readonly ALWAYS: GLenum;
15640     readonly ARRAY_BUFFER: GLenum;
15641     readonly ARRAY_BUFFER_BINDING: GLenum;
15642     readonly ATTACHED_SHADERS: GLenum;
15643     readonly BACK: GLenum;
15644     readonly BLEND: GLenum;
15645     readonly BLEND_COLOR: GLenum;
15646     readonly BLEND_DST_ALPHA: GLenum;
15647     readonly BLEND_DST_RGB: GLenum;
15648     readonly BLEND_EQUATION: GLenum;
15649     readonly BLEND_EQUATION_ALPHA: GLenum;
15650     readonly BLEND_EQUATION_RGB: GLenum;
15651     readonly BLEND_SRC_ALPHA: GLenum;
15652     readonly BLEND_SRC_RGB: GLenum;
15653     readonly BLUE_BITS: GLenum;
15654     readonly BOOL: GLenum;
15655     readonly BOOL_VEC2: GLenum;
15656     readonly BOOL_VEC3: GLenum;
15657     readonly BOOL_VEC4: GLenum;
15658     readonly BROWSER_DEFAULT_WEBGL: GLenum;
15659     readonly BUFFER_SIZE: GLenum;
15660     readonly BUFFER_USAGE: GLenum;
15661     readonly BYTE: GLenum;
15662     readonly CCW: GLenum;
15663     readonly CLAMP_TO_EDGE: GLenum;
15664     readonly COLOR_ATTACHMENT0: GLenum;
15665     readonly COLOR_BUFFER_BIT: GLenum;
15666     readonly COLOR_CLEAR_VALUE: GLenum;
15667     readonly COLOR_WRITEMASK: GLenum;
15668     readonly COMPILE_STATUS: GLenum;
15669     readonly COMPRESSED_TEXTURE_FORMATS: GLenum;
15670     readonly CONSTANT_ALPHA: GLenum;
15671     readonly CONSTANT_COLOR: GLenum;
15672     readonly CONTEXT_LOST_WEBGL: GLenum;
15673     readonly CULL_FACE: GLenum;
15674     readonly CULL_FACE_MODE: GLenum;
15675     readonly CURRENT_PROGRAM: GLenum;
15676     readonly CURRENT_VERTEX_ATTRIB: GLenum;
15677     readonly CW: GLenum;
15678     readonly DECR: GLenum;
15679     readonly DECR_WRAP: GLenum;
15680     readonly DELETE_STATUS: GLenum;
15681     readonly DEPTH_ATTACHMENT: GLenum;
15682     readonly DEPTH_BITS: GLenum;
15683     readonly DEPTH_BUFFER_BIT: GLenum;
15684     readonly DEPTH_CLEAR_VALUE: GLenum;
15685     readonly DEPTH_COMPONENT: GLenum;
15686     readonly DEPTH_COMPONENT16: GLenum;
15687     readonly DEPTH_FUNC: GLenum;
15688     readonly DEPTH_RANGE: GLenum;
15689     readonly DEPTH_STENCIL: GLenum;
15690     readonly DEPTH_STENCIL_ATTACHMENT: GLenum;
15691     readonly DEPTH_TEST: GLenum;
15692     readonly DEPTH_WRITEMASK: GLenum;
15693     readonly DITHER: GLenum;
15694     readonly DONT_CARE: GLenum;
15695     readonly DST_ALPHA: GLenum;
15696     readonly DST_COLOR: GLenum;
15697     readonly DYNAMIC_DRAW: GLenum;
15698     readonly ELEMENT_ARRAY_BUFFER: GLenum;
15699     readonly ELEMENT_ARRAY_BUFFER_BINDING: GLenum;
15700     readonly EQUAL: GLenum;
15701     readonly FASTEST: GLenum;
15702     readonly FLOAT: GLenum;
15703     readonly FLOAT_MAT2: GLenum;
15704     readonly FLOAT_MAT3: GLenum;
15705     readonly FLOAT_MAT4: GLenum;
15706     readonly FLOAT_VEC2: GLenum;
15707     readonly FLOAT_VEC3: GLenum;
15708     readonly FLOAT_VEC4: GLenum;
15709     readonly FRAGMENT_SHADER: GLenum;
15710     readonly FRAMEBUFFER: GLenum;
15711     readonly FRAMEBUFFER_ATTACHMENT_OBJECT_NAME: GLenum;
15712     readonly FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE: GLenum;
15713     readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE: GLenum;
15714     readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL: GLenum;
15715     readonly FRAMEBUFFER_BINDING: GLenum;
15716     readonly FRAMEBUFFER_COMPLETE: GLenum;
15717     readonly FRAMEBUFFER_INCOMPLETE_ATTACHMENT: GLenum;
15718     readonly FRAMEBUFFER_INCOMPLETE_DIMENSIONS: GLenum;
15719     readonly FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: GLenum;
15720     readonly FRAMEBUFFER_UNSUPPORTED: GLenum;
15721     readonly FRONT: GLenum;
15722     readonly FRONT_AND_BACK: GLenum;
15723     readonly FRONT_FACE: GLenum;
15724     readonly FUNC_ADD: GLenum;
15725     readonly FUNC_REVERSE_SUBTRACT: GLenum;
15726     readonly FUNC_SUBTRACT: GLenum;
15727     readonly GENERATE_MIPMAP_HINT: GLenum;
15728     readonly GEQUAL: GLenum;
15729     readonly GREATER: GLenum;
15730     readonly GREEN_BITS: GLenum;
15731     readonly HIGH_FLOAT: GLenum;
15732     readonly HIGH_INT: GLenum;
15733     readonly IMPLEMENTATION_COLOR_READ_FORMAT: GLenum;
15734     readonly IMPLEMENTATION_COLOR_READ_TYPE: GLenum;
15735     readonly INCR: GLenum;
15736     readonly INCR_WRAP: GLenum;
15737     readonly INT: GLenum;
15738     readonly INT_VEC2: GLenum;
15739     readonly INT_VEC3: GLenum;
15740     readonly INT_VEC4: GLenum;
15741     readonly INVALID_ENUM: GLenum;
15742     readonly INVALID_FRAMEBUFFER_OPERATION: GLenum;
15743     readonly INVALID_OPERATION: GLenum;
15744     readonly INVALID_VALUE: GLenum;
15745     readonly INVERT: GLenum;
15746     readonly KEEP: GLenum;
15747     readonly LEQUAL: GLenum;
15748     readonly LESS: GLenum;
15749     readonly LINEAR: GLenum;
15750     readonly LINEAR_MIPMAP_LINEAR: GLenum;
15751     readonly LINEAR_MIPMAP_NEAREST: GLenum;
15752     readonly LINES: GLenum;
15753     readonly LINE_LOOP: GLenum;
15754     readonly LINE_STRIP: GLenum;
15755     readonly LINE_WIDTH: GLenum;
15756     readonly LINK_STATUS: GLenum;
15757     readonly LOW_FLOAT: GLenum;
15758     readonly LOW_INT: GLenum;
15759     readonly LUMINANCE: GLenum;
15760     readonly LUMINANCE_ALPHA: GLenum;
15761     readonly MAX_COMBINED_TEXTURE_IMAGE_UNITS: GLenum;
15762     readonly MAX_CUBE_MAP_TEXTURE_SIZE: GLenum;
15763     readonly MAX_FRAGMENT_UNIFORM_VECTORS: GLenum;
15764     readonly MAX_RENDERBUFFER_SIZE: GLenum;
15765     readonly MAX_TEXTURE_IMAGE_UNITS: GLenum;
15766     readonly MAX_TEXTURE_SIZE: GLenum;
15767     readonly MAX_VARYING_VECTORS: GLenum;
15768     readonly MAX_VERTEX_ATTRIBS: GLenum;
15769     readonly MAX_VERTEX_TEXTURE_IMAGE_UNITS: GLenum;
15770     readonly MAX_VERTEX_UNIFORM_VECTORS: GLenum;
15771     readonly MAX_VIEWPORT_DIMS: GLenum;
15772     readonly MEDIUM_FLOAT: GLenum;
15773     readonly MEDIUM_INT: GLenum;
15774     readonly MIRRORED_REPEAT: GLenum;
15775     readonly NEAREST: GLenum;
15776     readonly NEAREST_MIPMAP_LINEAR: GLenum;
15777     readonly NEAREST_MIPMAP_NEAREST: GLenum;
15778     readonly NEVER: GLenum;
15779     readonly NICEST: GLenum;
15780     readonly NONE: GLenum;
15781     readonly NOTEQUAL: GLenum;
15782     readonly NO_ERROR: GLenum;
15783     readonly ONE: GLenum;
15784     readonly ONE_MINUS_CONSTANT_ALPHA: GLenum;
15785     readonly ONE_MINUS_CONSTANT_COLOR: GLenum;
15786     readonly ONE_MINUS_DST_ALPHA: GLenum;
15787     readonly ONE_MINUS_DST_COLOR: GLenum;
15788     readonly ONE_MINUS_SRC_ALPHA: GLenum;
15789     readonly ONE_MINUS_SRC_COLOR: GLenum;
15790     readonly OUT_OF_MEMORY: GLenum;
15791     readonly PACK_ALIGNMENT: GLenum;
15792     readonly POINTS: GLenum;
15793     readonly POLYGON_OFFSET_FACTOR: GLenum;
15794     readonly POLYGON_OFFSET_FILL: GLenum;
15795     readonly POLYGON_OFFSET_UNITS: GLenum;
15796     readonly RED_BITS: GLenum;
15797     readonly RENDERBUFFER: GLenum;
15798     readonly RENDERBUFFER_ALPHA_SIZE: GLenum;
15799     readonly RENDERBUFFER_BINDING: GLenum;
15800     readonly RENDERBUFFER_BLUE_SIZE: GLenum;
15801     readonly RENDERBUFFER_DEPTH_SIZE: GLenum;
15802     readonly RENDERBUFFER_GREEN_SIZE: GLenum;
15803     readonly RENDERBUFFER_HEIGHT: GLenum;
15804     readonly RENDERBUFFER_INTERNAL_FORMAT: GLenum;
15805     readonly RENDERBUFFER_RED_SIZE: GLenum;
15806     readonly RENDERBUFFER_STENCIL_SIZE: GLenum;
15807     readonly RENDERBUFFER_WIDTH: GLenum;
15808     readonly RENDERER: GLenum;
15809     readonly REPEAT: GLenum;
15810     readonly REPLACE: GLenum;
15811     readonly RGB: GLenum;
15812     readonly RGB565: GLenum;
15813     readonly RGB5_A1: GLenum;
15814     readonly RGBA: GLenum;
15815     readonly RGBA4: GLenum;
15816     readonly SAMPLER_2D: GLenum;
15817     readonly SAMPLER_CUBE: GLenum;
15818     readonly SAMPLES: GLenum;
15819     readonly SAMPLE_ALPHA_TO_COVERAGE: GLenum;
15820     readonly SAMPLE_BUFFERS: GLenum;
15821     readonly SAMPLE_COVERAGE: GLenum;
15822     readonly SAMPLE_COVERAGE_INVERT: GLenum;
15823     readonly SAMPLE_COVERAGE_VALUE: GLenum;
15824     readonly SCISSOR_BOX: GLenum;
15825     readonly SCISSOR_TEST: GLenum;
15826     readonly SHADER_TYPE: GLenum;
15827     readonly SHADING_LANGUAGE_VERSION: GLenum;
15828     readonly SHORT: GLenum;
15829     readonly SRC_ALPHA: GLenum;
15830     readonly SRC_ALPHA_SATURATE: GLenum;
15831     readonly SRC_COLOR: GLenum;
15832     readonly STATIC_DRAW: GLenum;
15833     readonly STENCIL_ATTACHMENT: GLenum;
15834     readonly STENCIL_BACK_FAIL: GLenum;
15835     readonly STENCIL_BACK_FUNC: GLenum;
15836     readonly STENCIL_BACK_PASS_DEPTH_FAIL: GLenum;
15837     readonly STENCIL_BACK_PASS_DEPTH_PASS: GLenum;
15838     readonly STENCIL_BACK_REF: GLenum;
15839     readonly STENCIL_BACK_VALUE_MASK: GLenum;
15840     readonly STENCIL_BACK_WRITEMASK: GLenum;
15841     readonly STENCIL_BITS: GLenum;
15842     readonly STENCIL_BUFFER_BIT: GLenum;
15843     readonly STENCIL_CLEAR_VALUE: GLenum;
15844     readonly STENCIL_FAIL: GLenum;
15845     readonly STENCIL_FUNC: GLenum;
15846     readonly STENCIL_INDEX8: GLenum;
15847     readonly STENCIL_PASS_DEPTH_FAIL: GLenum;
15848     readonly STENCIL_PASS_DEPTH_PASS: GLenum;
15849     readonly STENCIL_REF: GLenum;
15850     readonly STENCIL_TEST: GLenum;
15851     readonly STENCIL_VALUE_MASK: GLenum;
15852     readonly STENCIL_WRITEMASK: GLenum;
15853     readonly STREAM_DRAW: GLenum;
15854     readonly SUBPIXEL_BITS: GLenum;
15855     readonly TEXTURE: GLenum;
15856     readonly TEXTURE0: GLenum;
15857     readonly TEXTURE1: GLenum;
15858     readonly TEXTURE10: GLenum;
15859     readonly TEXTURE11: GLenum;
15860     readonly TEXTURE12: GLenum;
15861     readonly TEXTURE13: GLenum;
15862     readonly TEXTURE14: GLenum;
15863     readonly TEXTURE15: GLenum;
15864     readonly TEXTURE16: GLenum;
15865     readonly TEXTURE17: GLenum;
15866     readonly TEXTURE18: GLenum;
15867     readonly TEXTURE19: GLenum;
15868     readonly TEXTURE2: GLenum;
15869     readonly TEXTURE20: GLenum;
15870     readonly TEXTURE21: GLenum;
15871     readonly TEXTURE22: GLenum;
15872     readonly TEXTURE23: GLenum;
15873     readonly TEXTURE24: GLenum;
15874     readonly TEXTURE25: GLenum;
15875     readonly TEXTURE26: GLenum;
15876     readonly TEXTURE27: GLenum;
15877     readonly TEXTURE28: GLenum;
15878     readonly TEXTURE29: GLenum;
15879     readonly TEXTURE3: GLenum;
15880     readonly TEXTURE30: GLenum;
15881     readonly TEXTURE31: GLenum;
15882     readonly TEXTURE4: GLenum;
15883     readonly TEXTURE5: GLenum;
15884     readonly TEXTURE6: GLenum;
15885     readonly TEXTURE7: GLenum;
15886     readonly TEXTURE8: GLenum;
15887     readonly TEXTURE9: GLenum;
15888     readonly TEXTURE_2D: GLenum;
15889     readonly TEXTURE_BINDING_2D: GLenum;
15890     readonly TEXTURE_BINDING_CUBE_MAP: GLenum;
15891     readonly TEXTURE_CUBE_MAP: GLenum;
15892     readonly TEXTURE_CUBE_MAP_NEGATIVE_X: GLenum;
15893     readonly TEXTURE_CUBE_MAP_NEGATIVE_Y: GLenum;
15894     readonly TEXTURE_CUBE_MAP_NEGATIVE_Z: GLenum;
15895     readonly TEXTURE_CUBE_MAP_POSITIVE_X: GLenum;
15896     readonly TEXTURE_CUBE_MAP_POSITIVE_Y: GLenum;
15897     readonly TEXTURE_CUBE_MAP_POSITIVE_Z: GLenum;
15898     readonly TEXTURE_MAG_FILTER: GLenum;
15899     readonly TEXTURE_MIN_FILTER: GLenum;
15900     readonly TEXTURE_WRAP_S: GLenum;
15901     readonly TEXTURE_WRAP_T: GLenum;
15902     readonly TRIANGLES: GLenum;
15903     readonly TRIANGLE_FAN: GLenum;
15904     readonly TRIANGLE_STRIP: GLenum;
15905     readonly UNPACK_ALIGNMENT: GLenum;
15906     readonly UNPACK_COLORSPACE_CONVERSION_WEBGL: GLenum;
15907     readonly UNPACK_FLIP_Y_WEBGL: GLenum;
15908     readonly UNPACK_PREMULTIPLY_ALPHA_WEBGL: GLenum;
15909     readonly UNSIGNED_BYTE: GLenum;
15910     readonly UNSIGNED_INT: GLenum;
15911     readonly UNSIGNED_SHORT: GLenum;
15912     readonly UNSIGNED_SHORT_4_4_4_4: GLenum;
15913     readonly UNSIGNED_SHORT_5_5_5_1: GLenum;
15914     readonly UNSIGNED_SHORT_5_6_5: GLenum;
15915     readonly VALIDATE_STATUS: GLenum;
15916     readonly VENDOR: GLenum;
15917     readonly VERSION: GLenum;
15918     readonly VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: GLenum;
15919     readonly VERTEX_ATTRIB_ARRAY_ENABLED: GLenum;
15920     readonly VERTEX_ATTRIB_ARRAY_NORMALIZED: GLenum;
15921     readonly VERTEX_ATTRIB_ARRAY_POINTER: GLenum;
15922     readonly VERTEX_ATTRIB_ARRAY_SIZE: GLenum;
15923     readonly VERTEX_ATTRIB_ARRAY_STRIDE: GLenum;
15924     readonly VERTEX_ATTRIB_ARRAY_TYPE: GLenum;
15925     readonly VERTEX_SHADER: GLenum;
15926     readonly VIEWPORT: GLenum;
15927     readonly ZERO: GLenum;
15928 }
15929
15930 interface WebGLRenderingContextOverloads {
15931     bufferData(target: GLenum, size: GLsizeiptr, usage: GLenum): void;
15932     bufferData(target: GLenum, data: BufferSource | null, usage: GLenum): void;
15933     bufferSubData(target: GLenum, offset: GLintptr, data: BufferSource): void;
15934     compressedTexImage2D(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, border: GLint, data: ArrayBufferView): void;
15935     compressedTexSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, data: ArrayBufferView): void;
15936     readPixels(x: GLint, y: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, pixels: ArrayBufferView | null): void;
15937     texImage2D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, border: GLint, format: GLenum, type: GLenum, pixels: ArrayBufferView | null): void;
15938     texImage2D(target: GLenum, level: GLint, internalformat: GLint, format: GLenum, type: GLenum, source: TexImageSource): void;
15939     texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, pixels: ArrayBufferView | null): void;
15940     texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, format: GLenum, type: GLenum, source: TexImageSource): void;
15941     uniform1fv(location: WebGLUniformLocation | null, v: Float32List): void;
15942     uniform1iv(location: WebGLUniformLocation | null, v: Int32List): void;
15943     uniform2fv(location: WebGLUniformLocation | null, v: Float32List): void;
15944     uniform2iv(location: WebGLUniformLocation | null, v: Int32List): void;
15945     uniform3fv(location: WebGLUniformLocation | null, v: Float32List): void;
15946     uniform3iv(location: WebGLUniformLocation | null, v: Int32List): void;
15947     uniform4fv(location: WebGLUniformLocation | null, v: Float32List): void;
15948     uniform4iv(location: WebGLUniformLocation | null, v: Int32List): void;
15949     uniformMatrix2fv(location: WebGLUniformLocation | null, transpose: GLboolean, value: Float32List): void;
15950     uniformMatrix3fv(location: WebGLUniformLocation | null, transpose: GLboolean, value: Float32List): void;
15951     uniformMatrix4fv(location: WebGLUniformLocation | null, transpose: GLboolean, value: Float32List): void;
15952 }
15953
15954 interface WebGLSampler {
15955 }
15956
15957 declare var WebGLSampler: {
15958     prototype: WebGLSampler;
15959     new(): WebGLSampler;
15960 };
15961
15962 /** 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. */
15963 interface WebGLShader {
15964 }
15965
15966 declare var WebGLShader: {
15967     prototype: WebGLShader;
15968     new(): WebGLShader;
15969 };
15970
15971 /** Part of the WebGL API and represents the information returned by calling the WebGLRenderingContext.getShaderPrecisionFormat() method. */
15972 interface WebGLShaderPrecisionFormat {
15973     readonly precision: GLint;
15974     readonly rangeMax: GLint;
15975     readonly rangeMin: GLint;
15976 }
15977
15978 declare var WebGLShaderPrecisionFormat: {
15979     prototype: WebGLShaderPrecisionFormat;
15980     new(): WebGLShaderPrecisionFormat;
15981 };
15982
15983 interface WebGLSync {
15984 }
15985
15986 declare var WebGLSync: {
15987     prototype: WebGLSync;
15988     new(): WebGLSync;
15989 };
15990
15991 /** Part of the WebGL API and represents an opaque texture object providing storage and state for texturing operations. */
15992 interface WebGLTexture {
15993 }
15994
15995 declare var WebGLTexture: {
15996     prototype: WebGLTexture;
15997     new(): WebGLTexture;
15998 };
15999
16000 interface WebGLTransformFeedback {
16001 }
16002
16003 declare var WebGLTransformFeedback: {
16004     prototype: WebGLTransformFeedback;
16005     new(): WebGLTransformFeedback;
16006 };
16007
16008 /** Part of the WebGL API and represents the location of a uniform variable in a shader program. */
16009 interface WebGLUniformLocation {
16010 }
16011
16012 declare var WebGLUniformLocation: {
16013     prototype: WebGLUniformLocation;
16014     new(): WebGLUniformLocation;
16015 };
16016
16017 interface WebGLVertexArrayObject {
16018 }
16019
16020 declare var WebGLVertexArrayObject: {
16021     prototype: WebGLVertexArrayObject;
16022     new(): WebGLVertexArrayObject;
16023 };
16024
16025 interface WebGLVertexArrayObjectOES {
16026 }
16027
16028 interface WebSocketEventMap {
16029     "close": CloseEvent;
16030     "error": Event;
16031     "message": MessageEvent;
16032     "open": Event;
16033 }
16034
16035 /** Provides the API for creating and managing a WebSocket connection to a server, as well as for sending and receiving data on the connection. */
16036 interface WebSocket extends EventTarget {
16037     /**
16038      * Returns a string that indicates how binary data from the WebSocket object is exposed to scripts:
16039      *
16040      * Can be set, to change how binary data is returned. The default is "blob".
16041      */
16042     binaryType: BinaryType;
16043     /**
16044      * 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.
16045      *
16046      * 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.)
16047      */
16048     readonly bufferedAmount: number;
16049     /** Returns the extensions selected by the server, if any. */
16050     readonly extensions: string;
16051     onclose: ((this: WebSocket, ev: CloseEvent) => any) | null;
16052     onerror: ((this: WebSocket, ev: Event) => any) | null;
16053     onmessage: ((this: WebSocket, ev: MessageEvent) => any) | null;
16054     onopen: ((this: WebSocket, ev: Event) => any) | null;
16055     /** 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. */
16056     readonly protocol: string;
16057     /** Returns the state of the WebSocket object's connection. It can have the values described below. */
16058     readonly readyState: number;
16059     /** Returns the URL that was used to establish the WebSocket connection. */
16060     readonly url: string;
16061     /** Closes the WebSocket connection, optionally using code as the the WebSocket connection close code and reason as the the WebSocket connection close reason. */
16062     close(code?: number, reason?: string): void;
16063     /** Transmits data using the WebSocket connection. data can be a string, a Blob, an ArrayBuffer, or an ArrayBufferView. */
16064     send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void;
16065     readonly CLOSED: number;
16066     readonly CLOSING: number;
16067     readonly CONNECTING: number;
16068     readonly OPEN: number;
16069     addEventListener<K extends keyof WebSocketEventMap>(type: K, listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
16070     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
16071     removeEventListener<K extends keyof WebSocketEventMap>(type: K, listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
16072     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
16073 }
16074
16075 declare var WebSocket: {
16076     prototype: WebSocket;
16077     new(url: string | URL, protocols?: string | string[]): WebSocket;
16078     readonly CLOSED: number;
16079     readonly CLOSING: number;
16080     readonly CONNECTING: number;
16081     readonly OPEN: number;
16082 };
16083
16084 /** Events that occur due to the user moving a mouse wheel or similar input device. */
16085 interface WheelEvent extends MouseEvent {
16086     readonly deltaMode: number;
16087     readonly deltaX: number;
16088     readonly deltaY: number;
16089     readonly deltaZ: number;
16090     readonly DOM_DELTA_LINE: number;
16091     readonly DOM_DELTA_PAGE: number;
16092     readonly DOM_DELTA_PIXEL: number;
16093 }
16094
16095 declare var WheelEvent: {
16096     prototype: WheelEvent;
16097     new(type: string, eventInitDict?: WheelEventInit): WheelEvent;
16098     readonly DOM_DELTA_LINE: number;
16099     readonly DOM_DELTA_PAGE: number;
16100     readonly DOM_DELTA_PIXEL: number;
16101 };
16102
16103 interface WindowEventMap extends GlobalEventHandlersEventMap, WindowEventHandlersEventMap {
16104     "devicemotion": DeviceMotionEvent;
16105     "deviceorientation": DeviceOrientationEvent;
16106     "gamepadconnected": GamepadEvent;
16107     "gamepaddisconnected": GamepadEvent;
16108     "orientationchange": Event;
16109 }
16110
16111 /** A window containing a DOM document; the document property points to the DOM document loaded in that window. */
16112 interface Window extends EventTarget, AnimationFrameProvider, GlobalEventHandlers, WindowEventHandlers, WindowLocalStorage, WindowOrWorkerGlobalScope, WindowSessionStorage {
16113     /** @deprecated This is a legacy alias of `navigator`. */
16114     readonly clientInformation: Navigator;
16115     /** Returns true if the window has been closed, false otherwise. */
16116     readonly closed: boolean;
16117     /** Defines a new custom element, mapping the given name to the given constructor as an autonomous custom element. */
16118     readonly customElements: CustomElementRegistry;
16119     readonly devicePixelRatio: number;
16120     readonly document: Document;
16121     /** @deprecated */
16122     readonly event: Event | undefined;
16123     /** @deprecated */
16124     readonly external: External;
16125     readonly frameElement: Element | null;
16126     readonly frames: WindowProxy;
16127     readonly history: History;
16128     readonly innerHeight: number;
16129     readonly innerWidth: number;
16130     readonly length: number;
16131     get location(): Location;
16132     set location(href: string | Location);
16133     /** Returns true if the location bar is visible; otherwise, returns false. */
16134     readonly locationbar: BarProp;
16135     /** Returns true if the menu bar is visible; otherwise, returns false. */
16136     readonly menubar: BarProp;
16137     name: string;
16138     readonly navigator: Navigator;
16139     /** Available only in secure contexts. */
16140     ondevicemotion: ((this: Window, ev: DeviceMotionEvent) => any) | null;
16141     /** Available only in secure contexts. */
16142     ondeviceorientation: ((this: Window, ev: DeviceOrientationEvent) => any) | null;
16143     /** @deprecated */
16144     onorientationchange: ((this: Window, ev: Event) => any) | null;
16145     opener: any;
16146     /** @deprecated */
16147     readonly orientation: number;
16148     readonly outerHeight: number;
16149     readonly outerWidth: number;
16150     /** @deprecated This is a legacy alias of `scrollX`. */
16151     readonly pageXOffset: number;
16152     /** @deprecated This is a legacy alias of `scrollY`. */
16153     readonly pageYOffset: number;
16154     /**
16155      * Refers to either the parent WindowProxy, or itself.
16156      *
16157      * It can rarely be null e.g. for contentWindow of an iframe that is already removed from the parent.
16158      */
16159     readonly parent: WindowProxy;
16160     /** Returns true if the personal bar is visible; otherwise, returns false. */
16161     readonly personalbar: BarProp;
16162     readonly screen: Screen;
16163     readonly screenLeft: number;
16164     readonly screenTop: number;
16165     readonly screenX: number;
16166     readonly screenY: number;
16167     readonly scrollX: number;
16168     readonly scrollY: number;
16169     /** Returns true if the scrollbars are visible; otherwise, returns false. */
16170     readonly scrollbars: BarProp;
16171     readonly self: Window & typeof globalThis;
16172     readonly speechSynthesis: SpeechSynthesis;
16173     /** @deprecated */
16174     status: string;
16175     /** Returns true if the status bar is visible; otherwise, returns false. */
16176     readonly statusbar: BarProp;
16177     /** Returns true if the toolbar is visible; otherwise, returns false. */
16178     readonly toolbar: BarProp;
16179     readonly top: WindowProxy | null;
16180     readonly visualViewport: VisualViewport;
16181     readonly window: Window & typeof globalThis;
16182     alert(message?: any): void;
16183     blur(): void;
16184     cancelIdleCallback(handle: number): void;
16185     /** @deprecated */
16186     captureEvents(): void;
16187     /** Closes the window. */
16188     close(): void;
16189     confirm(message?: string): boolean;
16190     /** Moves the focus to the window's browsing context, if any. */
16191     focus(): void;
16192     getComputedStyle(elt: Element, pseudoElt?: string | null): CSSStyleDeclaration;
16193     getSelection(): Selection | null;
16194     matchMedia(query: string): MediaQueryList;
16195     moveBy(x: number, y: number): void;
16196     moveTo(x: number, y: number): void;
16197     open(url?: string | URL, target?: string, features?: string): WindowProxy | null;
16198     /**
16199      * Posts a message to the given window. Messages can be structured objects, e.g. nested objects and arrays, can contain JavaScript values (strings, numbers, Date objects, etc), and can contain certain data objects such as File Blob, FileList, and ArrayBuffer objects.
16200      *
16201      * Objects listed in the transfer member of options are transferred, not just cloned, meaning that they are no longer usable on the sending side.
16202      *
16203      * A target origin can be specified using the targetOrigin member of options. If not provided, it defaults to "/". This default restricts the message to same-origin targets only.
16204      *
16205      * If the origin of the target window doesn't match the given target origin, the message is discarded, to avoid information leakage. To send the message to the target regardless of origin, set the target origin to "*".
16206      *
16207      * Throws a "DataCloneError" DOMException if transfer array contains duplicate objects or if message could not be cloned.
16208      */
16209     postMessage(message: any, targetOrigin: string, transfer?: Transferable[]): void;
16210     postMessage(message: any, options?: WindowPostMessageOptions): void;
16211     print(): void;
16212     prompt(message?: string, _default?: string): string | null;
16213     /** @deprecated */
16214     releaseEvents(): void;
16215     requestIdleCallback(callback: IdleRequestCallback, options?: IdleRequestOptions): number;
16216     resizeBy(x: number, y: number): void;
16217     resizeTo(width: number, height: number): void;
16218     scroll(options?: ScrollToOptions): void;
16219     scroll(x: number, y: number): void;
16220     scrollBy(options?: ScrollToOptions): void;
16221     scrollBy(x: number, y: number): void;
16222     scrollTo(options?: ScrollToOptions): void;
16223     scrollTo(x: number, y: number): void;
16224     /** Cancels the document load. */
16225     stop(): void;
16226     addEventListener<K extends keyof WindowEventMap>(type: K, listener: (this: Window, ev: WindowEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
16227     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
16228     removeEventListener<K extends keyof WindowEventMap>(type: K, listener: (this: Window, ev: WindowEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
16229     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
16230     [index: number]: Window;
16231 }
16232
16233 declare var Window: {
16234     prototype: Window;
16235     new(): Window;
16236 };
16237
16238 interface WindowEventHandlersEventMap {
16239     "afterprint": Event;
16240     "beforeprint": Event;
16241     "beforeunload": BeforeUnloadEvent;
16242     "gamepadconnected": GamepadEvent;
16243     "gamepaddisconnected": GamepadEvent;
16244     "hashchange": HashChangeEvent;
16245     "languagechange": Event;
16246     "message": MessageEvent;
16247     "messageerror": MessageEvent;
16248     "offline": Event;
16249     "online": Event;
16250     "pagehide": PageTransitionEvent;
16251     "pageshow": PageTransitionEvent;
16252     "popstate": PopStateEvent;
16253     "rejectionhandled": PromiseRejectionEvent;
16254     "storage": StorageEvent;
16255     "unhandledrejection": PromiseRejectionEvent;
16256     "unload": Event;
16257 }
16258
16259 interface WindowEventHandlers {
16260     onafterprint: ((this: WindowEventHandlers, ev: Event) => any) | null;
16261     onbeforeprint: ((this: WindowEventHandlers, ev: Event) => any) | null;
16262     onbeforeunload: ((this: WindowEventHandlers, ev: BeforeUnloadEvent) => any) | null;
16263     ongamepadconnected: ((this: WindowEventHandlers, ev: GamepadEvent) => any) | null;
16264     ongamepaddisconnected: ((this: WindowEventHandlers, ev: GamepadEvent) => any) | null;
16265     onhashchange: ((this: WindowEventHandlers, ev: HashChangeEvent) => any) | null;
16266     onlanguagechange: ((this: WindowEventHandlers, ev: Event) => any) | null;
16267     onmessage: ((this: WindowEventHandlers, ev: MessageEvent) => any) | null;
16268     onmessageerror: ((this: WindowEventHandlers, ev: MessageEvent) => any) | null;
16269     onoffline: ((this: WindowEventHandlers, ev: Event) => any) | null;
16270     ononline: ((this: WindowEventHandlers, ev: Event) => any) | null;
16271     onpagehide: ((this: WindowEventHandlers, ev: PageTransitionEvent) => any) | null;
16272     onpageshow: ((this: WindowEventHandlers, ev: PageTransitionEvent) => any) | null;
16273     onpopstate: ((this: WindowEventHandlers, ev: PopStateEvent) => any) | null;
16274     onrejectionhandled: ((this: WindowEventHandlers, ev: PromiseRejectionEvent) => any) | null;
16275     onstorage: ((this: WindowEventHandlers, ev: StorageEvent) => any) | null;
16276     onunhandledrejection: ((this: WindowEventHandlers, ev: PromiseRejectionEvent) => any) | null;
16277     onunload: ((this: WindowEventHandlers, ev: Event) => any) | null;
16278     addEventListener<K extends keyof WindowEventHandlersEventMap>(type: K, listener: (this: WindowEventHandlers, ev: WindowEventHandlersEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
16279     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
16280     removeEventListener<K extends keyof WindowEventHandlersEventMap>(type: K, listener: (this: WindowEventHandlers, ev: WindowEventHandlersEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
16281     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
16282 }
16283
16284 interface WindowLocalStorage {
16285     readonly localStorage: Storage;
16286 }
16287
16288 interface WindowOrWorkerGlobalScope {
16289     /** Available only in secure contexts. */
16290     readonly caches: CacheStorage;
16291     readonly crossOriginIsolated: boolean;
16292     readonly crypto: Crypto;
16293     readonly indexedDB: IDBFactory;
16294     readonly isSecureContext: boolean;
16295     readonly origin: string;
16296     readonly performance: Performance;
16297     atob(data: string): string;
16298     btoa(data: string): string;
16299     clearInterval(handle?: number): void;
16300     clearTimeout(handle?: number): void;
16301     createImageBitmap(image: ImageBitmapSource, options?: ImageBitmapOptions): Promise<ImageBitmap>;
16302     createImageBitmap(image: ImageBitmapSource, sx: number, sy: number, sw: number, sh: number, options?: ImageBitmapOptions): Promise<ImageBitmap>;
16303     fetch(input: RequestInfo, init?: RequestInit): Promise<Response>;
16304     queueMicrotask(callback: VoidFunction): void;
16305     setInterval(handler: TimerHandler, timeout?: number, ...arguments: any[]): number;
16306     setTimeout(handler: TimerHandler, timeout?: number, ...arguments: any[]): number;
16307 }
16308
16309 interface WindowSessionStorage {
16310     readonly sessionStorage: Storage;
16311 }
16312
16313 interface WorkerEventMap extends AbstractWorkerEventMap {
16314     "message": MessageEvent;
16315     "messageerror": MessageEvent;
16316 }
16317
16318 /** 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. */
16319 interface Worker extends EventTarget, AbstractWorker {
16320     onmessage: ((this: Worker, ev: MessageEvent) => any) | null;
16321     onmessageerror: ((this: Worker, ev: MessageEvent) => any) | null;
16322     /** 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. */
16323     postMessage(message: any, transfer: Transferable[]): void;
16324     postMessage(message: any, options?: StructuredSerializeOptions): void;
16325     /** Aborts worker's associated global environment. */
16326     terminate(): void;
16327     addEventListener<K extends keyof WorkerEventMap>(type: K, listener: (this: Worker, ev: WorkerEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
16328     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
16329     removeEventListener<K extends keyof WorkerEventMap>(type: K, listener: (this: Worker, ev: WorkerEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
16330     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
16331 }
16332
16333 declare var Worker: {
16334     prototype: Worker;
16335     new(scriptURL: string | URL, options?: WorkerOptions): Worker;
16336 };
16337
16338 /** Available only in secure contexts. */
16339 interface Worklet {
16340     /**
16341      * Loads and executes the module script given by moduleURL into all of worklet's global scopes. It can also create additional global scopes as part of this process, depending on the worklet type. The returned promise will fulfill once the script has been successfully loaded and run in all global scopes.
16342      *
16343      * The credentials option can be set to a credentials mode to modify the script-fetching process. It defaults to "same-origin".
16344      *
16345      * Any failures in fetching the script or its dependencies will cause the returned promise to be rejected with an "AbortError" DOMException. Any errors in parsing the script or its dependencies will cause the returned promise to be rejected with the exception generated during parsing.
16346      */
16347     addModule(moduleURL: string | URL, options?: WorkletOptions): Promise<void>;
16348 }
16349
16350 declare var Worklet: {
16351     prototype: Worklet;
16352     new(): Worklet;
16353 };
16354
16355 /** 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. */
16356 interface WritableStream<W = any> {
16357     readonly locked: boolean;
16358     abort(reason?: any): Promise<void>;
16359     close(): Promise<void>;
16360     getWriter(): WritableStreamDefaultWriter<W>;
16361 }
16362
16363 declare var WritableStream: {
16364     prototype: WritableStream;
16365     new<W = any>(underlyingSink?: UnderlyingSink<W>, strategy?: QueuingStrategy<W>): WritableStream<W>;
16366 };
16367
16368 /** 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. */
16369 interface WritableStreamDefaultController {
16370     error(e?: any): void;
16371 }
16372
16373 declare var WritableStreamDefaultController: {
16374     prototype: WritableStreamDefaultController;
16375     new(): WritableStreamDefaultController;
16376 };
16377
16378 /** 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. */
16379 interface WritableStreamDefaultWriter<W = any> {
16380     readonly closed: Promise<undefined>;
16381     readonly desiredSize: number | null;
16382     readonly ready: Promise<undefined>;
16383     abort(reason?: any): Promise<void>;
16384     close(): Promise<void>;
16385     releaseLock(): void;
16386     write(chunk?: W): Promise<void>;
16387 }
16388
16389 declare var WritableStreamDefaultWriter: {
16390     prototype: WritableStreamDefaultWriter;
16391     new<W = any>(stream: WritableStream<W>): WritableStreamDefaultWriter<W>;
16392 };
16393
16394 /** 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. */
16395 interface XMLDocument extends Document {
16396     addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: XMLDocument, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
16397     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
16398     removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: XMLDocument, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
16399     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
16400 }
16401
16402 declare var XMLDocument: {
16403     prototype: XMLDocument;
16404     new(): XMLDocument;
16405 };
16406
16407 interface XMLHttpRequestEventMap extends XMLHttpRequestEventTargetEventMap {
16408     "readystatechange": Event;
16409 }
16410
16411 /** 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. */
16412 interface XMLHttpRequest extends XMLHttpRequestEventTarget {
16413     onreadystatechange: ((this: XMLHttpRequest, ev: Event) => any) | null;
16414     /** Returns client's state. */
16415     readonly readyState: number;
16416     /** Returns the response body. */
16417     readonly response: any;
16418     /**
16419      * Returns response as text.
16420      *
16421      * Throws an "InvalidStateError" DOMException if responseType is not the empty string or "text".
16422      */
16423     readonly responseText: string;
16424     /**
16425      * Returns the response type.
16426      *
16427      * Can be set to change the response type. Values are: the empty string (default), "arraybuffer", "blob", "document", "json", and "text".
16428      *
16429      * When set: setting to "document" is ignored if current global object is not a Window object.
16430      *
16431      * When set: throws an "InvalidStateError" DOMException if state is loading or done.
16432      *
16433      * When set: throws an "InvalidAccessError" DOMException if the synchronous flag is set and current global object is a Window object.
16434      */
16435     responseType: XMLHttpRequestResponseType;
16436     readonly responseURL: string;
16437     /**
16438      * Returns the response as document.
16439      *
16440      * Throws an "InvalidStateError" DOMException if responseType is not the empty string or "document".
16441      */
16442     readonly responseXML: Document | null;
16443     readonly status: number;
16444     readonly statusText: string;
16445     /**
16446      * 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 this's synchronous flag is unset, a timeout event will then be dispatched, or a "TimeoutError" DOMException will be thrown otherwise (for the send() method).
16447      *
16448      * When set: throws an "InvalidAccessError" DOMException if the synchronous flag is set and current global object is a Window object.
16449      */
16450     timeout: number;
16451     /** Returns the associated XMLHttpRequestUpload object. It can be used to gather transmission information when data is transferred to a server. */
16452     readonly upload: XMLHttpRequestUpload;
16453     /**
16454      * 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.
16455      *
16456      * When set: throws an "InvalidStateError" DOMException if state is not unsent or opened, or if the send() flag is set.
16457      */
16458     withCredentials: boolean;
16459     /** Cancels any network activity. */
16460     abort(): void;
16461     getAllResponseHeaders(): string;
16462     getResponseHeader(name: string): string | null;
16463     /**
16464      * Sets the request method, request URL, and synchronous flag.
16465      *
16466      * Throws a "SyntaxError" DOMException if either method is not a valid method or url cannot be parsed.
16467      *
16468      * Throws a "SecurityError" DOMException if method is a case-insensitive match for `CONNECT`, `TRACE`, or `TRACK`.
16469      *
16470      * 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.
16471      */
16472     open(method: string, url: string | URL): void;
16473     open(method: string, url: string | URL, async: boolean, username?: string | null, password?: string | null): void;
16474     /**
16475      * Acts as if the `Content-Type` header value for a response is mime. (It does not change the header.)
16476      *
16477      * Throws an "InvalidStateError" DOMException if state is loading or done.
16478      */
16479     overrideMimeType(mime: string): void;
16480     /**
16481      * Initiates the request. The body argument provides the request body, if any, and is ignored if the request method is GET or HEAD.
16482      *
16483      * Throws an "InvalidStateError" DOMException if either state is not opened or the send() flag is set.
16484      */
16485     send(body?: Document | XMLHttpRequestBodyInit | null): void;
16486     /**
16487      * Combines a header in author request headers.
16488      *
16489      * Throws an "InvalidStateError" DOMException if either state is not opened or the send() flag is set.
16490      *
16491      * Throws a "SyntaxError" DOMException if name is not a header name or if value is not a header value.
16492      */
16493     setRequestHeader(name: string, value: string): void;
16494     readonly DONE: number;
16495     readonly HEADERS_RECEIVED: number;
16496     readonly LOADING: number;
16497     readonly OPENED: number;
16498     readonly UNSENT: number;
16499     addEventListener<K extends keyof XMLHttpRequestEventMap>(type: K, listener: (this: XMLHttpRequest, ev: XMLHttpRequestEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
16500     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
16501     removeEventListener<K extends keyof XMLHttpRequestEventMap>(type: K, listener: (this: XMLHttpRequest, ev: XMLHttpRequestEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
16502     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
16503 }
16504
16505 declare var XMLHttpRequest: {
16506     prototype: XMLHttpRequest;
16507     new(): XMLHttpRequest;
16508     readonly DONE: number;
16509     readonly HEADERS_RECEIVED: number;
16510     readonly LOADING: number;
16511     readonly OPENED: number;
16512     readonly UNSENT: number;
16513 };
16514
16515 interface XMLHttpRequestEventTargetEventMap {
16516     "abort": ProgressEvent<XMLHttpRequestEventTarget>;
16517     "error": ProgressEvent<XMLHttpRequestEventTarget>;
16518     "load": ProgressEvent<XMLHttpRequestEventTarget>;
16519     "loadend": ProgressEvent<XMLHttpRequestEventTarget>;
16520     "loadstart": ProgressEvent<XMLHttpRequestEventTarget>;
16521     "progress": ProgressEvent<XMLHttpRequestEventTarget>;
16522     "timeout": ProgressEvent<XMLHttpRequestEventTarget>;
16523 }
16524
16525 interface XMLHttpRequestEventTarget extends EventTarget {
16526     onabort: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
16527     onerror: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
16528     onload: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
16529     onloadend: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
16530     onloadstart: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
16531     onprogress: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
16532     ontimeout: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
16533     addEventListener<K extends keyof XMLHttpRequestEventTargetEventMap>(type: K, listener: (this: XMLHttpRequestEventTarget, ev: XMLHttpRequestEventTargetEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
16534     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
16535     removeEventListener<K extends keyof XMLHttpRequestEventTargetEventMap>(type: K, listener: (this: XMLHttpRequestEventTarget, ev: XMLHttpRequestEventTargetEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
16536     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
16537 }
16538
16539 declare var XMLHttpRequestEventTarget: {
16540     prototype: XMLHttpRequestEventTarget;
16541     new(): XMLHttpRequestEventTarget;
16542 };
16543
16544 interface XMLHttpRequestUpload extends XMLHttpRequestEventTarget {
16545     addEventListener<K extends keyof XMLHttpRequestEventTargetEventMap>(type: K, listener: (this: XMLHttpRequestUpload, ev: XMLHttpRequestEventTargetEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
16546     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
16547     removeEventListener<K extends keyof XMLHttpRequestEventTargetEventMap>(type: K, listener: (this: XMLHttpRequestUpload, ev: XMLHttpRequestEventTargetEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
16548     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
16549 }
16550
16551 declare var XMLHttpRequestUpload: {
16552     prototype: XMLHttpRequestUpload;
16553     new(): XMLHttpRequestUpload;
16554 };
16555
16556 /** Provides the serializeToString() method to construct an XML string representing a DOM tree. */
16557 interface XMLSerializer {
16558     serializeToString(root: Node): string;
16559 }
16560
16561 declare var XMLSerializer: {
16562     prototype: XMLSerializer;
16563     new(): XMLSerializer;
16564 };
16565
16566 /** The XPathEvaluator interface allows to compile and evaluate XPath expressions. */
16567 interface XPathEvaluator extends XPathEvaluatorBase {
16568 }
16569
16570 declare var XPathEvaluator: {
16571     prototype: XPathEvaluator;
16572     new(): XPathEvaluator;
16573 };
16574
16575 interface XPathEvaluatorBase {
16576     createExpression(expression: string, resolver?: XPathNSResolver | null): XPathExpression;
16577     createNSResolver(nodeResolver: Node): XPathNSResolver;
16578     evaluate(expression: string, contextNode: Node, resolver?: XPathNSResolver | null, type?: number, result?: XPathResult | null): XPathResult;
16579 }
16580
16581 /** This interface is a compiled XPath expression that can be evaluated on a document or specific node to return information its DOM tree. */
16582 interface XPathExpression {
16583     evaluate(contextNode: Node, type?: number, result?: XPathResult | null): XPathResult;
16584 }
16585
16586 declare var XPathExpression: {
16587     prototype: XPathExpression;
16588     new(): XPathExpression;
16589 };
16590
16591 /** The results generated by evaluating an XPath expression within the context of a given node. */
16592 interface XPathResult {
16593     readonly booleanValue: boolean;
16594     readonly invalidIteratorState: boolean;
16595     readonly numberValue: number;
16596     readonly resultType: number;
16597     readonly singleNodeValue: Node | null;
16598     readonly snapshotLength: number;
16599     readonly stringValue: string;
16600     iterateNext(): Node | null;
16601     snapshotItem(index: number): Node | null;
16602     readonly ANY_TYPE: number;
16603     readonly ANY_UNORDERED_NODE_TYPE: number;
16604     readonly BOOLEAN_TYPE: number;
16605     readonly FIRST_ORDERED_NODE_TYPE: number;
16606     readonly NUMBER_TYPE: number;
16607     readonly ORDERED_NODE_ITERATOR_TYPE: number;
16608     readonly ORDERED_NODE_SNAPSHOT_TYPE: number;
16609     readonly STRING_TYPE: number;
16610     readonly UNORDERED_NODE_ITERATOR_TYPE: number;
16611     readonly UNORDERED_NODE_SNAPSHOT_TYPE: number;
16612 }
16613
16614 declare var XPathResult: {
16615     prototype: XPathResult;
16616     new(): XPathResult;
16617     readonly ANY_TYPE: number;
16618     readonly ANY_UNORDERED_NODE_TYPE: number;
16619     readonly BOOLEAN_TYPE: number;
16620     readonly FIRST_ORDERED_NODE_TYPE: number;
16621     readonly NUMBER_TYPE: number;
16622     readonly ORDERED_NODE_ITERATOR_TYPE: number;
16623     readonly ORDERED_NODE_SNAPSHOT_TYPE: number;
16624     readonly STRING_TYPE: number;
16625     readonly UNORDERED_NODE_ITERATOR_TYPE: number;
16626     readonly UNORDERED_NODE_SNAPSHOT_TYPE: number;
16627 };
16628
16629 /** 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. */
16630 interface XSLTProcessor {
16631     clearParameters(): void;
16632     getParameter(namespaceURI: string | null, localName: string): any;
16633     importStylesheet(style: Node): void;
16634     removeParameter(namespaceURI: string | null, localName: string): void;
16635     reset(): void;
16636     setParameter(namespaceURI: string | null, localName: string, value: any): void;
16637     transformToDocument(source: Node): Document;
16638     transformToFragment(source: Node, output: Document): DocumentFragment;
16639 }
16640
16641 declare var XSLTProcessor: {
16642     prototype: XSLTProcessor;
16643     new(): XSLTProcessor;
16644 };
16645
16646 interface Console {
16647     assert(condition?: boolean, ...data: any[]): void;
16648     clear(): void;
16649     count(label?: string): void;
16650     countReset(label?: string): void;
16651     debug(...data: any[]): void;
16652     dir(item?: any, options?: any): void;
16653     dirxml(...data: any[]): void;
16654     error(...data: any[]): void;
16655     group(...data: any[]): void;
16656     groupCollapsed(...data: any[]): void;
16657     groupEnd(): void;
16658     info(...data: any[]): void;
16659     log(...data: any[]): void;
16660     table(tabularData?: any, properties?: string[]): void;
16661     time(label?: string): void;
16662     timeEnd(label?: string): void;
16663     timeLog(label?: string, ...data: any[]): void;
16664     timeStamp(label?: string): void;
16665     trace(...data: any[]): void;
16666     warn(...data: any[]): void;
16667 }
16668
16669 declare var console: Console;
16670
16671 /** Holds useful CSS-related methods. No object with this interface are implemented: it contains only static methods and therefore is a utilitarian interface. */
16672 declare namespace CSS {
16673     function escape(ident: string): string;
16674     function supports(property: string, value: string): boolean;
16675     function supports(conditionText: string): boolean;
16676 }
16677
16678 declare namespace WebAssembly {
16679     interface CompileError extends Error {
16680     }
16681
16682     var CompileError: {
16683         prototype: CompileError;
16684         new(message?: string): CompileError;
16685         (message?: string): CompileError;
16686     };
16687
16688     interface Global {
16689         value: any;
16690         valueOf(): any;
16691     }
16692
16693     var Global: {
16694         prototype: Global;
16695         new(descriptor: GlobalDescriptor, v?: any): Global;
16696     };
16697
16698     interface Instance {
16699         readonly exports: Exports;
16700     }
16701
16702     var Instance: {
16703         prototype: Instance;
16704         new(module: Module, importObject?: Imports): Instance;
16705     };
16706
16707     interface LinkError extends Error {
16708     }
16709
16710     var LinkError: {
16711         prototype: LinkError;
16712         new(message?: string): LinkError;
16713         (message?: string): LinkError;
16714     };
16715
16716     interface Memory {
16717         readonly buffer: ArrayBuffer;
16718         grow(delta: number): number;
16719     }
16720
16721     var Memory: {
16722         prototype: Memory;
16723         new(descriptor: MemoryDescriptor): Memory;
16724     };
16725
16726     interface Module {
16727     }
16728
16729     var Module: {
16730         prototype: Module;
16731         new(bytes: BufferSource): Module;
16732         customSections(moduleObject: Module, sectionName: string): ArrayBuffer[];
16733         exports(moduleObject: Module): ModuleExportDescriptor[];
16734         imports(moduleObject: Module): ModuleImportDescriptor[];
16735     };
16736
16737     interface RuntimeError extends Error {
16738     }
16739
16740     var RuntimeError: {
16741         prototype: RuntimeError;
16742         new(message?: string): RuntimeError;
16743         (message?: string): RuntimeError;
16744     };
16745
16746     interface Table {
16747         readonly length: number;
16748         get(index: number): any;
16749         grow(delta: number, value?: any): number;
16750         set(index: number, value?: any): void;
16751     }
16752
16753     var Table: {
16754         prototype: Table;
16755         new(descriptor: TableDescriptor, value?: any): Table;
16756     };
16757
16758     interface GlobalDescriptor {
16759         mutable?: boolean;
16760         value: ValueType;
16761     }
16762
16763     interface MemoryDescriptor {
16764         initial: number;
16765         maximum?: number;
16766         shared?: boolean;
16767     }
16768
16769     interface ModuleExportDescriptor {
16770         kind: ImportExportKind;
16771         name: string;
16772     }
16773
16774     interface ModuleImportDescriptor {
16775         kind: ImportExportKind;
16776         module: string;
16777         name: string;
16778     }
16779
16780     interface TableDescriptor {
16781         element: TableKind;
16782         initial: number;
16783         maximum?: number;
16784     }
16785
16786     interface WebAssemblyInstantiatedSource {
16787         instance: Instance;
16788         module: Module;
16789     }
16790
16791     type ImportExportKind = "function" | "global" | "memory" | "table";
16792     type TableKind = "anyfunc" | "externref";
16793     type ValueType = "anyfunc" | "externref" | "f32" | "f64" | "i32" | "i64";
16794     type ExportValue = Function | Global | Memory | Table;
16795     type Exports = Record<string, ExportValue>;
16796     type ImportValue = ExportValue | number;
16797     type Imports = Record<string, ModuleImports>;
16798     type ModuleImports = Record<string, ImportValue>;
16799     function compile(bytes: BufferSource): Promise<Module>;
16800     function compileStreaming(source: Response | PromiseLike<Response>): Promise<Module>;
16801     function instantiate(bytes: BufferSource, importObject?: Imports): Promise<WebAssemblyInstantiatedSource>;
16802     function instantiate(moduleObject: Module, importObject?: Imports): Promise<Instance>;
16803     function instantiateStreaming(source: Response | PromiseLike<Response>, importObject?: Imports): Promise<WebAssemblyInstantiatedSource>;
16804     function validate(bytes: BufferSource): boolean;
16805 }
16806
16807 interface BlobCallback {
16808     (blob: Blob | null): void;
16809 }
16810
16811 interface CustomElementConstructor {
16812     new (...params: any[]): HTMLElement;
16813 }
16814
16815 interface DecodeErrorCallback {
16816     (error: DOMException): void;
16817 }
16818
16819 interface DecodeSuccessCallback {
16820     (decodedData: AudioBuffer): void;
16821 }
16822
16823 interface ErrorCallback {
16824     (err: DOMException): void;
16825 }
16826
16827 interface FileCallback {
16828     (file: File): void;
16829 }
16830
16831 interface FileSystemEntriesCallback {
16832     (entries: FileSystemEntry[]): void;
16833 }
16834
16835 interface FileSystemEntryCallback {
16836     (entry: FileSystemEntry): void;
16837 }
16838
16839 interface FrameRequestCallback {
16840     (time: DOMHighResTimeStamp): void;
16841 }
16842
16843 interface FunctionStringCallback {
16844     (data: string): void;
16845 }
16846
16847 interface IdleRequestCallback {
16848     (deadline: IdleDeadline): void;
16849 }
16850
16851 interface IntersectionObserverCallback {
16852     (entries: IntersectionObserverEntry[], observer: IntersectionObserver): void;
16853 }
16854
16855 interface MediaSessionActionHandler {
16856     (details: MediaSessionActionDetails): void;
16857 }
16858
16859 interface MutationCallback {
16860     (mutations: MutationRecord[], observer: MutationObserver): void;
16861 }
16862
16863 interface NotificationPermissionCallback {
16864     (permission: NotificationPermission): void;
16865 }
16866
16867 interface OnBeforeUnloadEventHandlerNonNull {
16868     (event: Event): string | null;
16869 }
16870
16871 interface OnErrorEventHandlerNonNull {
16872     (event: Event | string, source?: string, lineno?: number, colno?: number, error?: Error): any;
16873 }
16874
16875 interface PerformanceObserverCallback {
16876     (entries: PerformanceObserverEntryList, observer: PerformanceObserver): void;
16877 }
16878
16879 interface PositionCallback {
16880     (position: GeolocationPosition): void;
16881 }
16882
16883 interface PositionErrorCallback {
16884     (positionError: GeolocationPositionError): void;
16885 }
16886
16887 interface QueuingStrategySize<T = any> {
16888     (chunk: T): number;
16889 }
16890
16891 interface RTCPeerConnectionErrorCallback {
16892     (error: DOMException): void;
16893 }
16894
16895 interface RTCSessionDescriptionCallback {
16896     (description: RTCSessionDescriptionInit): void;
16897 }
16898
16899 interface RemotePlaybackAvailabilityCallback {
16900     (available: boolean): void;
16901 }
16902
16903 interface ResizeObserverCallback {
16904     (entries: ResizeObserverEntry[], observer: ResizeObserver): void;
16905 }
16906
16907 interface TransformerFlushCallback<O> {
16908     (controller: TransformStreamDefaultController<O>): void | PromiseLike<void>;
16909 }
16910
16911 interface TransformerStartCallback<O> {
16912     (controller: TransformStreamDefaultController<O>): any;
16913 }
16914
16915 interface TransformerTransformCallback<I, O> {
16916     (chunk: I, controller: TransformStreamDefaultController<O>): void | PromiseLike<void>;
16917 }
16918
16919 interface UnderlyingSinkAbortCallback {
16920     (reason?: any): void | PromiseLike<void>;
16921 }
16922
16923 interface UnderlyingSinkCloseCallback {
16924     (): void | PromiseLike<void>;
16925 }
16926
16927 interface UnderlyingSinkStartCallback {
16928     (controller: WritableStreamDefaultController): any;
16929 }
16930
16931 interface UnderlyingSinkWriteCallback<W> {
16932     (chunk: W, controller: WritableStreamDefaultController): void | PromiseLike<void>;
16933 }
16934
16935 interface UnderlyingSourceCancelCallback {
16936     (reason?: any): void | PromiseLike<void>;
16937 }
16938
16939 interface UnderlyingSourcePullCallback<R> {
16940     (controller: ReadableStreamController<R>): void | PromiseLike<void>;
16941 }
16942
16943 interface UnderlyingSourceStartCallback<R> {
16944     (controller: ReadableStreamController<R>): any;
16945 }
16946
16947 interface VoidFunction {
16948     (): void;
16949 }
16950
16951 interface HTMLElementTagNameMap {
16952     "a": HTMLAnchorElement;
16953     "abbr": HTMLElement;
16954     "address": HTMLElement;
16955     "area": HTMLAreaElement;
16956     "article": HTMLElement;
16957     "aside": HTMLElement;
16958     "audio": HTMLAudioElement;
16959     "b": HTMLElement;
16960     "base": HTMLBaseElement;
16961     "bdi": HTMLElement;
16962     "bdo": HTMLElement;
16963     "blockquote": HTMLQuoteElement;
16964     "body": HTMLBodyElement;
16965     "br": HTMLBRElement;
16966     "button": HTMLButtonElement;
16967     "canvas": HTMLCanvasElement;
16968     "caption": HTMLTableCaptionElement;
16969     "cite": HTMLElement;
16970     "code": HTMLElement;
16971     "col": HTMLTableColElement;
16972     "colgroup": HTMLTableColElement;
16973     "data": HTMLDataElement;
16974     "datalist": HTMLDataListElement;
16975     "dd": HTMLElement;
16976     "del": HTMLModElement;
16977     "details": HTMLDetailsElement;
16978     "dfn": HTMLElement;
16979     "dialog": HTMLDialogElement;
16980     "dir": HTMLDirectoryElement;
16981     "div": HTMLDivElement;
16982     "dl": HTMLDListElement;
16983     "dt": HTMLElement;
16984     "em": HTMLElement;
16985     "embed": HTMLEmbedElement;
16986     "fieldset": HTMLFieldSetElement;
16987     "figcaption": HTMLElement;
16988     "figure": HTMLElement;
16989     "font": HTMLFontElement;
16990     "footer": HTMLElement;
16991     "form": HTMLFormElement;
16992     "frame": HTMLFrameElement;
16993     "frameset": HTMLFrameSetElement;
16994     "h1": HTMLHeadingElement;
16995     "h2": HTMLHeadingElement;
16996     "h3": HTMLHeadingElement;
16997     "h4": HTMLHeadingElement;
16998     "h5": HTMLHeadingElement;
16999     "h6": HTMLHeadingElement;
17000     "head": HTMLHeadElement;
17001     "header": HTMLElement;
17002     "hgroup": HTMLElement;
17003     "hr": HTMLHRElement;
17004     "html": HTMLHtmlElement;
17005     "i": HTMLElement;
17006     "iframe": HTMLIFrameElement;
17007     "img": HTMLImageElement;
17008     "input": HTMLInputElement;
17009     "ins": HTMLModElement;
17010     "kbd": HTMLElement;
17011     "label": HTMLLabelElement;
17012     "legend": HTMLLegendElement;
17013     "li": HTMLLIElement;
17014     "link": HTMLLinkElement;
17015     "main": HTMLElement;
17016     "map": HTMLMapElement;
17017     "mark": HTMLElement;
17018     "marquee": HTMLMarqueeElement;
17019     "menu": HTMLMenuElement;
17020     "meta": HTMLMetaElement;
17021     "meter": HTMLMeterElement;
17022     "nav": HTMLElement;
17023     "noscript": HTMLElement;
17024     "object": HTMLObjectElement;
17025     "ol": HTMLOListElement;
17026     "optgroup": HTMLOptGroupElement;
17027     "option": HTMLOptionElement;
17028     "output": HTMLOutputElement;
17029     "p": HTMLParagraphElement;
17030     "param": HTMLParamElement;
17031     "picture": HTMLPictureElement;
17032     "pre": HTMLPreElement;
17033     "progress": HTMLProgressElement;
17034     "q": HTMLQuoteElement;
17035     "rp": HTMLElement;
17036     "rt": HTMLElement;
17037     "ruby": HTMLElement;
17038     "s": HTMLElement;
17039     "samp": HTMLElement;
17040     "script": HTMLScriptElement;
17041     "section": HTMLElement;
17042     "select": HTMLSelectElement;
17043     "slot": HTMLSlotElement;
17044     "small": HTMLElement;
17045     "source": HTMLSourceElement;
17046     "span": HTMLSpanElement;
17047     "strong": HTMLElement;
17048     "style": HTMLStyleElement;
17049     "sub": HTMLElement;
17050     "summary": HTMLElement;
17051     "sup": HTMLElement;
17052     "table": HTMLTableElement;
17053     "tbody": HTMLTableSectionElement;
17054     "td": HTMLTableCellElement;
17055     "template": HTMLTemplateElement;
17056     "textarea": HTMLTextAreaElement;
17057     "tfoot": HTMLTableSectionElement;
17058     "th": HTMLTableCellElement;
17059     "thead": HTMLTableSectionElement;
17060     "time": HTMLTimeElement;
17061     "title": HTMLTitleElement;
17062     "tr": HTMLTableRowElement;
17063     "track": HTMLTrackElement;
17064     "u": HTMLElement;
17065     "ul": HTMLUListElement;
17066     "var": HTMLElement;
17067     "video": HTMLVideoElement;
17068     "wbr": HTMLElement;
17069 }
17070
17071 interface HTMLElementDeprecatedTagNameMap {
17072     "listing": HTMLPreElement;
17073     "xmp": HTMLPreElement;
17074 }
17075
17076 interface SVGElementTagNameMap {
17077     "a": SVGAElement;
17078     "animate": SVGAnimateElement;
17079     "animateMotion": SVGAnimateMotionElement;
17080     "animateTransform": SVGAnimateTransformElement;
17081     "circle": SVGCircleElement;
17082     "clipPath": SVGClipPathElement;
17083     "defs": SVGDefsElement;
17084     "desc": SVGDescElement;
17085     "ellipse": SVGEllipseElement;
17086     "feBlend": SVGFEBlendElement;
17087     "feColorMatrix": SVGFEColorMatrixElement;
17088     "feComponentTransfer": SVGFEComponentTransferElement;
17089     "feComposite": SVGFECompositeElement;
17090     "feConvolveMatrix": SVGFEConvolveMatrixElement;
17091     "feDiffuseLighting": SVGFEDiffuseLightingElement;
17092     "feDisplacementMap": SVGFEDisplacementMapElement;
17093     "feDistantLight": SVGFEDistantLightElement;
17094     "feDropShadow": SVGFEDropShadowElement;
17095     "feFlood": SVGFEFloodElement;
17096     "feFuncA": SVGFEFuncAElement;
17097     "feFuncB": SVGFEFuncBElement;
17098     "feFuncG": SVGFEFuncGElement;
17099     "feFuncR": SVGFEFuncRElement;
17100     "feGaussianBlur": SVGFEGaussianBlurElement;
17101     "feImage": SVGFEImageElement;
17102     "feMerge": SVGFEMergeElement;
17103     "feMergeNode": SVGFEMergeNodeElement;
17104     "feMorphology": SVGFEMorphologyElement;
17105     "feOffset": SVGFEOffsetElement;
17106     "fePointLight": SVGFEPointLightElement;
17107     "feSpecularLighting": SVGFESpecularLightingElement;
17108     "feSpotLight": SVGFESpotLightElement;
17109     "feTile": SVGFETileElement;
17110     "feTurbulence": SVGFETurbulenceElement;
17111     "filter": SVGFilterElement;
17112     "foreignObject": SVGForeignObjectElement;
17113     "g": SVGGElement;
17114     "image": SVGImageElement;
17115     "line": SVGLineElement;
17116     "linearGradient": SVGLinearGradientElement;
17117     "marker": SVGMarkerElement;
17118     "mask": SVGMaskElement;
17119     "metadata": SVGMetadataElement;
17120     "mpath": SVGMPathElement;
17121     "path": SVGPathElement;
17122     "pattern": SVGPatternElement;
17123     "polygon": SVGPolygonElement;
17124     "polyline": SVGPolylineElement;
17125     "radialGradient": SVGRadialGradientElement;
17126     "rect": SVGRectElement;
17127     "script": SVGScriptElement;
17128     "set": SVGSetElement;
17129     "stop": SVGStopElement;
17130     "style": SVGStyleElement;
17131     "svg": SVGSVGElement;
17132     "switch": SVGSwitchElement;
17133     "symbol": SVGSymbolElement;
17134     "text": SVGTextElement;
17135     "textPath": SVGTextPathElement;
17136     "title": SVGTitleElement;
17137     "tspan": SVGTSpanElement;
17138     "use": SVGUseElement;
17139     "view": SVGViewElement;
17140 }
17141
17142 /** @deprecated Directly use HTMLElementTagNameMap or SVGElementTagNameMap as appropriate, instead. */
17143 type ElementTagNameMap = HTMLElementTagNameMap & Pick<SVGElementTagNameMap, Exclude<keyof SVGElementTagNameMap, keyof HTMLElementTagNameMap>>;
17144
17145 declare var Audio: {
17146     new(src?: string): HTMLAudioElement;
17147 };
17148 declare var Image: {
17149     new(width?: number, height?: number): HTMLImageElement;
17150 };
17151 declare var Option: {
17152     new(text?: string, value?: string, defaultSelected?: boolean, selected?: boolean): HTMLOptionElement;
17153 };
17154 /** @deprecated This is a legacy alias of `navigator`. */
17155 declare var clientInformation: Navigator;
17156 /** Returns true if the window has been closed, false otherwise. */
17157 declare var closed: boolean;
17158 /** Defines a new custom element, mapping the given name to the given constructor as an autonomous custom element. */
17159 declare var customElements: CustomElementRegistry;
17160 declare var devicePixelRatio: number;
17161 declare var document: Document;
17162 /** @deprecated */
17163 declare var event: Event | undefined;
17164 /** @deprecated */
17165 declare var external: External;
17166 declare var frameElement: Element | null;
17167 declare var frames: WindowProxy;
17168 declare var history: History;
17169 declare var innerHeight: number;
17170 declare var innerWidth: number;
17171 declare var length: number;
17172 declare var location: Location;
17173 /** Returns true if the location bar is visible; otherwise, returns false. */
17174 declare var locationbar: BarProp;
17175 /** Returns true if the menu bar is visible; otherwise, returns false. */
17176 declare var menubar: BarProp;
17177 /** @deprecated */
17178 declare const name: void;
17179 declare var navigator: Navigator;
17180 /** Available only in secure contexts. */
17181 declare var ondevicemotion: ((this: Window, ev: DeviceMotionEvent) => any) | null;
17182 /** Available only in secure contexts. */
17183 declare var ondeviceorientation: ((this: Window, ev: DeviceOrientationEvent) => any) | null;
17184 /** @deprecated */
17185 declare var onorientationchange: ((this: Window, ev: Event) => any) | null;
17186 declare var opener: any;
17187 /** @deprecated */
17188 declare var orientation: number;
17189 declare var outerHeight: number;
17190 declare var outerWidth: number;
17191 /** @deprecated This is a legacy alias of `scrollX`. */
17192 declare var pageXOffset: number;
17193 /** @deprecated This is a legacy alias of `scrollY`. */
17194 declare var pageYOffset: number;
17195 /**
17196  * Refers to either the parent WindowProxy, or itself.
17197  *
17198  * It can rarely be null e.g. for contentWindow of an iframe that is already removed from the parent.
17199  */
17200 declare var parent: WindowProxy;
17201 /** Returns true if the personal bar is visible; otherwise, returns false. */
17202 declare var personalbar: BarProp;
17203 declare var screen: Screen;
17204 declare var screenLeft: number;
17205 declare var screenTop: number;
17206 declare var screenX: number;
17207 declare var screenY: number;
17208 declare var scrollX: number;
17209 declare var scrollY: number;
17210 /** Returns true if the scrollbars are visible; otherwise, returns false. */
17211 declare var scrollbars: BarProp;
17212 declare var self: Window & typeof globalThis;
17213 declare var speechSynthesis: SpeechSynthesis;
17214 /** @deprecated */
17215 declare var status: string;
17216 /** Returns true if the status bar is visible; otherwise, returns false. */
17217 declare var statusbar: BarProp;
17218 /** Returns true if the toolbar is visible; otherwise, returns false. */
17219 declare var toolbar: BarProp;
17220 declare var top: WindowProxy | null;
17221 declare var visualViewport: VisualViewport;
17222 declare var window: Window & typeof globalThis;
17223 declare function alert(message?: any): void;
17224 declare function blur(): void;
17225 declare function cancelIdleCallback(handle: number): void;
17226 /** @deprecated */
17227 declare function captureEvents(): void;
17228 /** Closes the window. */
17229 declare function close(): void;
17230 declare function confirm(message?: string): boolean;
17231 /** Moves the focus to the window's browsing context, if any. */
17232 declare function focus(): void;
17233 declare function getComputedStyle(elt: Element, pseudoElt?: string | null): CSSStyleDeclaration;
17234 declare function getSelection(): Selection | null;
17235 declare function matchMedia(query: string): MediaQueryList;
17236 declare function moveBy(x: number, y: number): void;
17237 declare function moveTo(x: number, y: number): void;
17238 declare function open(url?: string | URL, target?: string, features?: string): WindowProxy | null;
17239 /**
17240  * Posts a message to the given window. Messages can be structured objects, e.g. nested objects and arrays, can contain JavaScript values (strings, numbers, Date objects, etc), and can contain certain data objects such as File Blob, FileList, and ArrayBuffer objects.
17241  *
17242  * Objects listed in the transfer member of options are transferred, not just cloned, meaning that they are no longer usable on the sending side.
17243  *
17244  * A target origin can be specified using the targetOrigin member of options. If not provided, it defaults to "/". This default restricts the message to same-origin targets only.
17245  *
17246  * If the origin of the target window doesn't match the given target origin, the message is discarded, to avoid information leakage. To send the message to the target regardless of origin, set the target origin to "*".
17247  *
17248  * Throws a "DataCloneError" DOMException if transfer array contains duplicate objects or if message could not be cloned.
17249  */
17250 declare function postMessage(message: any, targetOrigin: string, transfer?: Transferable[]): void;
17251 declare function postMessage(message: any, options?: WindowPostMessageOptions): void;
17252 declare function print(): void;
17253 declare function prompt(message?: string, _default?: string): string | null;
17254 /** @deprecated */
17255 declare function releaseEvents(): void;
17256 declare function requestIdleCallback(callback: IdleRequestCallback, options?: IdleRequestOptions): number;
17257 declare function resizeBy(x: number, y: number): void;
17258 declare function resizeTo(width: number, height: number): void;
17259 declare function scroll(options?: ScrollToOptions): void;
17260 declare function scroll(x: number, y: number): void;
17261 declare function scrollBy(options?: ScrollToOptions): void;
17262 declare function scrollBy(x: number, y: number): void;
17263 declare function scrollTo(options?: ScrollToOptions): void;
17264 declare function scrollTo(x: number, y: number): void;
17265 /** Cancels the document load. */
17266 declare function stop(): void;
17267 declare function toString(): string;
17268 /** 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. */
17269 declare function dispatchEvent(event: Event): boolean;
17270 declare function cancelAnimationFrame(handle: number): void;
17271 declare function requestAnimationFrame(callback: FrameRequestCallback): number;
17272 /**
17273  * Fires when the user aborts the download.
17274  * @param ev The event.
17275  */
17276 declare var onabort: ((this: Window, ev: UIEvent) => any) | null;
17277 declare var onanimationcancel: ((this: Window, ev: AnimationEvent) => any) | null;
17278 declare var onanimationend: ((this: Window, ev: AnimationEvent) => any) | null;
17279 declare var onanimationiteration: ((this: Window, ev: AnimationEvent) => any) | null;
17280 declare var onanimationstart: ((this: Window, ev: AnimationEvent) => any) | null;
17281 declare var onauxclick: ((this: Window, ev: MouseEvent) => any) | null;
17282 /**
17283  * Fires when the object loses the input focus.
17284  * @param ev The focus event.
17285  */
17286 declare var onblur: ((this: Window, ev: FocusEvent) => any) | null;
17287 /**
17288  * Occurs when playback is possible, but would require further buffering.
17289  * @param ev The event.
17290  */
17291 declare var oncanplay: ((this: Window, ev: Event) => any) | null;
17292 declare var oncanplaythrough: ((this: Window, ev: Event) => any) | null;
17293 /**
17294  * Fires when the contents of the object or selection have changed.
17295  * @param ev The event.
17296  */
17297 declare var onchange: ((this: Window, ev: Event) => any) | null;
17298 /**
17299  * Fires when the user clicks the left mouse button on the object
17300  * @param ev The mouse event.
17301  */
17302 declare var onclick: ((this: Window, ev: MouseEvent) => any) | null;
17303 declare var onclose: ((this: Window, ev: Event) => any) | null;
17304 /**
17305  * Fires when the user clicks the right mouse button in the client area, opening the context menu.
17306  * @param ev The mouse event.
17307  */
17308 declare var oncontextmenu: ((this: Window, ev: MouseEvent) => any) | null;
17309 declare var oncuechange: ((this: Window, ev: Event) => any) | null;
17310 /**
17311  * Fires when the user double-clicks the object.
17312  * @param ev The mouse event.
17313  */
17314 declare var ondblclick: ((this: Window, ev: MouseEvent) => any) | null;
17315 /**
17316  * Fires on the source object continuously during a drag operation.
17317  * @param ev The event.
17318  */
17319 declare var ondrag: ((this: Window, ev: DragEvent) => any) | null;
17320 /**
17321  * Fires on the source object when the user releases the mouse at the close of a drag operation.
17322  * @param ev The event.
17323  */
17324 declare var ondragend: ((this: Window, ev: DragEvent) => any) | null;
17325 /**
17326  * Fires on the target element when the user drags the object to a valid drop target.
17327  * @param ev The drag event.
17328  */
17329 declare var ondragenter: ((this: Window, ev: DragEvent) => any) | null;
17330 /**
17331  * Fires on the target object when the user moves the mouse out of a valid drop target during a drag operation.
17332  * @param ev The drag event.
17333  */
17334 declare var ondragleave: ((this: Window, ev: DragEvent) => any) | null;
17335 /**
17336  * Fires on the target element continuously while the user drags the object over a valid drop target.
17337  * @param ev The event.
17338  */
17339 declare var ondragover: ((this: Window, ev: DragEvent) => any) | null;
17340 /**
17341  * Fires on the source object when the user starts to drag a text selection or selected object.
17342  * @param ev The event.
17343  */
17344 declare var ondragstart: ((this: Window, ev: DragEvent) => any) | null;
17345 declare var ondrop: ((this: Window, ev: DragEvent) => any) | null;
17346 /**
17347  * Occurs when the duration attribute is updated.
17348  * @param ev The event.
17349  */
17350 declare var ondurationchange: ((this: Window, ev: Event) => any) | null;
17351 /**
17352  * Occurs when the media element is reset to its initial state.
17353  * @param ev The event.
17354  */
17355 declare var onemptied: ((this: Window, ev: Event) => any) | null;
17356 /**
17357  * Occurs when the end of playback is reached.
17358  * @param ev The event
17359  */
17360 declare var onended: ((this: Window, ev: Event) => any) | null;
17361 /**
17362  * Fires when an error occurs during object loading.
17363  * @param ev The event.
17364  */
17365 declare var onerror: OnErrorEventHandler;
17366 /**
17367  * Fires when the object receives focus.
17368  * @param ev The event.
17369  */
17370 declare var onfocus: ((this: Window, ev: FocusEvent) => any) | null;
17371 declare var onformdata: ((this: Window, ev: FormDataEvent) => any) | null;
17372 declare var ongotpointercapture: ((this: Window, ev: PointerEvent) => any) | null;
17373 declare var oninput: ((this: Window, ev: Event) => any) | null;
17374 declare var oninvalid: ((this: Window, ev: Event) => any) | null;
17375 /**
17376  * Fires when the user presses a key.
17377  * @param ev The keyboard event
17378  */
17379 declare var onkeydown: ((this: Window, ev: KeyboardEvent) => any) | null;
17380 /**
17381  * Fires when the user presses an alphanumeric key.
17382  * @param ev The event.
17383  * @deprecated
17384  */
17385 declare var onkeypress: ((this: Window, ev: KeyboardEvent) => any) | null;
17386 /**
17387  * Fires when the user releases a key.
17388  * @param ev The keyboard event
17389  */
17390 declare var onkeyup: ((this: Window, ev: KeyboardEvent) => any) | null;
17391 /**
17392  * Fires immediately after the browser loads the object.
17393  * @param ev The event.
17394  */
17395 declare var onload: ((this: Window, ev: Event) => any) | null;
17396 /**
17397  * Occurs when media data is loaded at the current playback position.
17398  * @param ev The event.
17399  */
17400 declare var onloadeddata: ((this: Window, ev: Event) => any) | null;
17401 /**
17402  * Occurs when the duration and dimensions of the media have been determined.
17403  * @param ev The event.
17404  */
17405 declare var onloadedmetadata: ((this: Window, ev: Event) => any) | null;
17406 /**
17407  * Occurs when Internet Explorer begins looking for media data.
17408  * @param ev The event.
17409  */
17410 declare var onloadstart: ((this: Window, ev: Event) => any) | null;
17411 declare var onlostpointercapture: ((this: Window, ev: PointerEvent) => any) | null;
17412 /**
17413  * Fires when the user clicks the object with either mouse button.
17414  * @param ev The mouse event.
17415  */
17416 declare var onmousedown: ((this: Window, ev: MouseEvent) => any) | null;
17417 declare var onmouseenter: ((this: Window, ev: MouseEvent) => any) | null;
17418 declare var onmouseleave: ((this: Window, ev: MouseEvent) => any) | null;
17419 /**
17420  * Fires when the user moves the mouse over the object.
17421  * @param ev The mouse event.
17422  */
17423 declare var onmousemove: ((this: Window, ev: MouseEvent) => any) | null;
17424 /**
17425  * Fires when the user moves the mouse pointer outside the boundaries of the object.
17426  * @param ev The mouse event.
17427  */
17428 declare var onmouseout: ((this: Window, ev: MouseEvent) => any) | null;
17429 /**
17430  * Fires when the user moves the mouse pointer into the object.
17431  * @param ev The mouse event.
17432  */
17433 declare var onmouseover: ((this: Window, ev: MouseEvent) => any) | null;
17434 /**
17435  * Fires when the user releases a mouse button while the mouse is over the object.
17436  * @param ev The mouse event.
17437  */
17438 declare var onmouseup: ((this: Window, ev: MouseEvent) => any) | null;
17439 /**
17440  * Occurs when playback is paused.
17441  * @param ev The event.
17442  */
17443 declare var onpause: ((this: Window, ev: Event) => any) | null;
17444 /**
17445  * Occurs when the play method is requested.
17446  * @param ev The event.
17447  */
17448 declare var onplay: ((this: Window, ev: Event) => any) | null;
17449 /**
17450  * Occurs when the audio or video has started playing.
17451  * @param ev The event.
17452  */
17453 declare var onplaying: ((this: Window, ev: Event) => any) | null;
17454 declare var onpointercancel: ((this: Window, ev: PointerEvent) => any) | null;
17455 declare var onpointerdown: ((this: Window, ev: PointerEvent) => any) | null;
17456 declare var onpointerenter: ((this: Window, ev: PointerEvent) => any) | null;
17457 declare var onpointerleave: ((this: Window, ev: PointerEvent) => any) | null;
17458 declare var onpointermove: ((this: Window, ev: PointerEvent) => any) | null;
17459 declare var onpointerout: ((this: Window, ev: PointerEvent) => any) | null;
17460 declare var onpointerover: ((this: Window, ev: PointerEvent) => any) | null;
17461 declare var onpointerup: ((this: Window, ev: PointerEvent) => any) | null;
17462 /**
17463  * Occurs to indicate progress while downloading media data.
17464  * @param ev The event.
17465  */
17466 declare var onprogress: ((this: Window, ev: ProgressEvent) => any) | null;
17467 /**
17468  * Occurs when the playback rate is increased or decreased.
17469  * @param ev The event.
17470  */
17471 declare var onratechange: ((this: Window, ev: Event) => any) | null;
17472 /**
17473  * Fires when the user resets a form.
17474  * @param ev The event.
17475  */
17476 declare var onreset: ((this: Window, ev: Event) => any) | null;
17477 declare var onresize: ((this: Window, ev: UIEvent) => any) | null;
17478 /**
17479  * Fires when the user repositions the scroll box in the scroll bar on the object.
17480  * @param ev The event.
17481  */
17482 declare var onscroll: ((this: Window, ev: Event) => any) | null;
17483 /**
17484  * Occurs when the seek operation ends.
17485  * @param ev The event.
17486  */
17487 declare var onseeked: ((this: Window, ev: Event) => any) | null;
17488 /**
17489  * Occurs when the current playback position is moved.
17490  * @param ev The event.
17491  */
17492 declare var onseeking: ((this: Window, ev: Event) => any) | null;
17493 /**
17494  * Fires when the current selection changes.
17495  * @param ev The event.
17496  */
17497 declare var onselect: ((this: Window, ev: Event) => any) | null;
17498 declare var onselectionchange: ((this: Window, ev: Event) => any) | null;
17499 declare var onselectstart: ((this: Window, ev: Event) => any) | null;
17500 /**
17501  * Occurs when the download has stopped.
17502  * @param ev The event.
17503  */
17504 declare var onstalled: ((this: Window, ev: Event) => any) | null;
17505 declare var onsubmit: ((this: Window, ev: SubmitEvent) => any) | null;
17506 /**
17507  * Occurs if the load operation has been intentionally halted.
17508  * @param ev The event.
17509  */
17510 declare var onsuspend: ((this: Window, ev: Event) => any) | null;
17511 /**
17512  * Occurs to indicate the current playback position.
17513  * @param ev The event.
17514  */
17515 declare var ontimeupdate: ((this: Window, ev: Event) => any) | null;
17516 declare var ontoggle: ((this: Window, ev: Event) => any) | null;
17517 declare var ontouchcancel: ((this: Window, ev: TouchEvent) => any) | null | undefined;
17518 declare var ontouchend: ((this: Window, ev: TouchEvent) => any) | null | undefined;
17519 declare var ontouchmove: ((this: Window, ev: TouchEvent) => any) | null | undefined;
17520 declare var ontouchstart: ((this: Window, ev: TouchEvent) => any) | null | undefined;
17521 declare var ontransitioncancel: ((this: Window, ev: TransitionEvent) => any) | null;
17522 declare var ontransitionend: ((this: Window, ev: TransitionEvent) => any) | null;
17523 declare var ontransitionrun: ((this: Window, ev: TransitionEvent) => any) | null;
17524 declare var ontransitionstart: ((this: Window, ev: TransitionEvent) => any) | null;
17525 /**
17526  * Occurs when the volume is changed, or playback is muted or unmuted.
17527  * @param ev The event.
17528  */
17529 declare var onvolumechange: ((this: Window, ev: Event) => any) | null;
17530 /**
17531  * Occurs when playback stops because the next frame of a video resource is not available.
17532  * @param ev The event.
17533  */
17534 declare var onwaiting: ((this: Window, ev: Event) => any) | null;
17535 /** @deprecated This is a legacy alias of `onanimationend`. */
17536 declare var onwebkitanimationend: ((this: Window, ev: Event) => any) | null;
17537 /** @deprecated This is a legacy alias of `onanimationiteration`. */
17538 declare var onwebkitanimationiteration: ((this: Window, ev: Event) => any) | null;
17539 /** @deprecated This is a legacy alias of `onanimationstart`. */
17540 declare var onwebkitanimationstart: ((this: Window, ev: Event) => any) | null;
17541 /** @deprecated This is a legacy alias of `ontransitionend`. */
17542 declare var onwebkittransitionend: ((this: Window, ev: Event) => any) | null;
17543 declare var onwheel: ((this: Window, ev: WheelEvent) => any) | null;
17544 declare var onafterprint: ((this: Window, ev: Event) => any) | null;
17545 declare var onbeforeprint: ((this: Window, ev: Event) => any) | null;
17546 declare var onbeforeunload: ((this: Window, ev: BeforeUnloadEvent) => any) | null;
17547 declare var ongamepadconnected: ((this: Window, ev: GamepadEvent) => any) | null;
17548 declare var ongamepaddisconnected: ((this: Window, ev: GamepadEvent) => any) | null;
17549 declare var onhashchange: ((this: Window, ev: HashChangeEvent) => any) | null;
17550 declare var onlanguagechange: ((this: Window, ev: Event) => any) | null;
17551 declare var onmessage: ((this: Window, ev: MessageEvent) => any) | null;
17552 declare var onmessageerror: ((this: Window, ev: MessageEvent) => any) | null;
17553 declare var onoffline: ((this: Window, ev: Event) => any) | null;
17554 declare var ononline: ((this: Window, ev: Event) => any) | null;
17555 declare var onpagehide: ((this: Window, ev: PageTransitionEvent) => any) | null;
17556 declare var onpageshow: ((this: Window, ev: PageTransitionEvent) => any) | null;
17557 declare var onpopstate: ((this: Window, ev: PopStateEvent) => any) | null;
17558 declare var onrejectionhandled: ((this: Window, ev: PromiseRejectionEvent) => any) | null;
17559 declare var onstorage: ((this: Window, ev: StorageEvent) => any) | null;
17560 declare var onunhandledrejection: ((this: Window, ev: PromiseRejectionEvent) => any) | null;
17561 declare var onunload: ((this: Window, ev: Event) => any) | null;
17562 declare var localStorage: Storage;
17563 /** Available only in secure contexts. */
17564 declare var caches: CacheStorage;
17565 declare var crossOriginIsolated: boolean;
17566 declare var crypto: Crypto;
17567 declare var indexedDB: IDBFactory;
17568 declare var isSecureContext: boolean;
17569 declare var origin: string;
17570 declare var performance: Performance;
17571 declare function atob(data: string): string;
17572 declare function btoa(data: string): string;
17573 declare function clearInterval(handle?: number): void;
17574 declare function clearTimeout(handle?: number): void;
17575 declare function createImageBitmap(image: ImageBitmapSource, options?: ImageBitmapOptions): Promise<ImageBitmap>;
17576 declare function createImageBitmap(image: ImageBitmapSource, sx: number, sy: number, sw: number, sh: number, options?: ImageBitmapOptions): Promise<ImageBitmap>;
17577 declare function fetch(input: RequestInfo, init?: RequestInit): Promise<Response>;
17578 declare function queueMicrotask(callback: VoidFunction): void;
17579 declare function setInterval(handler: TimerHandler, timeout?: number, ...arguments: any[]): number;
17580 declare function setTimeout(handler: TimerHandler, timeout?: number, ...arguments: any[]): number;
17581 declare var sessionStorage: Storage;
17582 declare function addEventListener<K extends keyof WindowEventMap>(type: K, listener: (this: Window, ev: WindowEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
17583 declare function addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
17584 declare function removeEventListener<K extends keyof WindowEventMap>(type: K, listener: (this: Window, ev: WindowEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
17585 declare function removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
17586 type AlgorithmIdentifier = Algorithm | string;
17587 type BigInteger = Uint8Array;
17588 type BinaryData = ArrayBuffer | ArrayBufferView;
17589 type BlobPart = BufferSource | Blob | string;
17590 type BodyInit = ReadableStream | XMLHttpRequestBodyInit;
17591 type BufferSource = ArrayBufferView | ArrayBuffer;
17592 type COSEAlgorithmIdentifier = number;
17593 type CSSNumberish = number;
17594 type CanvasImageSource = HTMLOrSVGImageElement | HTMLVideoElement | HTMLCanvasElement | ImageBitmap;
17595 type ClipboardItemData = Promise<ClipboardItemDataType>;
17596 type ClipboardItemDataType = string | Blob;
17597 type ClipboardItems = ClipboardItem[];
17598 type ConstrainBoolean = boolean | ConstrainBooleanParameters;
17599 type ConstrainDOMString = string | string[] | ConstrainDOMStringParameters;
17600 type ConstrainDouble = number | ConstrainDoubleRange;
17601 type ConstrainULong = number | ConstrainULongRange;
17602 type DOMHighResTimeStamp = number;
17603 type DOMTimeStamp = number;
17604 type EventListenerOrEventListenerObject = EventListener | EventListenerObject;
17605 type Float32List = Float32Array | GLfloat[];
17606 type FormDataEntryValue = File | string;
17607 type GLbitfield = number;
17608 type GLboolean = boolean;
17609 type GLclampf = number;
17610 type GLenum = number;
17611 type GLfloat = number;
17612 type GLint = number;
17613 type GLint64 = number;
17614 type GLintptr = number;
17615 type GLsizei = number;
17616 type GLsizeiptr = number;
17617 type GLuint = number;
17618 type GLuint64 = number;
17619 type HTMLOrSVGImageElement = HTMLImageElement | SVGImageElement;
17620 type HTMLOrSVGScriptElement = HTMLScriptElement | SVGScriptElement;
17621 type HashAlgorithmIdentifier = AlgorithmIdentifier;
17622 type HeadersInit = string[][] | Record<string, string> | Headers;
17623 type IDBValidKey = number | string | Date | BufferSource | IDBValidKey[];
17624 type ImageBitmapSource = CanvasImageSource | Blob | ImageData;
17625 type InsertPosition = "beforebegin" | "afterbegin" | "beforeend" | "afterend";
17626 type Int32List = Int32Array | GLint[];
17627 type LineAndPositionSetting = number | AutoKeyword;
17628 type MediaProvider = MediaStream | MediaSource | Blob;
17629 type MessageEventSource = WindowProxy | MessagePort | ServiceWorker;
17630 type MutationRecordType = "attributes" | "characterData" | "childList";
17631 type NamedCurve = string;
17632 type OnBeforeUnloadEventHandler = OnBeforeUnloadEventHandlerNonNull | null;
17633 type OnErrorEventHandler = OnErrorEventHandlerNonNull | null;
17634 type PerformanceEntryList = PerformanceEntry[];
17635 type ReadableStreamController<T> = ReadableStreamDefaultController<T>;
17636 type ReadableStreamDefaultReadResult<T> = ReadableStreamDefaultReadValueResult<T> | ReadableStreamDefaultReadDoneResult;
17637 type ReadableStreamReader<T> = ReadableStreamDefaultReader<T>;
17638 type RenderingContext = CanvasRenderingContext2D | ImageBitmapRenderingContext | WebGLRenderingContext | WebGL2RenderingContext;
17639 type RequestInfo = Request | string;
17640 type TexImageSource = ImageBitmap | ImageData | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
17641 type TimerHandler = string | Function;
17642 type Transferable = ArrayBuffer | MessagePort | ImageBitmap;
17643 type Uint32List = Uint32Array | GLuint[];
17644 type UvmEntries = UvmEntry[];
17645 type UvmEntry = number[];
17646 type VibratePattern = number | number[];
17647 type WindowProxy = Window;
17648 type XMLHttpRequestBodyInit = Blob | BufferSource | FormData | URLSearchParams | string;
17649 type AlignSetting = "center" | "end" | "left" | "right" | "start";
17650 type AnimationPlayState = "finished" | "idle" | "paused" | "running";
17651 type AnimationReplaceState = "active" | "persisted" | "removed";
17652 type AppendMode = "segments" | "sequence";
17653 type AttestationConveyancePreference = "direct" | "enterprise" | "indirect" | "none";
17654 type AudioContextLatencyCategory = "balanced" | "interactive" | "playback";
17655 type AudioContextState = "closed" | "running" | "suspended";
17656 type AuthenticatorAttachment = "cross-platform" | "platform";
17657 type AuthenticatorTransport = "ble" | "internal" | "nfc" | "usb";
17658 type AutoKeyword = "auto";
17659 type AutomationRate = "a-rate" | "k-rate";
17660 type BinaryType = "arraybuffer" | "blob";
17661 type BiquadFilterType = "allpass" | "bandpass" | "highpass" | "highshelf" | "lowpass" | "lowshelf" | "notch" | "peaking";
17662 type CanPlayTypeResult = "" | "maybe" | "probably";
17663 type CanvasDirection = "inherit" | "ltr" | "rtl";
17664 type CanvasFillRule = "evenodd" | "nonzero";
17665 type CanvasFontKerning = "auto" | "none" | "normal";
17666 type CanvasFontStretch = "condensed" | "expanded" | "extra-condensed" | "extra-expanded" | "normal" | "semi-condensed" | "semi-expanded" | "ultra-condensed" | "ultra-expanded";
17667 type CanvasFontVariantCaps = "all-petite-caps" | "all-small-caps" | "normal" | "petite-caps" | "small-caps" | "titling-caps" | "unicase";
17668 type CanvasLineCap = "butt" | "round" | "square";
17669 type CanvasLineJoin = "bevel" | "miter" | "round";
17670 type CanvasTextAlign = "center" | "end" | "left" | "right" | "start";
17671 type CanvasTextBaseline = "alphabetic" | "bottom" | "hanging" | "ideographic" | "middle" | "top";
17672 type CanvasTextRendering = "auto" | "geometricPrecision" | "optimizeLegibility" | "optimizeSpeed";
17673 type ChannelCountMode = "clamped-max" | "explicit" | "max";
17674 type ChannelInterpretation = "discrete" | "speakers";
17675 type ClientTypes = "all" | "sharedworker" | "window" | "worker";
17676 type ColorGamut = "p3" | "rec2020" | "srgb";
17677 type ColorSpaceConversion = "default" | "none";
17678 type CompositeOperation = "accumulate" | "add" | "replace";
17679 type CompositeOperationOrAuto = "accumulate" | "add" | "auto" | "replace";
17680 type ConnectionType = "bluetooth" | "cellular" | "ethernet" | "mixed" | "none" | "other" | "unknown" | "wifi";
17681 type CredentialMediationRequirement = "optional" | "required" | "silent";
17682 type DOMParserSupportedType = "application/xhtml+xml" | "application/xml" | "image/svg+xml" | "text/html" | "text/xml";
17683 type DirectionSetting = "" | "lr" | "rl";
17684 type DisplayCaptureSurfaceType = "application" | "browser" | "monitor" | "window";
17685 type DistanceModelType = "exponential" | "inverse" | "linear";
17686 type DocumentReadyState = "complete" | "interactive" | "loading";
17687 type EndOfStreamError = "decode" | "network";
17688 type EndingType = "native" | "transparent";
17689 type FillMode = "auto" | "backwards" | "both" | "forwards" | "none";
17690 type FontFaceLoadStatus = "error" | "loaded" | "loading" | "unloaded";
17691 type FontFaceSetLoadStatus = "loaded" | "loading";
17692 type FullscreenNavigationUI = "auto" | "hide" | "show";
17693 type GamepadHapticActuatorType = "vibration";
17694 type GamepadMappingType = "" | "standard" | "xr-standard";
17695 type HdrMetadataType = "smpteSt2086" | "smpteSt2094-10" | "smpteSt2094-40";
17696 type IDBCursorDirection = "next" | "nextunique" | "prev" | "prevunique";
17697 type IDBRequestReadyState = "done" | "pending";
17698 type IDBTransactionMode = "readonly" | "readwrite" | "versionchange";
17699 type ImageOrientation = "flipY" | "none";
17700 type ImageSmoothingQuality = "high" | "low" | "medium";
17701 type IterationCompositeOperation = "accumulate" | "replace";
17702 type KeyFormat = "jwk" | "pkcs8" | "raw" | "spki";
17703 type KeyType = "private" | "public" | "secret";
17704 type KeyUsage = "decrypt" | "deriveBits" | "deriveKey" | "encrypt" | "sign" | "unwrapKey" | "verify" | "wrapKey";
17705 type LineAlignSetting = "center" | "end" | "start";
17706 type MediaDecodingType = "file" | "media-source" | "webrtc";
17707 type MediaDeviceKind = "audioinput" | "audiooutput" | "videoinput";
17708 type MediaEncodingType = "record" | "webrtc";
17709 type MediaKeyMessageType = "individualization-request" | "license-release" | "license-renewal" | "license-request";
17710 type MediaKeySessionClosedReason = "closed-by-application" | "hardware-context-reset" | "internal-error" | "release-acknowledged" | "resource-evicted";
17711 type MediaKeySessionType = "persistent-license" | "temporary";
17712 type MediaKeyStatus = "expired" | "internal-error" | "output-downscaled" | "output-restricted" | "released" | "status-pending" | "usable" | "usable-in-future";
17713 type MediaKeysRequirement = "not-allowed" | "optional" | "required";
17714 type MediaSessionAction = "hangup" | "nexttrack" | "pause" | "play" | "previoustrack" | "seekbackward" | "seekforward" | "seekto" | "skipad" | "stop" | "togglecamera" | "togglemicrophone";
17715 type MediaSessionPlaybackState = "none" | "paused" | "playing";
17716 type MediaStreamTrackState = "ended" | "live";
17717 type NavigationType = "back_forward" | "navigate" | "prerender" | "reload";
17718 type NotificationDirection = "auto" | "ltr" | "rtl";
17719 type NotificationPermission = "default" | "denied" | "granted";
17720 type OrientationLockType = "any" | "landscape" | "landscape-primary" | "landscape-secondary" | "natural" | "portrait" | "portrait-primary" | "portrait-secondary";
17721 type OrientationType = "landscape-primary" | "landscape-secondary" | "portrait-primary" | "portrait-secondary";
17722 type OscillatorType = "custom" | "sawtooth" | "sine" | "square" | "triangle";
17723 type OverSampleType = "2x" | "4x" | "none";
17724 type PanningModelType = "HRTF" | "equalpower";
17725 type PaymentComplete = "fail" | "success" | "unknown";
17726 type PermissionName = "geolocation" | "notifications" | "persistent-storage" | "push" | "screen-wake-lock" | "xr-spatial-tracking";
17727 type PermissionState = "denied" | "granted" | "prompt";
17728 type PlaybackDirection = "alternate" | "alternate-reverse" | "normal" | "reverse";
17729 type PositionAlignSetting = "auto" | "center" | "line-left" | "line-right";
17730 type PredefinedColorSpace = "display-p3" | "srgb";
17731 type PremultiplyAlpha = "default" | "none" | "premultiply";
17732 type PresentationStyle = "attachment" | "inline" | "unspecified";
17733 type PublicKeyCredentialType = "public-key";
17734 type PushEncryptionKeyName = "auth" | "p256dh";
17735 type PushPermissionState = "denied" | "granted" | "prompt";
17736 type RTCBundlePolicy = "balanced" | "max-bundle" | "max-compat";
17737 type RTCDataChannelState = "closed" | "closing" | "connecting" | "open";
17738 type RTCDegradationPreference = "balanced" | "maintain-framerate" | "maintain-resolution";
17739 type RTCDtlsTransportState = "closed" | "connected" | "connecting" | "failed" | "new";
17740 type RTCIceCandidateType = "host" | "prflx" | "relay" | "srflx";
17741 type RTCIceComponent = "rtcp" | "rtp";
17742 type RTCIceConnectionState = "checking" | "closed" | "completed" | "connected" | "disconnected" | "failed" | "new";
17743 type RTCIceCredentialType = "password";
17744 type RTCIceGathererState = "complete" | "gathering" | "new";
17745 type RTCIceGatheringState = "complete" | "gathering" | "new";
17746 type RTCIceProtocol = "tcp" | "udp";
17747 type RTCIceTcpCandidateType = "active" | "passive" | "so";
17748 type RTCIceTransportPolicy = "all" | "relay";
17749 type RTCIceTransportState = "checking" | "closed" | "completed" | "connected" | "disconnected" | "failed" | "new";
17750 type RTCPeerConnectionState = "closed" | "connected" | "connecting" | "disconnected" | "failed" | "new";
17751 type RTCPriorityType = "high" | "low" | "medium" | "very-low";
17752 type RTCRtcpMuxPolicy = "require";
17753 type RTCRtpTransceiverDirection = "inactive" | "recvonly" | "sendonly" | "sendrecv" | "stopped";
17754 type RTCSdpType = "answer" | "offer" | "pranswer" | "rollback";
17755 type RTCSignalingState = "closed" | "have-local-offer" | "have-local-pranswer" | "have-remote-offer" | "have-remote-pranswer" | "stable";
17756 type RTCStatsIceCandidatePairState = "failed" | "frozen" | "in-progress" | "inprogress" | "succeeded" | "waiting";
17757 type RTCStatsType = "candidate-pair" | "certificate" | "codec" | "csrc" | "data-channel" | "inbound-rtp" | "local-candidate" | "media-source" | "outbound-rtp" | "peer-connection" | "remote-candidate" | "remote-inbound-rtp" | "remote-outbound-rtp" | "track" | "transport";
17758 type ReadyState = "closed" | "ended" | "open";
17759 type RecordingState = "inactive" | "paused" | "recording";
17760 type ReferrerPolicy = "" | "no-referrer" | "no-referrer-when-downgrade" | "origin" | "origin-when-cross-origin" | "same-origin" | "strict-origin" | "strict-origin-when-cross-origin" | "unsafe-url";
17761 type RemotePlaybackState = "connected" | "connecting" | "disconnected";
17762 type RequestCache = "default" | "force-cache" | "no-cache" | "no-store" | "only-if-cached" | "reload";
17763 type RequestCredentials = "include" | "omit" | "same-origin";
17764 type RequestDestination = "" | "audio" | "audioworklet" | "document" | "embed" | "font" | "frame" | "iframe" | "image" | "manifest" | "object" | "paintworklet" | "report" | "script" | "sharedworker" | "style" | "track" | "video" | "worker" | "xslt";
17765 type RequestMode = "cors" | "navigate" | "no-cors" | "same-origin";
17766 type RequestRedirect = "error" | "follow" | "manual";
17767 type ResidentKeyRequirement = "discouraged" | "preferred" | "required";
17768 type ResizeObserverBoxOptions = "border-box" | "content-box" | "device-pixel-content-box";
17769 type ResizeQuality = "high" | "low" | "medium" | "pixelated";
17770 type ResponseType = "basic" | "cors" | "default" | "error" | "opaque" | "opaqueredirect";
17771 type ScrollBehavior = "auto" | "smooth";
17772 type ScrollLogicalPosition = "center" | "end" | "nearest" | "start";
17773 type ScrollRestoration = "auto" | "manual";
17774 type ScrollSetting = "" | "up";
17775 type SecurityPolicyViolationEventDisposition = "enforce" | "report";
17776 type SelectionMode = "end" | "preserve" | "select" | "start";
17777 type ServiceWorkerState = "activated" | "activating" | "installed" | "installing" | "parsed" | "redundant";
17778 type ServiceWorkerUpdateViaCache = "all" | "imports" | "none";
17779 type ShadowRootMode = "closed" | "open";
17780 type SlotAssignmentMode = "manual" | "named";
17781 type SpeechSynthesisErrorCode = "audio-busy" | "audio-hardware" | "canceled" | "interrupted" | "invalid-argument" | "language-unavailable" | "network" | "not-allowed" | "synthesis-failed" | "synthesis-unavailable" | "text-too-long" | "voice-unavailable";
17782 type TextTrackKind = "captions" | "chapters" | "descriptions" | "metadata" | "subtitles";
17783 type TextTrackMode = "disabled" | "hidden" | "showing";
17784 type TouchType = "direct" | "stylus";
17785 type TransferFunction = "hlg" | "pq" | "srgb";
17786 type UserVerificationRequirement = "discouraged" | "preferred" | "required";
17787 type VideoFacingModeEnum = "environment" | "left" | "right" | "user";
17788 type VisibilityState = "hidden" | "visible";
17789 type WebGLPowerPreference = "default" | "high-performance" | "low-power";
17790 type WorkerType = "classic" | "module";
17791 type XMLHttpRequestResponseType = "" | "arraybuffer" | "blob" | "document" | "json" | "text";