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

   1 /*! *****************************************************************************
   2 Copyright (c) Microsoft Corporation. All rights reserved.
   3 Licensed under the Apache License, Version 2.0 (the "License"); you may not use
   4 this file except in compliance with the License. You may obtain a copy of the
   5 License at http://www.apache.org/licenses/LICENSE-2.0
   6
   7 THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
   8 KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
   9 WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
  10 MERCHANTABLITY OR NON-INFRINGEMENT.
  11
  12 See the Apache Version 2.0 License for specific language governing permissions
  13 and limitations under the License.
  14 ***************************************************************************** */
  15
  16
  17
  18 /// <reference no-default-lib="true"/>\r
  19
  20
  21 /////////////////////////////
  22 /// DOM APIs
  23 /////////////////////////////
  24
  25 interface Account {
  26     displayName: string;
  27     id: string;
  28     imageURL?: string;
  29     name?: string;
  30     rpDisplayName: string;
  31 }
  32
  33 interface AddEventListenerOptions extends EventListenerOptions {
  34     once?: boolean;
  35     passive?: boolean;
  36 }
  37
  38 interface AesCbcParams extends Algorithm {
  39     iv: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;
  40 }
  41
  42 interface AesCtrParams extends Algorithm {
  43     counter: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;
  44     length: number;
  45 }
  46
  47 interface AesDerivedKeyParams extends Algorithm {
  48     length: number;
  49 }
  50
  51 interface AesGcmParams extends Algorithm {
  52     additionalData?: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;
  53     iv: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;
  54     tagLength?: number;
  55 }
  56
  57 interface AesKeyAlgorithm extends KeyAlgorithm {
  58     length: number;
  59 }
  60
  61 interface AesKeyGenParams extends Algorithm {
  62     length: number;
  63 }
  64
  65 interface Algorithm {
  66     name: string;
  67 }
  68
  69 interface AnalyserOptions extends AudioNodeOptions {
  70     fftSize?: number;
  71     maxDecibels?: number;
  72     minDecibels?: number;
  73     smoothingTimeConstant?: number;
  74 }
  75
  76 interface AnimationEventInit extends EventInit {
  77     animationName?: string;
  78     elapsedTime?: number;
  79     pseudoElement?: string;
  80 }
  81
  82 interface AnimationPlaybackEventInit extends EventInit {
  83     currentTime?: number | null;
  84     timelineTime?: number | null;
  85 }
  86
  87 interface AssertionOptions {
  88     allowList?: ScopedCredentialDescriptor[];
  89     extensions?: WebAuthnExtensions;
  90     rpId?: string;
  91     timeoutSeconds?: number;
  92 }
  93
  94 interface AssignedNodesOptions {
  95     flatten?: boolean;
  96 }
  97
  98 interface AudioBufferOptions {
  99     length: number;
 100     numberOfChannels?: number;
 101     sampleRate: number;
 102 }
 103
 104 interface AudioBufferSourceOptions {
 105     buffer?: AudioBuffer | null;
 106     detune?: number;
 107     loop?: boolean;
 108     loopEnd?: number;
 109     loopStart?: number;
 110     playbackRate?: number;
 111 }
 112
 113 interface AudioContextInfo {
 114     currentTime?: number;
 115     sampleRate?: number;
 116 }
 117
 118 interface AudioContextOptions {
 119     latencyHint?: AudioContextLatencyCategory | number;
 120     sampleRate?: number;
 121 }
 122
 123 interface AudioNodeOptions {
 124     channelCount?: number;
 125     channelCountMode?: ChannelCountMode;
 126     channelInterpretation?: ChannelInterpretation;
 127 }
 128
 129 interface AudioParamDescriptor {
 130     automationRate?: AutomationRate;
 131     defaultValue?: number;
 132     maxValue?: number;
 133     minValue?: number;
 134     name: string;
 135 }
 136
 137 interface AudioProcessingEventInit extends EventInit {
 138     inputBuffer: AudioBuffer;
 139     outputBuffer: AudioBuffer;
 140     playbackTime: number;
 141 }
 142
 143 interface AudioTimestamp {
 144     contextTime?: number;
 145     performanceTime?: number;
 146 }
 147
 148 interface AudioWorkletNodeOptions extends AudioNodeOptions {
 149     numberOfInputs?: number;
 150     numberOfOutputs?: number;
 151     outputChannelCount?: number[];
 152     parameterData?: Record<string, number>;
 153     processorOptions?: any;
 154 }
 155
 156 interface AuthenticationExtensionsClientInputs {
 157     appid?: string;
 158     authnSel?: AuthenticatorSelectionList;
 159     exts?: boolean;
 160     loc?: boolean;
 161     txAuthGeneric?: txAuthGenericArg;
 162     txAuthSimple?: string;
 163     uvi?: boolean;
 164     uvm?: boolean;
 165 }
 166
 167 interface AuthenticationExtensionsClientOutputs {
 168     appid?: boolean;
 169     authnSel?: boolean;
 170     exts?: AuthenticationExtensionsSupported;
 171     loc?: Coordinates;
 172     txAuthGeneric?: ArrayBuffer;
 173     txAuthSimple?: string;
 174     uvi?: ArrayBuffer;
 175     uvm?: UvmEntries;
 176 }
 177
 178 interface AuthenticatorSelectionCriteria {
 179     authenticatorAttachment?: AuthenticatorAttachment;
 180     requireResidentKey?: boolean;
 181     userVerification?: UserVerificationRequirement;
 182 }
 183
 184 interface BiquadFilterOptions extends AudioNodeOptions {
 185     Q?: number;
 186     detune?: number;
 187     frequency?: number;
 188     gain?: number;
 189     type?: BiquadFilterType;
 190 }
 191
 192 interface BlobPropertyBag {
 193     endings?: EndingType;
 194     type?: string;
 195 }
 196
 197 interface ByteLengthChunk {
 198     byteLength?: number;
 199 }
 200
 201 interface CacheQueryOptions {
 202     ignoreMethod?: boolean;
 203     ignoreSearch?: boolean;
 204     ignoreVary?: boolean;
 205 }
 206
 207 interface CanvasRenderingContext2DSettings {
 208     alpha?: boolean;
 209     desynchronized?: boolean;
 210 }
 211
 212 interface ChannelMergerOptions extends AudioNodeOptions {
 213     numberOfInputs?: number;
 214 }
 215
 216 interface ChannelSplitterOptions extends AudioNodeOptions {
 217     numberOfOutputs?: number;
 218 }
 219
 220 interface ClientData {
 221     challenge: string;
 222     extensions?: WebAuthnExtensions;
 223     hashAlg: string | Algorithm;
 224     origin: string;
 225     rpId: string;
 226     tokenBinding?: string;
 227 }
 228
 229 interface ClientQueryOptions {
 230     includeUncontrolled?: boolean;
 231     type?: ClientTypes;
 232 }
 233
 234 interface ClipboardEventInit extends EventInit {
 235     clipboardData?: DataTransfer | null;
 236 }
 237
 238 interface CloseEventInit extends EventInit {
 239     code?: number;
 240     reason?: string;
 241     wasClean?: boolean;
 242 }
 243
 244 interface CompositionEventInit extends UIEventInit {
 245     data?: string;
 246 }
 247
 248 interface ComputedEffectTiming extends EffectTiming {
 249     activeDuration?: number;
 250     currentIteration?: number | null;
 251     endTime?: number;
 252     localTime?: number | null;
 253     progress?: number | null;
 254 }
 255
 256 interface ComputedKeyframe {
 257     composite: CompositeOperationOrAuto;
 258     computedOffset: number;
 259     easing: string;
 260     offset: number | null;
 261     [property: string]: string | number | null | undefined;
 262 }
 263
 264 interface ConfirmSiteSpecificExceptionsInformation extends ExceptionInformation {
 265     arrayOfDomainStrings?: string[];
 266 }
 267
 268 interface ConstantSourceOptions {
 269     offset?: number;
 270 }
 271
 272 interface ConstrainBooleanParameters {
 273     exact?: boolean;
 274     ideal?: boolean;
 275 }
 276
 277 interface ConstrainDOMStringParameters {
 278     exact?: string | string[];
 279     ideal?: string | string[];
 280 }
 281
 282 interface ConstrainDoubleRange extends DoubleRange {
 283     exact?: number;
 284     ideal?: number;
 285 }
 286
 287 interface ConstrainULongRange extends ULongRange {
 288     exact?: number;
 289     ideal?: number;
 290 }
 291
 292 interface ConstrainVideoFacingModeParameters {
 293     exact?: VideoFacingModeEnum | VideoFacingModeEnum[];
 294     ideal?: VideoFacingModeEnum | VideoFacingModeEnum[];
 295 }
 296
 297 interface ConvolverOptions extends AudioNodeOptions {
 298     buffer?: AudioBuffer | null;
 299     disableNormalization?: boolean;
 300 }
 301
 302 interface CredentialCreationOptions {
 303     publicKey?: PublicKeyCredentialCreationOptions;
 304     signal?: AbortSignal;
 305 }
 306
 307 interface CredentialRequestOptions {
 308     mediation?: CredentialMediationRequirement;
 309     publicKey?: PublicKeyCredentialRequestOptions;
 310     signal?: AbortSignal;
 311 }
 312
 313 interface CustomEventInit<T = any> extends EventInit {
 314     detail?: T;
 315 }
 316
 317 interface DOMMatrix2DInit {
 318     a?: number;
 319     b?: number;
 320     c?: number;
 321     d?: number;
 322     e?: number;
 323     f?: number;
 324     m11?: number;
 325     m12?: number;
 326     m21?: number;
 327     m22?: number;
 328     m41?: number;
 329     m42?: number;
 330 }
 331
 332 interface DOMMatrixInit extends DOMMatrix2DInit {
 333     is2D?: boolean;
 334     m13?: number;
 335     m14?: number;
 336     m23?: number;
 337     m24?: number;
 338     m31?: number;
 339     m32?: number;
 340     m33?: number;
 341     m34?: number;
 342     m43?: number;
 343     m44?: number;
 344 }
 345
 346 interface DOMPointInit {
 347     w?: number;
 348     x?: number;
 349     y?: number;
 350     z?: number;
 351 }
 352
 353 interface DOMQuadInit {
 354     p1?: DOMPointInit;
 355     p2?: DOMPointInit;
 356     p3?: DOMPointInit;
 357     p4?: DOMPointInit;
 358 }
 359
 360 interface DOMRectInit {
 361     height?: number;
 362     width?: number;
 363     x?: number;
 364     y?: number;
 365 }
 366
 367 interface DelayOptions extends AudioNodeOptions {
 368     delayTime?: number;
 369     maxDelayTime?: number;
 370 }
 371
 372 interface DeviceLightEventInit extends EventInit {
 373     value?: number;
 374 }
 375
 376 interface DeviceMotionEventAccelerationInit {
 377     x?: number | null;
 378     y?: number | null;
 379     z?: number | null;
 380 }
 381
 382 interface DeviceMotionEventInit extends EventInit {
 383     acceleration?: DeviceMotionEventAccelerationInit;
 384     accelerationIncludingGravity?: DeviceMotionEventAccelerationInit;
 385     interval?: number;
 386     rotationRate?: DeviceMotionEventRotationRateInit;
 387 }
 388
 389 interface DeviceMotionEventRotationRateInit {
 390     alpha?: number | null;
 391     beta?: number | null;
 392     gamma?: number | null;
 393 }
 394
 395 interface DeviceOrientationEventInit extends EventInit {
 396     absolute?: boolean;
 397     alpha?: number | null;
 398     beta?: number | null;
 399     gamma?: number | null;
 400 }
 401
 402 interface DevicePermissionDescriptor extends PermissionDescriptor {
 403     deviceId?: string;
 404     name: "camera" | "microphone" | "speaker";
 405 }
 406
 407 interface DocumentTimelineOptions {
 408     originTime?: number;
 409 }
 410
 411 interface DoubleRange {
 412     max?: number;
 413     min?: number;
 414 }
 415
 416 interface DragEventInit extends MouseEventInit {
 417     dataTransfer?: DataTransfer | null;
 418 }
 419
 420 interface DynamicsCompressorOptions extends AudioNodeOptions {
 421     attack?: number;
 422     knee?: number;
 423     ratio?: number;
 424     release?: number;
 425     threshold?: number;
 426 }
 427
 428 interface EcKeyAlgorithm extends KeyAlgorithm {
 429     namedCurve: NamedCurve;
 430 }
 431
 432 interface EcKeyGenParams extends Algorithm {
 433     namedCurve: NamedCurve;
 434 }
 435
 436 interface EcKeyImportParams extends Algorithm {
 437     namedCurve: NamedCurve;
 438 }
 439
 440 interface EcdhKeyDeriveParams extends Algorithm {
 441     public: CryptoKey;
 442 }
 443
 444 interface EcdsaParams extends Algorithm {
 445     hash: HashAlgorithmIdentifier;
 446 }
 447
 448 interface EffectTiming {
 449     delay?: number;
 450     direction?: PlaybackDirection;
 451     duration?: number | string;
 452     easing?: string;
 453     endDelay?: number;
 454     fill?: FillMode;
 455     iterationStart?: number;
 456     iterations?: number;
 457 }
 458
 459 interface ElementCreationOptions {
 460     is?: string;
 461 }
 462
 463 interface ElementDefinitionOptions {
 464     extends?: string;
 465 }
 466
 467 interface ErrorEventInit extends EventInit {
 468     colno?: number;
 469     error?: any;
 470     filename?: string;
 471     lineno?: number;
 472     message?: string;
 473 }
 474
 475 interface EventInit {
 476     bubbles?: boolean;
 477     cancelable?: boolean;
 478     composed?: boolean;
 479 }
 480
 481 interface EventListenerOptions {
 482     capture?: boolean;
 483 }
 484
 485 interface EventModifierInit extends UIEventInit {
 486     altKey?: boolean;
 487     ctrlKey?: boolean;
 488     metaKey?: boolean;
 489     modifierAltGraph?: boolean;
 490     modifierCapsLock?: boolean;
 491     modifierFn?: boolean;
 492     modifierFnLock?: boolean;
 493     modifierHyper?: boolean;
 494     modifierNumLock?: boolean;
 495     modifierScrollLock?: boolean;
 496     modifierSuper?: boolean;
 497     modifierSymbol?: boolean;
 498     modifierSymbolLock?: boolean;
 499     shiftKey?: boolean;
 500 }
 501
 502 interface EventSourceInit {
 503     withCredentials?: boolean;
 504 }
 505
 506 interface ExceptionInformation {
 507     domain?: string | null;
 508 }
 509
 510 interface FilePropertyBag extends BlobPropertyBag {
 511     lastModified?: number;
 512 }
 513
 514 interface FocusEventInit extends UIEventInit {
 515     relatedTarget?: EventTarget | null;
 516 }
 517
 518 interface FocusNavigationEventInit extends EventInit {
 519     navigationReason?: string | null;
 520     originHeight?: number;
 521     originLeft?: number;
 522     originTop?: number;
 523     originWidth?: number;
 524 }
 525
 526 interface FocusNavigationOrigin {
 527     originHeight?: number;
 528     originLeft?: number;
 529     originTop?: number;
 530     originWidth?: number;
 531 }
 532
 533 interface FocusOptions {
 534     preventScroll?: boolean;
 535 }
 536
 537 interface FullscreenOptions {
 538     navigationUI?: FullscreenNavigationUI;
 539 }
 540
 541 interface GainOptions extends AudioNodeOptions {
 542     gain?: number;
 543 }
 544
 545 interface GamepadEventInit extends EventInit {
 546     gamepad: Gamepad;
 547 }
 548
 549 interface GetNotificationOptions {
 550     tag?: string;
 551 }
 552
 553 interface GetRootNodeOptions {
 554     composed?: boolean;
 555 }
 556
 557 interface HashChangeEventInit extends EventInit {
 558     newURL?: string;
 559     oldURL?: string;
 560 }
 561
 562 interface HkdfParams extends Algorithm {
 563     hash: HashAlgorithmIdentifier;
 564     info: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;
 565     salt: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;
 566 }
 567
 568 interface HmacImportParams extends Algorithm {
 569     hash: HashAlgorithmIdentifier;
 570     length?: number;
 571 }
 572
 573 interface HmacKeyAlgorithm extends KeyAlgorithm {
 574     hash: KeyAlgorithm;
 575     length: number;
 576 }
 577
 578 interface HmacKeyGenParams extends Algorithm {
 579     hash: HashAlgorithmIdentifier;
 580     length?: number;
 581 }
 582
 583 interface IDBIndexParameters {
 584     multiEntry?: boolean;
 585     unique?: boolean;
 586 }
 587
 588 interface IDBObjectStoreParameters {
 589     autoIncrement?: boolean;
 590     keyPath?: string | string[] | null;
 591 }
 592
 593 interface IDBVersionChangeEventInit extends EventInit {
 594     newVersion?: number | null;
 595     oldVersion?: number;
 596 }
 597
 598 interface IIRFilterOptions extends AudioNodeOptions {
 599     feedback: number[];
 600     feedforward: number[];
 601 }
 602
 603 interface ImageBitmapOptions {
 604     colorSpaceConversion?: ColorSpaceConversion;
 605     imageOrientation?: ImageOrientation;
 606     premultiplyAlpha?: PremultiplyAlpha;
 607     resizeHeight?: number;
 608     resizeQuality?: ResizeQuality;
 609     resizeWidth?: number;
 610 }
 611
 612 interface ImageBitmapRenderingContextSettings {
 613     alpha?: boolean;
 614 }
 615
 616 interface ImageEncodeOptions {
 617     quality?: number;
 618     type?: string;
 619 }
 620
 621 interface InputEventInit extends UIEventInit {
 622     data?: string | null;
 623     inputType?: string;
 624     isComposing?: boolean;
 625 }
 626
 627 interface IntersectionObserverEntryInit {
 628     boundingClientRect: DOMRectInit;
 629     intersectionRatio: number;
 630     intersectionRect: DOMRectInit;
 631     isIntersecting: boolean;
 632     rootBounds: DOMRectInit | null;
 633     target: Element;
 634     time: number;
 635 }
 636
 637 interface IntersectionObserverInit {
 638     root?: Element | null;
 639     rootMargin?: string;
 640     threshold?: number | number[];
 641 }
 642
 643 interface JsonWebKey {
 644     alg?: string;
 645     crv?: string;
 646     d?: string;
 647     dp?: string;
 648     dq?: string;
 649     e?: string;
 650     ext?: boolean;
 651     k?: string;
 652     key_ops?: string[];
 653     kty?: string;
 654     n?: string;
 655     oth?: RsaOtherPrimesInfo[];
 656     p?: string;
 657     q?: string;
 658     qi?: string;
 659     use?: string;
 660     x?: string;
 661     y?: string;
 662 }
 663
 664 interface KeyAlgorithm {
 665     name: string;
 666 }
 667
 668 interface KeyboardEventInit extends EventModifierInit {
 669     code?: string;
 670     isComposing?: boolean;
 671     key?: string;
 672     location?: number;
 673     repeat?: boolean;
 674 }
 675
 676 interface Keyframe {
 677     composite?: CompositeOperationOrAuto;
 678     easing?: string;
 679     offset?: number | null;
 680     [property: string]: string | number | null | undefined;
 681 }
 682
 683 interface KeyframeAnimationOptions extends KeyframeEffectOptions {
 684     id?: string;
 685 }
 686
 687 interface KeyframeEffectOptions extends EffectTiming {
 688     composite?: CompositeOperation;
 689     iterationComposite?: IterationCompositeOperation;
 690 }
 691
 692 interface MediaElementAudioSourceOptions {
 693     mediaElement: HTMLMediaElement;
 694 }
 695
 696 interface MediaEncryptedEventInit extends EventInit {
 697     initData?: ArrayBuffer | null;
 698     initDataType?: string;
 699 }
 700
 701 interface MediaKeyMessageEventInit extends EventInit {
 702     message: ArrayBuffer;
 703     messageType: MediaKeyMessageType;
 704 }
 705
 706 interface MediaKeySystemConfiguration {
 707     audioCapabilities?: MediaKeySystemMediaCapability[];
 708     distinctiveIdentifier?: MediaKeysRequirement;
 709     initDataTypes?: string[];
 710     label?: string;
 711     persistentState?: MediaKeysRequirement;
 712     sessionTypes?: string[];
 713     videoCapabilities?: MediaKeySystemMediaCapability[];
 714 }
 715
 716 interface MediaKeySystemMediaCapability {
 717     contentType?: string;
 718     robustness?: string;
 719 }
 720
 721 interface MediaQueryListEventInit extends EventInit {
 722     matches?: boolean;
 723     media?: string;
 724 }
 725
 726 interface MediaStreamAudioSourceOptions {
 727     mediaStream: MediaStream;
 728 }
 729
 730 interface MediaStreamConstraints {
 731     audio?: boolean | MediaTrackConstraints;
 732     peerIdentity?: string;
 733     video?: boolean | MediaTrackConstraints;
 734 }
 735
 736 interface MediaStreamErrorEventInit extends EventInit {
 737     error?: MediaStreamError | null;
 738 }
 739
 740 interface MediaStreamEventInit extends EventInit {
 741     stream?: MediaStream;
 742 }
 743
 744 interface MediaStreamTrackAudioSourceOptions {
 745     mediaStreamTrack: MediaStreamTrack;
 746 }
 747
 748 interface MediaStreamTrackEventInit extends EventInit {
 749     track: MediaStreamTrack;
 750 }
 751
 752 interface MediaTrackCapabilities {
 753     aspectRatio?: DoubleRange;
 754     autoGainControl?: boolean[];
 755     channelCount?: ULongRange;
 756     deviceId?: string;
 757     echoCancellation?: boolean[];
 758     facingMode?: string[];
 759     frameRate?: DoubleRange;
 760     groupId?: string;
 761     height?: ULongRange;
 762     latency?: DoubleRange;
 763     noiseSuppression?: boolean[];
 764     resizeMode?: string[];
 765     sampleRate?: ULongRange;
 766     sampleSize?: ULongRange;
 767     width?: ULongRange;
 768 }
 769
 770 interface MediaTrackConstraintSet {
 771     aspectRatio?: ConstrainDouble;
 772     autoGainControl?: ConstrainBoolean;
 773     channelCount?: ConstrainULong;
 774     deviceId?: ConstrainDOMString;
 775     echoCancellation?: ConstrainBoolean;
 776     facingMode?: ConstrainDOMString;
 777     frameRate?: ConstrainDouble;
 778     groupId?: ConstrainDOMString;
 779     height?: ConstrainULong;
 780     latency?: ConstrainDouble;
 781     noiseSuppression?: ConstrainBoolean;
 782     resizeMode?: ConstrainDOMString;
 783     sampleRate?: ConstrainULong;
 784     sampleSize?: ConstrainULong;
 785     width?: ConstrainULong;
 786 }
 787
 788 interface MediaTrackConstraints extends MediaTrackConstraintSet {
 789     advanced?: MediaTrackConstraintSet[];
 790 }
 791
 792 interface MediaTrackSettings {
 793     aspectRatio?: number;
 794     autoGainControl?: boolean;
 795     channelCount?: number;
 796     deviceId?: string;
 797     echoCancellation?: boolean;
 798     facingMode?: string;
 799     frameRate?: number;
 800     groupId?: string;
 801     height?: number;
 802     latency?: number;
 803     noiseSuppression?: boolean;
 804     resizeMode?: string;
 805     sampleRate?: number;
 806     sampleSize?: number;
 807     width?: number;
 808 }
 809
 810 interface MediaTrackSupportedConstraints {
 811     aspectRatio?: boolean;
 812     autoGainControl?: boolean;
 813     channelCount?: boolean;
 814     deviceId?: boolean;
 815     echoCancellation?: boolean;
 816     facingMode?: boolean;
 817     frameRate?: boolean;
 818     groupId?: boolean;
 819     height?: boolean;
 820     latency?: boolean;
 821     noiseSuppression?: boolean;
 822     resizeMode?: boolean;
 823     sampleRate?: boolean;
 824     sampleSize?: boolean;
 825     width?: boolean;
 826 }
 827
 828 interface MessageEventInit extends EventInit {
 829     data?: any;
 830     lastEventId?: string;
 831     origin?: string;
 832     ports?: MessagePort[];
 833     source?: MessageEventSource | null;
 834 }
 835
 836 interface MidiPermissionDescriptor extends PermissionDescriptor {
 837     name: "midi";
 838     sysex?: boolean;
 839 }
 840
 841 interface MouseEventInit extends EventModifierInit {
 842     button?: number;
 843     buttons?: number;
 844     clientX?: number;
 845     clientY?: number;
 846     movementX?: number;
 847     movementY?: number;
 848     relatedTarget?: EventTarget | null;
 849     screenX?: number;
 850     screenY?: number;
 851 }
 852
 853 interface MultiCacheQueryOptions extends CacheQueryOptions {
 854     cacheName?: string;
 855 }
 856
 857 interface MutationObserverInit {
 858     /**
 859      * 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.
 860      */
 861     attributeFilter?: string[];
 862     /**
 863      * Set to true if attributes is true or omitted and target's attribute value before the mutation needs to be recorded.
 864      */
 865     attributeOldValue?: boolean;
 866     /**
 867      * Set to true if mutations to target's attributes are to be observed. Can be omitted if attributeOldValue or attributeFilter is specified.
 868      */
 869     attributes?: boolean;
 870     /**
 871      * Set to true if mutations to target's data are to be observed. Can be omitted if characterDataOldValue is specified.
 872      */
 873     characterData?: boolean;
 874     /**
 875      * Set to true if characterData is set to true or omitted and target's data before the mutation needs to be recorded.
 876      */
 877     characterDataOldValue?: boolean;
 878     /**
 879      * Set to true if mutations to target's children are to be observed.
 880      */
 881     childList?: boolean;
 882     /**
 883      * Set to true if mutations to not just target, but also target's descendants are to be observed.
 884      */
 885     subtree?: boolean;
 886 }
 887
 888 interface NavigationPreloadState {
 889     enabled?: boolean;
 890     headerValue?: string;
 891 }
 892
 893 interface NotificationAction {
 894     action: string;
 895     icon?: string;
 896     title: string;
 897 }
 898
 899 interface NotificationOptions {
 900     actions?: NotificationAction[];
 901     badge?: string;
 902     body?: string;
 903     data?: any;
 904     dir?: NotificationDirection;
 905     icon?: string;
 906     image?: string;
 907     lang?: string;
 908     renotify?: boolean;
 909     requireInteraction?: boolean;
 910     silent?: boolean;
 911     tag?: string;
 912     timestamp?: number;
 913     vibrate?: VibratePattern;
 914 }
 915
 916 interface OfflineAudioCompletionEventInit extends EventInit {
 917     renderedBuffer: AudioBuffer;
 918 }
 919
 920 interface OfflineAudioContextOptions {
 921     length: number;
 922     numberOfChannels?: number;
 923     sampleRate: number;
 924 }
 925
 926 interface OptionalEffectTiming {
 927     delay?: number;
 928     direction?: PlaybackDirection;
 929     duration?: number | string;
 930     easing?: string;
 931     endDelay?: number;
 932     fill?: FillMode;
 933     iterationStart?: number;
 934     iterations?: number;
 935 }
 936
 937 interface OscillatorOptions extends AudioNodeOptions {
 938     detune?: number;
 939     frequency?: number;
 940     periodicWave?: PeriodicWave;
 941     type?: OscillatorType;
 942 }
 943
 944 interface PageTransitionEventInit extends EventInit {
 945     persisted?: boolean;
 946 }
 947
 948 interface PannerOptions extends AudioNodeOptions {
 949     coneInnerAngle?: number;
 950     coneOuterAngle?: number;
 951     coneOuterGain?: number;
 952     distanceModel?: DistanceModelType;
 953     maxDistance?: number;
 954     orientationX?: number;
 955     orientationY?: number;
 956     orientationZ?: number;
 957     panningModel?: PanningModelType;
 958     positionX?: number;
 959     positionY?: number;
 960     positionZ?: number;
 961     refDistance?: number;
 962     rolloffFactor?: number;
 963 }
 964
 965 interface PaymentCurrencyAmount {
 966     currency: string;
 967     currencySystem?: string;
 968     value: string;
 969 }
 970
 971 interface PaymentDetailsBase {
 972     displayItems?: PaymentItem[];
 973     modifiers?: PaymentDetailsModifier[];
 974     shippingOptions?: PaymentShippingOption[];
 975 }
 976
 977 interface PaymentDetailsInit extends PaymentDetailsBase {
 978     id?: string;
 979     total: PaymentItem;
 980 }
 981
 982 interface PaymentDetailsModifier {
 983     additionalDisplayItems?: PaymentItem[];
 984     data?: any;
 985     supportedMethods: string | string[];
 986     total?: PaymentItem;
 987 }
 988
 989 interface PaymentDetailsUpdate extends PaymentDetailsBase {
 990     error?: string;
 991     total?: PaymentItem;
 992 }
 993
 994 interface PaymentItem {
 995     amount: PaymentCurrencyAmount;
 996     label: string;
 997     pending?: boolean;
 998 }
 999
1000 interface PaymentMethodData {
1001     data?: any;
1002     supportedMethods: string | string[];
1003 }
1004
1005 interface PaymentOptions {
1006     requestPayerEmail?: boolean;
1007     requestPayerName?: boolean;
1008     requestPayerPhone?: boolean;
1009     requestShipping?: boolean;
1010     shippingType?: string;
1011 }
1012
1013 interface PaymentRequestUpdateEventInit extends EventInit {
1014 }
1015
1016 interface PaymentShippingOption {
1017     amount: PaymentCurrencyAmount;
1018     id: string;
1019     label: string;
1020     selected?: boolean;
1021 }
1022
1023 interface Pbkdf2Params extends Algorithm {
1024     hash: HashAlgorithmIdentifier;
1025     iterations: number;
1026     salt: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;
1027 }
1028
1029 interface PerformanceObserverInit {
1030     buffered?: boolean;
1031     entryTypes?: string[];
1032     type?: string;
1033 }
1034
1035 interface PeriodicWaveConstraints {
1036     disableNormalization?: boolean;
1037 }
1038
1039 interface PeriodicWaveOptions extends PeriodicWaveConstraints {
1040     imag?: number[] | Float32Array;
1041     real?: number[] | Float32Array;
1042 }
1043
1044 interface PermissionDescriptor {
1045     name: PermissionName;
1046 }
1047
1048 interface PipeOptions {
1049     preventAbort?: boolean;
1050     preventCancel?: boolean;
1051     preventClose?: boolean;
1052     signal?: AbortSignal;
1053 }
1054
1055 interface PointerEventInit extends MouseEventInit {
1056     height?: number;
1057     isPrimary?: boolean;
1058     pointerId?: number;
1059     pointerType?: string;
1060     pressure?: number;
1061     tangentialPressure?: number;
1062     tiltX?: number;
1063     tiltY?: number;
1064     twist?: number;
1065     width?: number;
1066 }
1067
1068 interface PopStateEventInit extends EventInit {
1069     state?: any;
1070 }
1071
1072 interface PositionOptions {
1073     enableHighAccuracy?: boolean;
1074     maximumAge?: number;
1075     timeout?: number;
1076 }
1077
1078 interface PostMessageOptions {
1079     transfer?: any[];
1080 }
1081
1082 interface ProgressEventInit extends EventInit {
1083     lengthComputable?: boolean;
1084     loaded?: number;
1085     total?: number;
1086 }
1087
1088 interface PromiseRejectionEventInit extends EventInit {
1089     promise: Promise<any>;
1090     reason?: any;
1091 }
1092
1093 interface PropertyIndexedKeyframes {
1094     composite?: CompositeOperationOrAuto | CompositeOperationOrAuto[];
1095     easing?: string | string[];
1096     offset?: number | (number | null)[];
1097     [property: string]: string | string[] | number | null | (number | null)[] | undefined;
1098 }
1099
1100 interface PublicKeyCredentialCreationOptions {
1101     attestation?: AttestationConveyancePreference;
1102     authenticatorSelection?: AuthenticatorSelectionCriteria;
1103     challenge: BufferSource;
1104     excludeCredentials?: PublicKeyCredentialDescriptor[];
1105     extensions?: AuthenticationExtensionsClientInputs;
1106     pubKeyCredParams: PublicKeyCredentialParameters[];
1107     rp: PublicKeyCredentialRpEntity;
1108     timeout?: number;
1109     user: PublicKeyCredentialUserEntity;
1110 }
1111
1112 interface PublicKeyCredentialDescriptor {
1113     id: BufferSource;
1114     transports?: AuthenticatorTransport[];
1115     type: PublicKeyCredentialType;
1116 }
1117
1118 interface PublicKeyCredentialEntity {
1119     icon?: string;
1120     name: string;
1121 }
1122
1123 interface PublicKeyCredentialParameters {
1124     alg: COSEAlgorithmIdentifier;
1125     type: PublicKeyCredentialType;
1126 }
1127
1128 interface PublicKeyCredentialRequestOptions {
1129     allowCredentials?: PublicKeyCredentialDescriptor[];
1130     challenge: BufferSource;
1131     extensions?: AuthenticationExtensionsClientInputs;
1132     rpId?: string;
1133     timeout?: number;
1134     userVerification?: UserVerificationRequirement;
1135 }
1136
1137 interface PublicKeyCredentialRpEntity extends PublicKeyCredentialEntity {
1138     id?: string;
1139 }
1140
1141 interface PublicKeyCredentialUserEntity extends PublicKeyCredentialEntity {
1142     displayName: string;
1143     id: BufferSource;
1144 }
1145
1146 interface PushPermissionDescriptor extends PermissionDescriptor {
1147     name: "push";
1148     userVisibleOnly?: boolean;
1149 }
1150
1151 interface PushSubscriptionJSON {
1152     endpoint?: string;
1153     expirationTime?: number | null;
1154     keys?: Record<string, string>;
1155 }
1156
1157 interface PushSubscriptionOptionsInit {
1158     applicationServerKey?: BufferSource | string | null;
1159     userVisibleOnly?: boolean;
1160 }
1161
1162 interface QueuingStrategy<T = any> {
1163     highWaterMark?: number;
1164     size?: QueuingStrategySizeCallback<T>;
1165 }
1166
1167 interface RTCAnswerOptions extends RTCOfferAnswerOptions {
1168 }
1169
1170 interface RTCCertificateExpiration {
1171     expires?: number;
1172 }
1173
1174 interface RTCConfiguration {
1175     bundlePolicy?: RTCBundlePolicy;
1176     certificates?: RTCCertificate[];
1177     iceCandidatePoolSize?: number;
1178     iceServers?: RTCIceServer[];
1179     iceTransportPolicy?: RTCIceTransportPolicy;
1180     peerIdentity?: string;
1181     rtcpMuxPolicy?: RTCRtcpMuxPolicy;
1182 }
1183
1184 interface RTCDTMFToneChangeEventInit extends EventInit {
1185     tone: string;
1186 }
1187
1188 interface RTCDataChannelEventInit extends EventInit {
1189     channel: RTCDataChannel;
1190 }
1191
1192 interface RTCDataChannelInit {
1193     id?: number;
1194     maxPacketLifeTime?: number;
1195     maxRetransmits?: number;
1196     negotiated?: boolean;
1197     ordered?: boolean;
1198     priority?: RTCPriorityType;
1199     protocol?: string;
1200 }
1201
1202 interface RTCDtlsFingerprint {
1203     algorithm?: string;
1204     value?: string;
1205 }
1206
1207 interface RTCDtlsParameters {
1208     fingerprints?: RTCDtlsFingerprint[];
1209     role?: RTCDtlsRole;
1210 }
1211
1212 interface RTCErrorEventInit extends EventInit {
1213     error: RTCError;
1214 }
1215
1216 interface RTCErrorInit {
1217     errorDetail: RTCErrorDetailType;
1218     httpRequestStatusCode?: number;
1219     receivedAlert?: number;
1220     sctpCauseCode?: number;
1221     sdpLineNumber?: number;
1222     sentAlert?: number;
1223 }
1224
1225 interface RTCIceCandidateAttributes extends RTCStats {
1226     addressSourceUrl?: string;
1227     candidateType?: RTCStatsIceCandidateType;
1228     ipAddress?: string;
1229     portNumber?: number;
1230     priority?: number;
1231     transport?: string;
1232 }
1233
1234 interface RTCIceCandidateComplete {
1235 }
1236
1237 interface RTCIceCandidateDictionary {
1238     foundation?: string;
1239     ip?: string;
1240     msMTurnSessionId?: string;
1241     port?: number;
1242     priority?: number;
1243     protocol?: RTCIceProtocol;
1244     relatedAddress?: string;
1245     relatedPort?: number;
1246     tcpType?: RTCIceTcpCandidateType;
1247     type?: RTCIceCandidateType;
1248 }
1249
1250 interface RTCIceCandidateInit {
1251     candidate?: string;
1252     sdpMLineIndex?: number | null;
1253     sdpMid?: string | null;
1254     usernameFragment?: string | null;
1255 }
1256
1257 interface RTCIceCandidatePair {
1258     local?: RTCIceCandidate;
1259     remote?: RTCIceCandidate;
1260 }
1261
1262 interface RTCIceCandidatePairStats extends RTCStats {
1263     availableIncomingBitrate?: number;
1264     availableOutgoingBitrate?: number;
1265     bytesReceived?: number;
1266     bytesSent?: number;
1267     localCandidateId?: string;
1268     nominated?: boolean;
1269     priority?: number;
1270     readable?: boolean;
1271     remoteCandidateId?: string;
1272     roundTripTime?: number;
1273     state?: RTCStatsIceCandidatePairState;
1274     transportId?: string;
1275     writable?: boolean;
1276 }
1277
1278 interface RTCIceGatherOptions {
1279     gatherPolicy?: RTCIceGatherPolicy;
1280     iceservers?: RTCIceServer[];
1281 }
1282
1283 interface RTCIceParameters {
1284     password?: string;
1285     usernameFragment?: string;
1286 }
1287
1288 interface RTCIceServer {
1289     credential?: string | RTCOAuthCredential;
1290     credentialType?: RTCIceCredentialType;
1291     urls: string | string[];
1292     username?: string;
1293 }
1294
1295 interface RTCIdentityProviderOptions {
1296     peerIdentity?: string;
1297     protocol?: string;
1298     usernameHint?: string;
1299 }
1300
1301 interface RTCInboundRTPStreamStats extends RTCRTPStreamStats {
1302     bytesReceived?: number;
1303     fractionLost?: number;
1304     jitter?: number;
1305     packetsLost?: number;
1306     packetsReceived?: number;
1307 }
1308
1309 interface RTCMediaStreamTrackStats extends RTCStats {
1310     audioLevel?: number;
1311     echoReturnLoss?: number;
1312     echoReturnLossEnhancement?: number;
1313     frameHeight?: number;
1314     frameWidth?: number;
1315     framesCorrupted?: number;
1316     framesDecoded?: number;
1317     framesDropped?: number;
1318     framesPerSecond?: number;
1319     framesReceived?: number;
1320     framesSent?: number;
1321     remoteSource?: boolean;
1322     ssrcIds?: string[];
1323     trackIdentifier?: string;
1324 }
1325
1326 interface RTCOAuthCredential {
1327     accessToken: string;
1328     macKey: string;
1329 }
1330
1331 interface RTCOfferAnswerOptions {
1332     voiceActivityDetection?: boolean;
1333 }
1334
1335 interface RTCOfferOptions extends RTCOfferAnswerOptions {
1336     iceRestart?: boolean;
1337     offerToReceiveAudio?: boolean;
1338     offerToReceiveVideo?: boolean;
1339 }
1340
1341 interface RTCOutboundRTPStreamStats extends RTCRTPStreamStats {
1342     bytesSent?: number;
1343     packetsSent?: number;
1344     roundTripTime?: number;
1345     targetBitrate?: number;
1346 }
1347
1348 interface RTCPeerConnectionIceErrorEventInit extends EventInit {
1349     errorCode: number;
1350     hostCandidate?: string;
1351     statusText?: string;
1352     url?: string;
1353 }
1354
1355 interface RTCPeerConnectionIceEventInit extends EventInit {
1356     candidate?: RTCIceCandidate | null;
1357     url?: string | null;
1358 }
1359
1360 interface RTCRTPStreamStats extends RTCStats {
1361     associateStatsId?: string;
1362     codecId?: string;
1363     firCount?: number;
1364     isRemote?: boolean;
1365     mediaTrackId?: string;
1366     mediaType?: string;
1367     nackCount?: number;
1368     pliCount?: number;
1369     sliCount?: number;
1370     ssrc?: string;
1371     transportId?: string;
1372 }
1373
1374 interface RTCRtcpFeedback {
1375     parameter?: string;
1376     type?: string;
1377 }
1378
1379 interface RTCRtcpParameters {
1380     cname?: string;
1381     reducedSize?: boolean;
1382 }
1383
1384 interface RTCRtpCapabilities {
1385     codecs: RTCRtpCodecCapability[];
1386     headerExtensions: RTCRtpHeaderExtensionCapability[];
1387 }
1388
1389 interface RTCRtpCodecCapability {
1390     channels?: number;
1391     clockRate: number;
1392     mimeType: string;
1393     sdpFmtpLine?: string;
1394 }
1395
1396 interface RTCRtpCodecParameters {
1397     channels?: number;
1398     clockRate: number;
1399     mimeType: string;
1400     payloadType: number;
1401     sdpFmtpLine?: string;
1402 }
1403
1404 interface RTCRtpCodingParameters {
1405     rid?: string;
1406 }
1407
1408 interface RTCRtpContributingSource {
1409     audioLevel?: number;
1410     rtpTimestamp: number;
1411     source: number;
1412     timestamp: number;
1413 }
1414
1415 interface RTCRtpDecodingParameters extends RTCRtpCodingParameters {
1416 }
1417
1418 interface RTCRtpEncodingParameters extends RTCRtpCodingParameters {
1419     active?: boolean;
1420     codecPayloadType?: number;
1421     dtx?: RTCDtxStatus;
1422     maxBitrate?: number;
1423     maxFramerate?: number;
1424     ptime?: number;
1425     scaleResolutionDownBy?: number;
1426 }
1427
1428 interface RTCRtpFecParameters {
1429     mechanism?: string;
1430     ssrc?: number;
1431 }
1432
1433 interface RTCRtpHeaderExtension {
1434     kind?: string;
1435     preferredEncrypt?: boolean;
1436     preferredId?: number;
1437     uri?: string;
1438 }
1439
1440 interface RTCRtpHeaderExtensionCapability {
1441     uri?: string;
1442 }
1443
1444 interface RTCRtpHeaderExtensionParameters {
1445     encrypted?: boolean;
1446     id: number;
1447     uri: string;
1448 }
1449
1450 interface RTCRtpParameters {
1451     codecs: RTCRtpCodecParameters[];
1452     headerExtensions: RTCRtpHeaderExtensionParameters[];
1453     rtcp: RTCRtcpParameters;
1454 }
1455
1456 interface RTCRtpReceiveParameters extends RTCRtpParameters {
1457     encodings: RTCRtpDecodingParameters[];
1458 }
1459
1460 interface RTCRtpRtxParameters {
1461     ssrc?: number;
1462 }
1463
1464 interface RTCRtpSendParameters extends RTCRtpParameters {
1465     degradationPreference?: RTCDegradationPreference;
1466     encodings: RTCRtpEncodingParameters[];
1467     priority?: RTCPriorityType;
1468     transactionId: string;
1469 }
1470
1471 interface RTCRtpSynchronizationSource extends RTCRtpContributingSource {
1472     voiceActivityFlag?: boolean;
1473 }
1474
1475 interface RTCRtpTransceiverInit {
1476     direction?: RTCRtpTransceiverDirection;
1477     sendEncodings?: RTCRtpEncodingParameters[];
1478     streams?: MediaStream[];
1479 }
1480
1481 interface RTCRtpUnhandled {
1482     muxId?: string;
1483     payloadType?: number;
1484     ssrc?: number;
1485 }
1486
1487 interface RTCSessionDescriptionInit {
1488     sdp?: string;
1489     type?: RTCSdpType;
1490 }
1491
1492 interface RTCSrtpKeyParam {
1493     keyMethod?: string;
1494     keySalt?: string;
1495     lifetime?: string;
1496     mkiLength?: number;
1497     mkiValue?: number;
1498 }
1499
1500 interface RTCSrtpSdesParameters {
1501     cryptoSuite?: string;
1502     keyParams?: RTCSrtpKeyParam[];
1503     sessionParams?: string[];
1504     tag?: number;
1505 }
1506
1507 interface RTCSsrcRange {
1508     max?: number;
1509     min?: number;
1510 }
1511
1512 interface RTCStats {
1513     id: string;
1514     timestamp: number;
1515     type: RTCStatsType;
1516 }
1517
1518 interface RTCStatsEventInit extends EventInit {
1519     report: RTCStatsReport;
1520 }
1521
1522 interface RTCStatsReport {
1523 }
1524
1525 interface RTCTrackEventInit extends EventInit {
1526     receiver: RTCRtpReceiver;
1527     streams?: MediaStream[];
1528     track: MediaStreamTrack;
1529     transceiver: RTCRtpTransceiver;
1530 }
1531
1532 interface RTCTransportStats extends RTCStats {
1533     activeConnection?: boolean;
1534     bytesReceived?: number;
1535     bytesSent?: number;
1536     localCertificateId?: string;
1537     remoteCertificateId?: string;
1538     rtcpTransportStatsId?: string;
1539     selectedCandidatePairId?: string;
1540 }
1541
1542 interface ReadableStreamReadDoneResult<T> {
1543     done: true;
1544     value?: T;
1545 }
1546
1547 interface ReadableStreamReadValueResult<T> {
1548     done: false;
1549     value: T;
1550 }
1551
1552 interface RegistrationOptions {
1553     scope?: string;
1554     type?: WorkerType;
1555     updateViaCache?: ServiceWorkerUpdateViaCache;
1556 }
1557
1558 interface RequestInit {
1559     /**
1560      * A BodyInit object or null to set request's body.
1561      */
1562     body?: BodyInit | null;
1563     /**
1564      * A string indicating how the request will interact with the browser's cache to set request's cache.
1565      */
1566     cache?: RequestCache;
1567     /**
1568      * 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.
1569      */
1570     credentials?: RequestCredentials;
1571     /**
1572      * A Headers object, an object literal, or an array of two-item arrays to set request's headers.
1573      */
1574     headers?: HeadersInit;
1575     /**
1576      * A cryptographic hash of the resource to be fetched by request. Sets request's integrity.
1577      */
1578     integrity?: string;
1579     /**
1580      * A boolean to set request's keepalive.
1581      */
1582     keepalive?: boolean;
1583     /**
1584      * A string to set request's method.
1585      */
1586     method?: string;
1587     /**
1588      * A string to indicate whether the request will use CORS, or will be restricted to same-origin URLs. Sets request's mode.
1589      */
1590     mode?: RequestMode;
1591     /**
1592      * 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.
1593      */
1594     redirect?: RequestRedirect;
1595     /**
1596      * A string whose value is a same-origin URL, "about:client", or the empty string, to set request's referrer.
1597      */
1598     referrer?: string;
1599     /**
1600      * A referrer policy to set request's referrerPolicy.
1601      */
1602     referrerPolicy?: ReferrerPolicy;
1603     /**
1604      * An AbortSignal to set request's signal.
1605      */
1606     signal?: AbortSignal | null;
1607     /**
1608      * Can only be null. Used to disassociate request from any Window.
1609      */
1610     window?: any;
1611 }
1612
1613 interface ResponseInit {
1614     headers?: HeadersInit;
1615     status?: number;
1616     statusText?: string;
1617 }
1618
1619 interface RsaHashedImportParams extends Algorithm {
1620     hash: HashAlgorithmIdentifier;
1621 }
1622
1623 interface RsaHashedKeyAlgorithm extends RsaKeyAlgorithm {
1624     hash: KeyAlgorithm;
1625 }
1626
1627 interface RsaHashedKeyGenParams extends RsaKeyGenParams {
1628     hash: HashAlgorithmIdentifier;
1629 }
1630
1631 interface RsaKeyAlgorithm extends KeyAlgorithm {
1632     modulusLength: number;
1633     publicExponent: BigInteger;
1634 }
1635
1636 interface RsaKeyGenParams extends Algorithm {
1637     modulusLength: number;
1638     publicExponent: BigInteger;
1639 }
1640
1641 interface RsaOaepParams extends Algorithm {
1642     label?: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;
1643 }
1644
1645 interface RsaOtherPrimesInfo {
1646     d?: string;
1647     r?: string;
1648     t?: string;
1649 }
1650
1651 interface RsaPssParams extends Algorithm {
1652     saltLength: number;
1653 }
1654
1655 interface SVGBoundingBoxOptions {
1656     clipped?: boolean;
1657     fill?: boolean;
1658     markers?: boolean;
1659     stroke?: boolean;
1660 }
1661
1662 interface ScopedCredentialDescriptor {
1663     id: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer | null;
1664     transports?: Transport[];
1665     type: ScopedCredentialType;
1666 }
1667
1668 interface ScopedCredentialOptions {
1669     excludeList?: ScopedCredentialDescriptor[];
1670     extensions?: WebAuthnExtensions;
1671     rpId?: string;
1672     timeoutSeconds?: number;
1673 }
1674
1675 interface ScopedCredentialParameters {
1676     algorithm: string | Algorithm;
1677     type: ScopedCredentialType;
1678 }
1679
1680 interface ScrollIntoViewOptions extends ScrollOptions {
1681     block?: ScrollLogicalPosition;
1682     inline?: ScrollLogicalPosition;
1683 }
1684
1685 interface ScrollOptions {
1686     behavior?: ScrollBehavior;
1687 }
1688
1689 interface ScrollToOptions extends ScrollOptions {
1690     left?: number;
1691     top?: number;
1692 }
1693
1694 interface SecurityPolicyViolationEventInit extends EventInit {
1695     blockedURI?: string;
1696     columnNumber?: number;
1697     documentURI?: string;
1698     effectiveDirective?: string;
1699     lineNumber?: number;
1700     originalPolicy?: string;
1701     referrer?: string;
1702     sourceFile?: string;
1703     statusCode?: number;
1704     violatedDirective?: string;
1705 }
1706
1707 interface ServiceWorkerMessageEventInit extends EventInit {
1708     data?: any;
1709     lastEventId?: string;
1710     origin?: string;
1711     ports?: MessagePort[] | null;
1712     source?: ServiceWorker | MessagePort | null;
1713 }
1714
1715 interface ShadowRootInit {
1716     delegatesFocus?: boolean;
1717     mode: ShadowRootMode;
1718 }
1719
1720 interface ShareData {
1721     text?: string;
1722     title?: string;
1723     url?: string;
1724 }
1725
1726 interface SpeechSynthesisErrorEventInit extends SpeechSynthesisEventInit {
1727     error: SpeechSynthesisErrorCode;
1728 }
1729
1730 interface SpeechSynthesisEventInit extends EventInit {
1731     charIndex?: number;
1732     charLength?: number;
1733     elapsedTime?: number;
1734     name?: string;
1735     utterance: SpeechSynthesisUtterance;
1736 }
1737
1738 interface StaticRangeInit {
1739     endContainer: Node;
1740     endOffset: number;
1741     startContainer: Node;
1742     startOffset: number;
1743 }
1744
1745 interface StereoPannerOptions extends AudioNodeOptions {
1746     pan?: number;
1747 }
1748
1749 interface StorageEstimate {
1750     quota?: number;
1751     usage?: number;
1752 }
1753
1754 interface StorageEventInit extends EventInit {
1755     key?: string | null;
1756     newValue?: string | null;
1757     oldValue?: string | null;
1758     storageArea?: Storage | null;
1759     url?: string;
1760 }
1761
1762 interface StoreExceptionsInformation extends ExceptionInformation {
1763     detailURI?: string | null;
1764     explanationString?: string | null;
1765     siteName?: string | null;
1766 }
1767
1768 interface StoreSiteSpecificExceptionsInformation extends StoreExceptionsInformation {
1769     arrayOfDomainStrings?: string[];
1770 }
1771
1772 interface TextDecodeOptions {
1773     stream?: boolean;
1774 }
1775
1776 interface TextDecoderOptions {
1777     fatal?: boolean;
1778     ignoreBOM?: boolean;
1779 }
1780
1781 interface TextEncoderEncodeIntoResult {
1782     read?: number;
1783     written?: number;
1784 }
1785
1786 interface TouchEventInit extends EventModifierInit {
1787     changedTouches?: Touch[];
1788     targetTouches?: Touch[];
1789     touches?: Touch[];
1790 }
1791
1792 interface TouchInit {
1793     altitudeAngle?: number;
1794     azimuthAngle?: number;
1795     clientX?: number;
1796     clientY?: number;
1797     force?: number;
1798     identifier: number;
1799     pageX?: number;
1800     pageY?: number;
1801     radiusX?: number;
1802     radiusY?: number;
1803     rotationAngle?: number;
1804     screenX?: number;
1805     screenY?: number;
1806     target: EventTarget;
1807     touchType?: TouchType;
1808 }
1809
1810 interface TrackEventInit extends EventInit {
1811     track?: TextTrack | null;
1812 }
1813
1814 interface Transformer<I = any, O = any> {
1815     flush?: TransformStreamDefaultControllerCallback<O>;
1816     readableType?: undefined;
1817     start?: TransformStreamDefaultControllerCallback<O>;
1818     transform?: TransformStreamDefaultControllerTransformCallback<I, O>;
1819     writableType?: undefined;
1820 }
1821
1822 interface TransitionEventInit extends EventInit {
1823     elapsedTime?: number;
1824     propertyName?: string;
1825     pseudoElement?: string;
1826 }
1827
1828 interface UIEventInit extends EventInit {
1829     detail?: number;
1830     view?: Window | null;
1831 }
1832
1833 interface ULongRange {
1834     max?: number;
1835     min?: number;
1836 }
1837
1838 interface UnderlyingByteSource {
1839     autoAllocateChunkSize?: number;
1840     cancel?: ReadableStreamErrorCallback;
1841     pull?: ReadableByteStreamControllerCallback;
1842     start?: ReadableByteStreamControllerCallback;
1843     type: "bytes";
1844 }
1845
1846 interface UnderlyingSink<W = any> {
1847     abort?: WritableStreamErrorCallback;
1848     close?: WritableStreamDefaultControllerCloseCallback;
1849     start?: WritableStreamDefaultControllerStartCallback;
1850     type?: undefined;
1851     write?: WritableStreamDefaultControllerWriteCallback<W>;
1852 }
1853
1854 interface UnderlyingSource<R = any> {
1855     cancel?: ReadableStreamErrorCallback;
1856     pull?: ReadableStreamDefaultControllerCallback<R>;
1857     start?: ReadableStreamDefaultControllerCallback<R>;
1858     type?: undefined;
1859 }
1860
1861 interface VRDisplayEventInit extends EventInit {
1862     display: VRDisplay;
1863     reason?: VRDisplayEventReason;
1864 }
1865
1866 interface VRLayer {
1867     leftBounds?: number[] | Float32Array | null;
1868     rightBounds?: number[] | Float32Array | null;
1869     source?: HTMLCanvasElement | null;
1870 }
1871
1872 interface VRStageParameters {
1873     sittingToStandingTransform?: Float32Array;
1874     sizeX?: number;
1875     sizeY?: number;
1876 }
1877
1878 interface WaveShaperOptions extends AudioNodeOptions {
1879     curve?: number[] | Float32Array;
1880     oversample?: OverSampleType;
1881 }
1882
1883 interface WebAuthnExtensions {
1884 }
1885
1886 interface WebGLContextAttributes {
1887     alpha?: boolean;
1888     antialias?: boolean;
1889     depth?: boolean;
1890     desynchronized?: boolean;
1891     failIfMajorPerformanceCaveat?: boolean;
1892     powerPreference?: WebGLPowerPreference;
1893     premultipliedAlpha?: boolean;
1894     preserveDrawingBuffer?: boolean;
1895     stencil?: boolean;
1896 }
1897
1898 interface WebGLContextEventInit extends EventInit {
1899     statusMessage?: string;
1900 }
1901
1902 interface WheelEventInit extends MouseEventInit {
1903     deltaMode?: number;
1904     deltaX?: number;
1905     deltaY?: number;
1906     deltaZ?: number;
1907 }
1908
1909 interface WorkerOptions {
1910     credentials?: RequestCredentials;
1911     name?: string;
1912     type?: WorkerType;
1913 }
1914
1915 interface WorkletOptions {
1916     credentials?: RequestCredentials;
1917 }
1918
1919 interface txAuthGenericArg {
1920     content: ArrayBuffer;
1921     contentType: string;
1922 }
1923
1924 interface EventListener {
1925     (evt: Event): void;
1926 }
1927
1928 type XPathNSResolver = ((prefix: string | null) => string | null) | { lookupNamespaceURI(prefix: string | null): string | null; };
1929
1930 /** 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. */
1931 interface ANGLE_instanced_arrays {
1932     drawArraysInstancedANGLE(mode: GLenum, first: GLint, count: GLsizei, primcount: GLsizei): void;
1933     drawElementsInstancedANGLE(mode: GLenum, count: GLsizei, type: GLenum, offset: GLintptr, primcount: GLsizei): void;
1934     vertexAttribDivisorANGLE(index: GLuint, divisor: GLuint): void;
1935     readonly VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE: GLenum;
1936 }
1937
1938 /** A controller object that allows you to abort one or more DOM requests as and when desired. */
1939 interface AbortController {
1940     /**
1941      * Returns the AbortSignal object associated with this object.
1942      */
1943     readonly signal: AbortSignal;
1944     /**
1945      * 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.
1946      */
1947     abort(): void;
1948 }
1949
1950 declare var AbortController: {
1951     prototype: AbortController;
1952     new(): AbortController;
1953 };
1954
1955 interface AbortSignalEventMap {
1956     "abort": Event;
1957 }
1958
1959 /** 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. */
1960 interface AbortSignal extends EventTarget {
1961     /**
1962      * Returns true if this AbortSignal's AbortController has signaled to abort, and false otherwise.
1963      */
1964     readonly aborted: boolean;
1965     onabort: ((this: AbortSignal, ev: Event) => any) | null;
1966     addEventListener<K extends keyof AbortSignalEventMap>(type: K, listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
1967     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
1968     removeEventListener<K extends keyof AbortSignalEventMap>(type: K, listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
1969     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
1970 }
1971
1972 declare var AbortSignal: {
1973     prototype: AbortSignal;
1974     new(): AbortSignal;
1975 };
1976
1977 interface AbstractRange {
1978     /**
1979      * Returns true if range is collapsed, and false otherwise.
1980      */
1981     readonly collapsed: boolean;
1982     /**
1983      * Returns range's end node.
1984      */
1985     readonly endContainer: Node;
1986     /**
1987      * Returns range's end offset.
1988      */
1989     readonly endOffset: number;
1990     /**
1991      * Returns range's start node.
1992      */
1993     readonly startContainer: Node;
1994     /**
1995      * Returns range's start offset.
1996      */
1997     readonly startOffset: number;
1998 }
1999
2000 declare var AbstractRange: {
2001     prototype: AbstractRange;
2002     new(): AbstractRange;
2003 };
2004
2005 interface AbstractWorkerEventMap {
2006     "error": ErrorEvent;
2007 }
2008
2009 interface AbstractWorker {
2010     onerror: ((this: AbstractWorker, ev: ErrorEvent) => any) | null;
2011     addEventListener<K extends keyof AbstractWorkerEventMap>(type: K, listener: (this: AbstractWorker, ev: AbstractWorkerEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
2012     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
2013     removeEventListener<K extends keyof AbstractWorkerEventMap>(type: K, listener: (this: AbstractWorker, ev: AbstractWorkerEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
2014     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
2015 }
2016
2017 interface AesCfbParams extends Algorithm {
2018     iv: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;
2019 }
2020
2021 interface AesCmacParams extends Algorithm {
2022     length: number;
2023 }
2024
2025 /** 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. */
2026 interface AnalyserNode extends AudioNode {
2027     fftSize: number;
2028     readonly frequencyBinCount: number;
2029     maxDecibels: number;
2030     minDecibels: number;
2031     smoothingTimeConstant: number;
2032     getByteFrequencyData(array: Uint8Array): void;
2033     getByteTimeDomainData(array: Uint8Array): void;
2034     getFloatFrequencyData(array: Float32Array): void;
2035     getFloatTimeDomainData(array: Float32Array): void;
2036 }
2037
2038 declare var AnalyserNode: {
2039     prototype: AnalyserNode;
2040     new(context: BaseAudioContext, options?: AnalyserOptions): AnalyserNode;
2041 };
2042
2043 interface Animatable {
2044     animate(keyframes: Keyframe[] | PropertyIndexedKeyframes | null, options?: number | KeyframeAnimationOptions): Animation;
2045     getAnimations(): Animation[];
2046 }
2047
2048 interface AnimationEventMap {
2049     "cancel": AnimationPlaybackEvent;
2050     "finish": AnimationPlaybackEvent;
2051 }
2052
2053 interface Animation extends EventTarget {
2054     currentTime: number | null;
2055     effect: AnimationEffect | null;
2056     readonly finished: Promise<Animation>;
2057     id: string;
2058     oncancel: ((this: Animation, ev: AnimationPlaybackEvent) => any) | null;
2059     onfinish: ((this: Animation, ev: AnimationPlaybackEvent) => any) | null;
2060     readonly pending: boolean;
2061     readonly playState: AnimationPlayState;
2062     playbackRate: number;
2063     readonly ready: Promise<Animation>;
2064     startTime: number | null;
2065     timeline: AnimationTimeline | null;
2066     cancel(): void;
2067     finish(): void;
2068     pause(): void;
2069     play(): void;
2070     reverse(): void;
2071     updatePlaybackRate(playbackRate: number): void;
2072     addEventListener<K extends keyof AnimationEventMap>(type: K, listener: (this: Animation, ev: AnimationEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
2073     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
2074     removeEventListener<K extends keyof AnimationEventMap>(type: K, listener: (this: Animation, ev: AnimationEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
2075     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
2076 }
2077
2078 declare var Animation: {
2079     prototype: Animation;
2080     new(effect?: AnimationEffect | null, timeline?: AnimationTimeline | null): Animation;
2081 };
2082
2083 interface AnimationEffect {
2084     getComputedTiming(): ComputedEffectTiming;
2085     getTiming(): EffectTiming;
2086     updateTiming(timing?: OptionalEffectTiming): void;
2087 }
2088
2089 declare var AnimationEffect: {
2090     prototype: AnimationEffect;
2091     new(): AnimationEffect;
2092 };
2093
2094 /** Events providing information related to animations. */
2095 interface AnimationEvent extends Event {
2096     readonly animationName: string;
2097     readonly elapsedTime: number;
2098     readonly pseudoElement: string;
2099 }
2100
2101 declare var AnimationEvent: {
2102     prototype: AnimationEvent;
2103     new(type: string, animationEventInitDict?: AnimationEventInit): AnimationEvent;
2104 };
2105
2106 interface AnimationFrameProvider {
2107     cancelAnimationFrame(handle: number): void;
2108     requestAnimationFrame(callback: FrameRequestCallback): number;
2109 }
2110
2111 interface AnimationPlaybackEvent extends Event {
2112     readonly currentTime: number | null;
2113     readonly timelineTime: number | null;
2114 }
2115
2116 declare var AnimationPlaybackEvent: {
2117     prototype: AnimationPlaybackEvent;
2118     new(type: string, eventInitDict?: AnimationPlaybackEventInit): AnimationPlaybackEvent;
2119 };
2120
2121 interface AnimationTimeline {
2122     readonly currentTime: number | null;
2123 }
2124
2125 declare var AnimationTimeline: {
2126     prototype: AnimationTimeline;
2127     new(): AnimationTimeline;
2128 };
2129
2130 interface ApplicationCacheEventMap {
2131     "cached": Event;
2132     "checking": Event;
2133     "downloading": Event;
2134     "error": Event;
2135     "noupdate": Event;
2136     "obsolete": Event;
2137     "progress": ProgressEvent<ApplicationCache>;
2138     "updateready": Event;
2139 }
2140
2141 interface ApplicationCache extends EventTarget {
2142     /** @deprecated */
2143     oncached: ((this: ApplicationCache, ev: Event) => any) | null;
2144     /** @deprecated */
2145     onchecking: ((this: ApplicationCache, ev: Event) => any) | null;
2146     /** @deprecated */
2147     ondownloading: ((this: ApplicationCache, ev: Event) => any) | null;
2148     /** @deprecated */
2149     onerror: ((this: ApplicationCache, ev: Event) => any) | null;
2150     /** @deprecated */
2151     onnoupdate: ((this: ApplicationCache, ev: Event) => any) | null;
2152     /** @deprecated */
2153     onobsolete: ((this: ApplicationCache, ev: Event) => any) | null;
2154     /** @deprecated */
2155     onprogress: ((this: ApplicationCache, ev: ProgressEvent<ApplicationCache>) => any) | null;
2156     /** @deprecated */
2157     onupdateready: ((this: ApplicationCache, ev: Event) => any) | null;
2158     /** @deprecated */
2159     readonly status: number;
2160     /** @deprecated */
2161     abort(): void;
2162     /** @deprecated */
2163     swapCache(): void;
2164     /** @deprecated */
2165     update(): void;
2166     readonly CHECKING: number;
2167     readonly DOWNLOADING: number;
2168     readonly IDLE: number;
2169     readonly OBSOLETE: number;
2170     readonly UNCACHED: number;
2171     readonly UPDATEREADY: number;
2172     addEventListener<K extends keyof ApplicationCacheEventMap>(type: K, listener: (this: ApplicationCache, ev: ApplicationCacheEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
2173     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
2174     removeEventListener<K extends keyof ApplicationCacheEventMap>(type: K, listener: (this: ApplicationCache, ev: ApplicationCacheEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
2175     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
2176 }
2177
2178 declare var ApplicationCache: {
2179     prototype: ApplicationCache;
2180     new(): ApplicationCache;
2181     readonly CHECKING: number;
2182     readonly DOWNLOADING: number;
2183     readonly IDLE: number;
2184     readonly OBSOLETE: number;
2185     readonly UNCACHED: number;
2186     readonly UPDATEREADY: number;
2187 };
2188
2189 /** 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. */
2190 interface Attr extends Node {
2191     readonly localName: string;
2192     readonly name: string;
2193     readonly namespaceURI: string | null;
2194     readonly ownerDocument: Document;
2195     readonly ownerElement: Element | null;
2196     readonly prefix: string | null;
2197     readonly specified: boolean;
2198     value: string;
2199 }
2200
2201 declare var Attr: {
2202     prototype: Attr;
2203     new(): Attr;
2204 };
2205
2206 /** 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. */
2207 interface AudioBuffer {
2208     readonly duration: number;
2209     readonly length: number;
2210     readonly numberOfChannels: number;
2211     readonly sampleRate: number;
2212     copyFromChannel(destination: Float32Array, channelNumber: number, bufferOffset?: number): void;
2213     copyToChannel(source: Float32Array, channelNumber: number, bufferOffset?: number): void;
2214     getChannelData(channel: number): Float32Array;
2215 }
2216
2217 declare var AudioBuffer: {
2218     prototype: AudioBuffer;
2219     new(options: AudioBufferOptions): AudioBuffer;
2220 };
2221
2222 /** 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. */
2223 interface AudioBufferSourceNode extends AudioScheduledSourceNode {
2224     buffer: AudioBuffer | null;
2225     readonly detune: AudioParam;
2226     loop: boolean;
2227     loopEnd: number;
2228     loopStart: number;
2229     readonly playbackRate: AudioParam;
2230     start(when?: number, offset?: number, duration?: number): void;
2231     addEventListener<K extends keyof AudioScheduledSourceNodeEventMap>(type: K, listener: (this: AudioBufferSourceNode, ev: AudioScheduledSourceNodeEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
2232     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
2233     removeEventListener<K extends keyof AudioScheduledSourceNodeEventMap>(type: K, listener: (this: AudioBufferSourceNode, ev: AudioScheduledSourceNodeEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
2234     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
2235 }
2236
2237 declare var AudioBufferSourceNode: {
2238     prototype: AudioBufferSourceNode;
2239     new(context: BaseAudioContext, options?: AudioBufferSourceOptions): AudioBufferSourceNode;
2240 };
2241
2242 /** An audio-processing graph built from audio modules linked together, each represented by an AudioNode. */
2243 interface AudioContext extends BaseAudioContext {
2244     readonly baseLatency: number;
2245     readonly outputLatency: number;
2246     close(): Promise<void>;
2247     createMediaElementSource(mediaElement: HTMLMediaElement): MediaElementAudioSourceNode;
2248     createMediaStreamDestination(): MediaStreamAudioDestinationNode;
2249     createMediaStreamSource(mediaStream: MediaStream): MediaStreamAudioSourceNode;
2250     createMediaStreamTrackSource(mediaStreamTrack: MediaStreamTrack): MediaStreamTrackAudioSourceNode;
2251     getOutputTimestamp(): AudioTimestamp;
2252     resume(): Promise<void>;
2253     suspend(): Promise<void>;
2254     addEventListener<K extends keyof BaseAudioContextEventMap>(type: K, listener: (this: AudioContext, ev: BaseAudioContextEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
2255     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
2256     removeEventListener<K extends keyof BaseAudioContextEventMap>(type: K, listener: (this: AudioContext, ev: BaseAudioContextEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
2257     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
2258 }
2259
2260 declare var AudioContext: {
2261     prototype: AudioContext;
2262     new(contextOptions?: AudioContextOptions): AudioContext;
2263 };
2264
2265 /** 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. */
2266 interface AudioDestinationNode extends AudioNode {
2267     readonly maxChannelCount: number;
2268 }
2269
2270 declare var AudioDestinationNode: {
2271     prototype: AudioDestinationNode;
2272     new(): AudioDestinationNode;
2273 };
2274
2275 /** 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. */
2276 interface AudioListener {
2277     readonly forwardX: AudioParam;
2278     readonly forwardY: AudioParam;
2279     readonly forwardZ: AudioParam;
2280     readonly positionX: AudioParam;
2281     readonly positionY: AudioParam;
2282     readonly positionZ: AudioParam;
2283     readonly upX: AudioParam;
2284     readonly upY: AudioParam;
2285     readonly upZ: AudioParam;
2286     /** @deprecated */
2287     setOrientation(x: number, y: number, z: number, xUp: number, yUp: number, zUp: number): void;
2288     /** @deprecated */
2289     setPosition(x: number, y: number, z: number): void;
2290 }
2291
2292 declare var AudioListener: {
2293     prototype: AudioListener;
2294     new(): AudioListener;
2295 };
2296
2297 /** A generic interface for representing an audio processing module. Examples include: */
2298 interface AudioNode extends EventTarget {
2299     channelCount: number;
2300     channelCountMode: ChannelCountMode;
2301     channelInterpretation: ChannelInterpretation;
2302     readonly context: BaseAudioContext;
2303     readonly numberOfInputs: number;
2304     readonly numberOfOutputs: number;
2305     connect(destinationNode: AudioNode, output?: number, input?: number): AudioNode;
2306     connect(destinationParam: AudioParam, output?: number): void;
2307     disconnect(): void;
2308     disconnect(output: number): void;
2309     disconnect(destinationNode: AudioNode): void;
2310     disconnect(destinationNode: AudioNode, output: number): void;
2311     disconnect(destinationNode: AudioNode, output: number, input: number): void;
2312     disconnect(destinationParam: AudioParam): void;
2313     disconnect(destinationParam: AudioParam, output: number): void;
2314 }
2315
2316 declare var AudioNode: {
2317     prototype: AudioNode;
2318     new(): AudioNode;
2319 };
2320
2321 /** The Web Audio API's AudioParam interface represents an audio-related parameter, usually a parameter of an AudioNode (such as GainNode.gain). */
2322 interface AudioParam {
2323     automationRate: AutomationRate;
2324     readonly defaultValue: number;
2325     readonly maxValue: number;
2326     readonly minValue: number;
2327     value: number;
2328     cancelAndHoldAtTime(cancelTime: number): AudioParam;
2329     cancelScheduledValues(cancelTime: number): AudioParam;
2330     exponentialRampToValueAtTime(value: number, endTime: number): AudioParam;
2331     linearRampToValueAtTime(value: number, endTime: number): AudioParam;
2332     setTargetAtTime(target: number, startTime: number, timeConstant: number): AudioParam;
2333     setValueAtTime(value: number, startTime: number): AudioParam;
2334     setValueCurveAtTime(values: number[] | Float32Array, startTime: number, duration: number): AudioParam;
2335 }
2336
2337 declare var AudioParam: {
2338     prototype: AudioParam;
2339     new(): AudioParam;
2340 };
2341
2342 interface AudioParamMap {
2343     forEach(callbackfn: (value: AudioParam, key: string, parent: AudioParamMap) => void, thisArg?: any): void;
2344 }
2345
2346 declare var AudioParamMap: {
2347     prototype: AudioParamMap;
2348     new(): AudioParamMap;
2349 };
2350
2351 /** The Web Audio API events that occur when a ScriptProcessorNode input buffer is ready to be processed. */
2352 interface AudioProcessingEvent extends Event {
2353     readonly inputBuffer: AudioBuffer;
2354     readonly outputBuffer: AudioBuffer;
2355     readonly playbackTime: number;
2356 }
2357
2358 declare var AudioProcessingEvent: {
2359     prototype: AudioProcessingEvent;
2360     new(type: string, eventInitDict: AudioProcessingEventInit): AudioProcessingEvent;
2361 };
2362
2363 interface AudioScheduledSourceNodeEventMap {
2364     "ended": Event;
2365 }
2366
2367 interface AudioScheduledSourceNode extends AudioNode {
2368     onended: ((this: AudioScheduledSourceNode, ev: Event) => any) | null;
2369     start(when?: number): void;
2370     stop(when?: number): void;
2371     addEventListener<K extends keyof AudioScheduledSourceNodeEventMap>(type: K, listener: (this: AudioScheduledSourceNode, ev: AudioScheduledSourceNodeEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
2372     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
2373     removeEventListener<K extends keyof AudioScheduledSourceNodeEventMap>(type: K, listener: (this: AudioScheduledSourceNode, ev: AudioScheduledSourceNodeEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
2374     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
2375 }
2376
2377 declare var AudioScheduledSourceNode: {
2378     prototype: AudioScheduledSourceNode;
2379     new(): AudioScheduledSourceNode;
2380 };
2381
2382 interface AudioWorklet extends Worklet {
2383 }
2384
2385 declare var AudioWorklet: {
2386     prototype: AudioWorklet;
2387     new(): AudioWorklet;
2388 };
2389
2390 interface AudioWorkletNodeEventMap {
2391     "processorerror": Event;
2392 }
2393
2394 interface AudioWorkletNode extends AudioNode {
2395     onprocessorerror: ((this: AudioWorkletNode, ev: Event) => any) | null;
2396     readonly parameters: AudioParamMap;
2397     readonly port: MessagePort;
2398     addEventListener<K extends keyof AudioWorkletNodeEventMap>(type: K, listener: (this: AudioWorkletNode, ev: AudioWorkletNodeEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
2399     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
2400     removeEventListener<K extends keyof AudioWorkletNodeEventMap>(type: K, listener: (this: AudioWorkletNode, ev: AudioWorkletNodeEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
2401     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
2402 }
2403
2404 declare var AudioWorkletNode: {
2405     prototype: AudioWorkletNode;
2406     new(context: BaseAudioContext, name: string, options?: AudioWorkletNodeOptions): AudioWorkletNode;
2407 };
2408
2409 interface AuthenticatorAssertionResponse extends AuthenticatorResponse {
2410     readonly authenticatorData: ArrayBuffer;
2411     readonly signature: ArrayBuffer;
2412     readonly userHandle: ArrayBuffer | null;
2413 }
2414
2415 declare var AuthenticatorAssertionResponse: {
2416     prototype: AuthenticatorAssertionResponse;
2417     new(): AuthenticatorAssertionResponse;
2418 };
2419
2420 interface AuthenticatorAttestationResponse extends AuthenticatorResponse {
2421     readonly attestationObject: ArrayBuffer;
2422 }
2423
2424 declare var AuthenticatorAttestationResponse: {
2425     prototype: AuthenticatorAttestationResponse;
2426     new(): AuthenticatorAttestationResponse;
2427 };
2428
2429 interface AuthenticatorResponse {
2430     readonly clientDataJSON: ArrayBuffer;
2431 }
2432
2433 declare var AuthenticatorResponse: {
2434     prototype: AuthenticatorResponse;
2435     new(): AuthenticatorResponse;
2436 };
2437
2438 interface BarProp {
2439     readonly visible: boolean;
2440 }
2441
2442 declare var BarProp: {
2443     prototype: BarProp;
2444     new(): BarProp;
2445 };
2446
2447 interface BaseAudioContextEventMap {
2448     "statechange": Event;
2449 }
2450
2451 interface BaseAudioContext extends EventTarget {
2452     readonly audioWorklet: AudioWorklet;
2453     readonly currentTime: number;
2454     readonly destination: AudioDestinationNode;
2455     readonly listener: AudioListener;
2456     onstatechange: ((this: BaseAudioContext, ev: Event) => any) | null;
2457     readonly sampleRate: number;
2458     readonly state: AudioContextState;
2459     createAnalyser(): AnalyserNode;
2460     createBiquadFilter(): BiquadFilterNode;
2461     createBuffer(numberOfChannels: number, length: number, sampleRate: number): AudioBuffer;
2462     createBufferSource(): AudioBufferSourceNode;
2463     createChannelMerger(numberOfInputs?: number): ChannelMergerNode;
2464     createChannelSplitter(numberOfOutputs?: number): ChannelSplitterNode;
2465     createConstantSource(): ConstantSourceNode;
2466     createConvolver(): ConvolverNode;
2467     createDelay(maxDelayTime?: number): DelayNode;
2468     createDynamicsCompressor(): DynamicsCompressorNode;
2469     createGain(): GainNode;
2470     createIIRFilter(feedforward: number[], feedback: number[]): IIRFilterNode;
2471     createOscillator(): OscillatorNode;
2472     createPanner(): PannerNode;
2473     createPeriodicWave(real: number[] | Float32Array, imag: number[] | Float32Array, constraints?: PeriodicWaveConstraints): PeriodicWave;
2474     createScriptProcessor(bufferSize?: number, numberOfInputChannels?: number, numberOfOutputChannels?: number): ScriptProcessorNode;
2475     createStereoPanner(): StereoPannerNode;
2476     createWaveShaper(): WaveShaperNode;
2477     decodeAudioData(audioData: ArrayBuffer, successCallback?: DecodeSuccessCallback | null, errorCallback?: DecodeErrorCallback | null): Promise<AudioBuffer>;
2478     addEventListener<K extends keyof BaseAudioContextEventMap>(type: K, listener: (this: BaseAudioContext, ev: BaseAudioContextEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
2479     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
2480     removeEventListener<K extends keyof BaseAudioContextEventMap>(type: K, listener: (this: BaseAudioContext, ev: BaseAudioContextEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
2481     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
2482 }
2483
2484 declare var BaseAudioContext: {
2485     prototype: BaseAudioContext;
2486     new(): BaseAudioContext;
2487 };
2488
2489 /** The beforeunload event is fired when the window, the document and its resources are about to be unloaded. */
2490 interface BeforeUnloadEvent extends Event {
2491     returnValue: any;
2492 }
2493
2494 declare var BeforeUnloadEvent: {
2495     prototype: BeforeUnloadEvent;
2496     new(): BeforeUnloadEvent;
2497 };
2498
2499 interface BhxBrowser {
2500     readonly lastError: DOMException;
2501     checkMatchesGlobExpression(pattern: string, value: string): boolean;
2502     checkMatchesUriExpression(pattern: string, value: string): boolean;
2503     clearLastError(): void;
2504     currentWindowId(): number;
2505     fireExtensionApiTelemetry(functionName: string, isSucceeded: boolean, isSupported: boolean, errorString: string): void;
2506     genericFunction(functionId: number, destination: any, parameters?: string, callbackId?: number): void;
2507     genericSynchronousFunction(functionId: number, parameters?: string): string;
2508     getExtensionId(): string;
2509     getThisAddress(): any;
2510     registerGenericFunctionCallbackHandler(callbackHandler: Function): void;
2511     registerGenericListenerHandler(eventHandler: Function): void;
2512     setLastError(parameters: string): void;
2513     webPlatformGenericFunction(destination: any, parameters?: string, callbackId?: number): void;
2514 }
2515
2516 declare var BhxBrowser: {
2517     prototype: BhxBrowser;
2518     new(): BhxBrowser;
2519 };
2520
2521 /** 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. */
2522 interface BiquadFilterNode extends AudioNode {
2523     readonly Q: AudioParam;
2524     readonly detune: AudioParam;
2525     readonly frequency: AudioParam;
2526     readonly gain: AudioParam;
2527     type: BiquadFilterType;
2528     getFrequencyResponse(frequencyHz: Float32Array, magResponse: Float32Array, phaseResponse: Float32Array): void;
2529 }
2530
2531 declare var BiquadFilterNode: {
2532     prototype: BiquadFilterNode;
2533     new(context: BaseAudioContext, options?: BiquadFilterOptions): BiquadFilterNode;
2534 };
2535
2536 /** 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. */
2537 interface Blob {
2538     readonly size: number;
2539     readonly type: string;
2540     arrayBuffer(): Promise<ArrayBuffer>;
2541     slice(start?: number, end?: number, contentType?: string): Blob;
2542     stream(): ReadableStream;
2543     text(): Promise<string>;
2544 }
2545
2546 declare var Blob: {
2547     prototype: Blob;
2548     new(blobParts?: BlobPart[], options?: BlobPropertyBag): Blob;
2549 };
2550
2551 interface Body {
2552     readonly body: ReadableStream<Uint8Array> | null;
2553     readonly bodyUsed: boolean;
2554     arrayBuffer(): Promise<ArrayBuffer>;
2555     blob(): Promise<Blob>;
2556     formData(): Promise<FormData>;
2557     json(): Promise<any>;
2558     text(): Promise<string>;
2559 }
2560
2561 interface BroadcastChannelEventMap {
2562     "message": MessageEvent;
2563     "messageerror": MessageEvent;
2564 }
2565
2566 interface BroadcastChannel extends EventTarget {
2567     /**
2568      * Returns the channel name (as passed to the constructor).
2569      */
2570     readonly name: string;
2571     onmessage: ((this: BroadcastChannel, ev: MessageEvent) => any) | null;
2572     onmessageerror: ((this: BroadcastChannel, ev: MessageEvent) => any) | null;
2573     /**
2574      * Closes the BroadcastChannel object, opening it up to garbage collection.
2575      */
2576     close(): void;
2577     /**
2578      * Sends the given message to other BroadcastChannel objects set up for this channel. Messages can be structured objects, e.g. nested objects and arrays.
2579      */
2580     postMessage(message: any): void;
2581     addEventListener<K extends keyof BroadcastChannelEventMap>(type: K, listener: (this: BroadcastChannel, ev: BroadcastChannelEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
2582     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
2583     removeEventListener<K extends keyof BroadcastChannelEventMap>(type: K, listener: (this: BroadcastChannel, ev: BroadcastChannelEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
2584     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
2585 }
2586
2587 declare var BroadcastChannel: {
2588     prototype: BroadcastChannel;
2589     new(name: string): BroadcastChannel;
2590 };
2591
2592 /** This Streams API interface provides a built-in byte length queuing strategy that can be used when constructing streams. */
2593 interface ByteLengthQueuingStrategy extends QueuingStrategy<ArrayBufferView> {
2594     highWaterMark: number;
2595     size(chunk: ArrayBufferView): number;
2596 }
2597
2598 declare var ByteLengthQueuingStrategy: {
2599     prototype: ByteLengthQueuingStrategy;
2600     new(options: { highWaterMark: number }): ByteLengthQueuingStrategy;
2601 };
2602
2603 /** 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. */
2604 interface CDATASection extends Text {
2605 }
2606
2607 declare var CDATASection: {
2608     prototype: CDATASection;
2609     new(): CDATASection;
2610 };
2611
2612 /** A single condition CSS at-rule, which consists of a condition and a statement block. It is a child of CSSGroupingRule. */
2613 interface CSSConditionRule extends CSSGroupingRule {
2614     conditionText: string;
2615 }
2616
2617 declare var CSSConditionRule: {
2618     prototype: CSSConditionRule;
2619     new(): CSSConditionRule;
2620 };
2621
2622 interface CSSFontFaceRule extends CSSRule {
2623     readonly style: CSSStyleDeclaration;
2624 }
2625
2626 declare var CSSFontFaceRule: {
2627     prototype: CSSFontFaceRule;
2628     new(): CSSFontFaceRule;
2629 };
2630
2631 /** Any CSS at-rule that contains other rules nested within it. */
2632 interface CSSGroupingRule extends CSSRule {
2633     readonly cssRules: CSSRuleList;
2634     deleteRule(index: number): void;
2635     insertRule(rule: string, index?: number): number;
2636 }
2637
2638 declare var CSSGroupingRule: {
2639     prototype: CSSGroupingRule;
2640     new(): CSSGroupingRule;
2641 };
2642
2643 interface CSSImportRule extends CSSRule {
2644     readonly href: string;
2645     readonly media: MediaList;
2646     readonly styleSheet: CSSStyleSheet;
2647 }
2648
2649 declare var CSSImportRule: {
2650     prototype: CSSImportRule;
2651     new(): CSSImportRule;
2652 };
2653
2654 /** 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). */
2655 interface CSSKeyframeRule extends CSSRule {
2656     keyText: string;
2657     readonly style: CSSStyleDeclaration;
2658 }
2659
2660 declare var CSSKeyframeRule: {
2661     prototype: CSSKeyframeRule;
2662     new(): CSSKeyframeRule;
2663 };
2664
2665 /** 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). */
2666 interface CSSKeyframesRule extends CSSRule {
2667     readonly cssRules: CSSRuleList;
2668     name: string;
2669     appendRule(rule: string): void;
2670     deleteRule(select: string): void;
2671     findRule(select: string): CSSKeyframeRule | null;
2672 }
2673
2674 declare var CSSKeyframesRule: {
2675     prototype: CSSKeyframesRule;
2676     new(): CSSKeyframesRule;
2677 };
2678
2679 /** 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). */
2680 interface CSSMediaRule extends CSSConditionRule {
2681     readonly media: MediaList;
2682 }
2683
2684 declare var CSSMediaRule: {
2685     prototype: CSSMediaRule;
2686     new(): CSSMediaRule;
2687 };
2688
2689 /** An object representing a single CSS @namespace at-rule. It implements the CSSRule interface, with a type value of 10 (CSSRule.NAMESPACE_RULE). */
2690 interface CSSNamespaceRule extends CSSRule {
2691     readonly namespaceURI: string;
2692     readonly prefix: string;
2693 }
2694
2695 declare var CSSNamespaceRule: {
2696     prototype: CSSNamespaceRule;
2697     new(): CSSNamespaceRule;
2698 };
2699
2700 /** CSSPageRule is an interface representing a single CSS @page rule. It implements the CSSRule interface with a type value of 6 (CSSRule.PAGE_RULE). */
2701 interface CSSPageRule extends CSSGroupingRule {
2702     selectorText: string;
2703     readonly style: CSSStyleDeclaration;
2704 }
2705
2706 declare var CSSPageRule: {
2707     prototype: CSSPageRule;
2708     new(): CSSPageRule;
2709 };
2710
2711 /** A single CSS rule. There are several types of rules, listed in the Type constants section below. */
2712 interface CSSRule {
2713     cssText: string;
2714     readonly parentRule: CSSRule | null;
2715     readonly parentStyleSheet: CSSStyleSheet | null;
2716     readonly type: number;
2717     readonly CHARSET_RULE: number;
2718     readonly FONT_FACE_RULE: number;
2719     readonly IMPORT_RULE: number;
2720     readonly KEYFRAMES_RULE: number;
2721     readonly KEYFRAME_RULE: number;
2722     readonly MEDIA_RULE: number;
2723     readonly NAMESPACE_RULE: number;
2724     readonly PAGE_RULE: number;
2725     readonly STYLE_RULE: number;
2726     readonly SUPPORTS_RULE: number;
2727 }
2728
2729 declare var CSSRule: {
2730     prototype: CSSRule;
2731     new(): CSSRule;
2732     readonly CHARSET_RULE: number;
2733     readonly FONT_FACE_RULE: number;
2734     readonly IMPORT_RULE: number;
2735     readonly KEYFRAMES_RULE: number;
2736     readonly KEYFRAME_RULE: number;
2737     readonly MEDIA_RULE: number;
2738     readonly NAMESPACE_RULE: number;
2739     readonly PAGE_RULE: number;
2740     readonly STYLE_RULE: number;
2741     readonly SUPPORTS_RULE: number;
2742 };
2743
2744 /** A CSSRuleList is an (indirect-modify only) array-like object containing an ordered collection of CSSRule objects. */
2745 interface CSSRuleList {
2746     readonly length: number;
2747     item(index: number): CSSRule | null;
2748     [index: number]: CSSRule;
2749 }
2750
2751 declare var CSSRuleList: {
2752     prototype: CSSRuleList;
2753     new(): CSSRuleList;
2754 };
2755
2756 /** An object that is a CSS declaration block, and exposes style information and various style-related methods and properties. */
2757 interface CSSStyleDeclaration {
2758     alignContent: string;
2759     alignItems: string;
2760     alignSelf: string;
2761     alignmentBaseline: string;
2762     all: string;
2763     animation: string;
2764     animationDelay: string;
2765     animationDirection: string;
2766     animationDuration: string;
2767     animationFillMode: string;
2768     animationIterationCount: string;
2769     animationName: string;
2770     animationPlayState: string;
2771     animationTimingFunction: string;
2772     backfaceVisibility: string;
2773     background: string;
2774     backgroundAttachment: string;
2775     backgroundClip: string;
2776     backgroundColor: string;
2777     backgroundImage: string;
2778     backgroundOrigin: string;
2779     backgroundPosition: string;
2780     backgroundPositionX: string;
2781     backgroundPositionY: string;
2782     backgroundRepeat: string;
2783     backgroundSize: string;
2784     baselineShift: string;
2785     blockSize: string;
2786     border: string;
2787     borderBlockEnd: string;
2788     borderBlockEndColor: string;
2789     borderBlockEndStyle: string;
2790     borderBlockEndWidth: string;
2791     borderBlockStart: string;
2792     borderBlockStartColor: string;
2793     borderBlockStartStyle: string;
2794     borderBlockStartWidth: string;
2795     borderBottom: string;
2796     borderBottomColor: string;
2797     borderBottomLeftRadius: string;
2798     borderBottomRightRadius: string;
2799     borderBottomStyle: string;
2800     borderBottomWidth: string;
2801     borderCollapse: string;
2802     borderColor: string;
2803     borderImage: string;
2804     borderImageOutset: string;
2805     borderImageRepeat: string;
2806     borderImageSlice: string;
2807     borderImageSource: string;
2808     borderImageWidth: string;
2809     borderInlineEnd: string;
2810     borderInlineEndColor: string;
2811     borderInlineEndStyle: string;
2812     borderInlineEndWidth: string;
2813     borderInlineStart: string;
2814     borderInlineStartColor: string;
2815     borderInlineStartStyle: string;
2816     borderInlineStartWidth: string;
2817     borderLeft: string;
2818     borderLeftColor: string;
2819     borderLeftStyle: string;
2820     borderLeftWidth: string;
2821     borderRadius: string;
2822     borderRight: string;
2823     borderRightColor: string;
2824     borderRightStyle: string;
2825     borderRightWidth: string;
2826     borderSpacing: string;
2827     borderStyle: string;
2828     borderTop: string;
2829     borderTopColor: string;
2830     borderTopLeftRadius: string;
2831     borderTopRightRadius: string;
2832     borderTopStyle: string;
2833     borderTopWidth: string;
2834     borderWidth: string;
2835     bottom: string;
2836     boxShadow: string;
2837     boxSizing: string;
2838     breakAfter: string;
2839     breakBefore: string;
2840     breakInside: string;
2841     captionSide: string;
2842     caretColor: string;
2843     clear: string;
2844     clip: string;
2845     clipPath: string;
2846     clipRule: string;
2847     color: string;
2848     colorInterpolation: string;
2849     colorInterpolationFilters: string;
2850     columnCount: string;
2851     columnFill: string;
2852     columnGap: string;
2853     columnRule: string;
2854     columnRuleColor: string;
2855     columnRuleStyle: string;
2856     columnRuleWidth: string;
2857     columnSpan: string;
2858     columnWidth: string;
2859     columns: string;
2860     content: string;
2861     counterIncrement: string;
2862     counterReset: string;
2863     cssFloat: string;
2864     cssText: string;
2865     cursor: string;
2866     direction: string;
2867     display: string;
2868     dominantBaseline: string;
2869     emptyCells: string;
2870     fill: string;
2871     fillOpacity: string;
2872     fillRule: string;
2873     filter: string;
2874     flex: string;
2875     flexBasis: string;
2876     flexDirection: string;
2877     flexFlow: string;
2878     flexGrow: string;
2879     flexShrink: string;
2880     flexWrap: string;
2881     float: string;
2882     floodColor: string;
2883     floodOpacity: string;
2884     font: string;
2885     fontFamily: string;
2886     fontFeatureSettings: string;
2887     fontKerning: string;
2888     fontSize: string;
2889     fontSizeAdjust: string;
2890     fontStretch: string;
2891     fontStyle: string;
2892     fontSynthesis: string;
2893     fontVariant: string;
2894     fontVariantCaps: string;
2895     fontVariantEastAsian: string;
2896     fontVariantLigatures: string;
2897     fontVariantNumeric: string;
2898     fontVariantPosition: string;
2899     fontWeight: string;
2900     gap: string;
2901     glyphOrientationVertical: string;
2902     grid: string;
2903     gridArea: string;
2904     gridAutoColumns: string;
2905     gridAutoFlow: string;
2906     gridAutoRows: string;
2907     gridColumn: string;
2908     gridColumnEnd: string;
2909     gridColumnGap: string;
2910     gridColumnStart: string;
2911     gridGap: string;
2912     gridRow: string;
2913     gridRowEnd: string;
2914     gridRowGap: string;
2915     gridRowStart: string;
2916     gridTemplate: string;
2917     gridTemplateAreas: string;
2918     gridTemplateColumns: string;
2919     gridTemplateRows: string;
2920     height: string;
2921     hyphens: string;
2922     imageOrientation: string;
2923     imageRendering: string;
2924     inlineSize: string;
2925     justifyContent: string;
2926     justifyItems: string;
2927     justifySelf: string;
2928     left: string;
2929     readonly length: number;
2930     letterSpacing: string;
2931     lightingColor: string;
2932     lineBreak: string;
2933     lineHeight: string;
2934     listStyle: string;
2935     listStyleImage: string;
2936     listStylePosition: string;
2937     listStyleType: string;
2938     margin: string;
2939     marginBlockEnd: string;
2940     marginBlockStart: string;
2941     marginBottom: string;
2942     marginInlineEnd: string;
2943     marginInlineStart: string;
2944     marginLeft: string;
2945     marginRight: string;
2946     marginTop: string;
2947     marker: string;
2948     markerEnd: string;
2949     markerMid: string;
2950     markerStart: string;
2951     mask: string;
2952     maskComposite: string;
2953     maskImage: string;
2954     maskPosition: string;
2955     maskRepeat: string;
2956     maskSize: string;
2957     maskType: string;
2958     maxBlockSize: string;
2959     maxHeight: string;
2960     maxInlineSize: string;
2961     maxWidth: string;
2962     minBlockSize: string;
2963     minHeight: string;
2964     minInlineSize: string;
2965     minWidth: string;
2966     objectFit: string;
2967     objectPosition: string;
2968     opacity: string;
2969     order: string;
2970     orphans: string;
2971     outline: string;
2972     outlineColor: string;
2973     outlineOffset: string;
2974     outlineStyle: string;
2975     outlineWidth: string;
2976     overflow: string;
2977     overflowAnchor: string;
2978     overflowWrap: string;
2979     overflowX: string;
2980     overflowY: string;
2981     padding: string;
2982     paddingBlockEnd: string;
2983     paddingBlockStart: string;
2984     paddingBottom: string;
2985     paddingInlineEnd: string;
2986     paddingInlineStart: string;
2987     paddingLeft: string;
2988     paddingRight: string;
2989     paddingTop: string;
2990     pageBreakAfter: string;
2991     pageBreakBefore: string;
2992     pageBreakInside: string;
2993     paintOrder: string;
2994     readonly parentRule: CSSRule | null;
2995     perspective: string;
2996     perspectiveOrigin: string;
2997     placeContent: string;
2998     placeItems: string;
2999     placeSelf: string;
3000     pointerEvents: string;
3001     position: string;
3002     quotes: string;
3003     resize: string;
3004     right: string;
3005     rotate: string;
3006     rowGap: string;
3007     rubyAlign: string;
3008     rubyPosition: string;
3009     scale: string;
3010     scrollBehavior: string;
3011     shapeRendering: string;
3012     stopColor: string;
3013     stopOpacity: string;
3014     stroke: string;
3015     strokeDasharray: string;
3016     strokeDashoffset: string;
3017     strokeLinecap: string;
3018     strokeLinejoin: string;
3019     strokeMiterlimit: string;
3020     strokeOpacity: string;
3021     strokeWidth: string;
3022     tabSize: string;
3023     tableLayout: string;
3024     textAlign: string;
3025     textAlignLast: string;
3026     textAnchor: string;
3027     textCombineUpright: string;
3028     textDecoration: string;
3029     textDecorationColor: string;
3030     textDecorationLine: string;
3031     textDecorationStyle: string;
3032     textEmphasis: string;
3033     textEmphasisColor: string;
3034     textEmphasisPosition: string;
3035     textEmphasisStyle: string;
3036     textIndent: string;
3037     textJustify: string;
3038     textOrientation: string;
3039     textOverflow: string;
3040     textRendering: string;
3041     textShadow: string;
3042     textTransform: string;
3043     textUnderlinePosition: string;
3044     top: string;
3045     touchAction: string;
3046     transform: string;
3047     transformBox: string;
3048     transformOrigin: string;
3049     transformStyle: string;
3050     transition: string;
3051     transitionDelay: string;
3052     transitionDuration: string;
3053     transitionProperty: string;
3054     transitionTimingFunction: string;
3055     translate: string;
3056     unicodeBidi: string;
3057     userSelect: string;
3058     verticalAlign: string;
3059     visibility: string;
3060     /** @deprecated */
3061     webkitAlignContent: string;
3062     /** @deprecated */
3063     webkitAlignItems: string;
3064     /** @deprecated */
3065     webkitAlignSelf: string;
3066     /** @deprecated */
3067     webkitAnimation: string;
3068     /** @deprecated */
3069     webkitAnimationDelay: string;
3070     /** @deprecated */
3071     webkitAnimationDirection: string;
3072     /** @deprecated */
3073     webkitAnimationDuration: string;
3074     /** @deprecated */
3075     webkitAnimationFillMode: string;
3076     /** @deprecated */
3077     webkitAnimationIterationCount: string;
3078     /** @deprecated */
3079     webkitAnimationName: string;
3080     /** @deprecated */
3081     webkitAnimationPlayState: string;
3082     /** @deprecated */
3083     webkitAnimationTimingFunction: string;
3084     /** @deprecated */
3085     webkitAppearance: string;
3086     /** @deprecated */
3087     webkitBackfaceVisibility: string;
3088     /** @deprecated */
3089     webkitBackgroundClip: string;
3090     /** @deprecated */
3091     webkitBackgroundOrigin: string;
3092     /** @deprecated */
3093     webkitBackgroundSize: string;
3094     /** @deprecated */
3095     webkitBorderBottomLeftRadius: string;
3096     /** @deprecated */
3097     webkitBorderBottomRightRadius: string;
3098     /** @deprecated */
3099     webkitBorderRadius: string;
3100     /** @deprecated */
3101     webkitBorderTopLeftRadius: string;
3102     /** @deprecated */
3103     webkitBorderTopRightRadius: string;
3104     /** @deprecated */
3105     webkitBoxAlign: string;
3106     /** @deprecated */
3107     webkitBoxFlex: string;
3108     /** @deprecated */
3109     webkitBoxOrdinalGroup: string;
3110     /** @deprecated */
3111     webkitBoxOrient: string;
3112     /** @deprecated */
3113     webkitBoxPack: string;
3114     /** @deprecated */
3115     webkitBoxShadow: string;
3116     /** @deprecated */
3117     webkitBoxSizing: string;
3118     /** @deprecated */
3119     webkitFilter: string;
3120     /** @deprecated */
3121     webkitFlex: string;
3122     /** @deprecated */
3123     webkitFlexBasis: string;
3124     /** @deprecated */
3125     webkitFlexDirection: string;
3126     /** @deprecated */
3127     webkitFlexFlow: string;
3128     /** @deprecated */
3129     webkitFlexGrow: string;
3130     /** @deprecated */
3131     webkitFlexShrink: string;
3132     /** @deprecated */
3133     webkitFlexWrap: string;
3134     /** @deprecated */
3135     webkitJustifyContent: string;
3136     webkitLineClamp: string;
3137     /** @deprecated */
3138     webkitMask: string;
3139     /** @deprecated */
3140     webkitMaskBoxImage: string;
3141     /** @deprecated */
3142     webkitMaskBoxImageOutset: string;
3143     /** @deprecated */
3144     webkitMaskBoxImageRepeat: string;
3145     /** @deprecated */
3146     webkitMaskBoxImageSlice: string;
3147     /** @deprecated */
3148     webkitMaskBoxImageSource: string;
3149     /** @deprecated */
3150     webkitMaskBoxImageWidth: string;
3151     /** @deprecated */
3152     webkitMaskClip: string;
3153     /** @deprecated */
3154     webkitMaskComposite: string;
3155     /** @deprecated */
3156     webkitMaskImage: string;
3157     /** @deprecated */
3158     webkitMaskOrigin: string;
3159     /** @deprecated */
3160     webkitMaskPosition: string;
3161     /** @deprecated */
3162     webkitMaskRepeat: string;
3163     /** @deprecated */
3164     webkitMaskSize: string;
3165     /** @deprecated */
3166     webkitOrder: string;
3167     /** @deprecated */
3168     webkitPerspective: string;
3169     /** @deprecated */
3170     webkitPerspectiveOrigin: string;
3171     webkitTapHighlightColor: string;
3172     /** @deprecated */
3173     webkitTextFillColor: string;
3174     /** @deprecated */
3175     webkitTextSizeAdjust: string;
3176     /** @deprecated */
3177     webkitTextStroke: string;
3178     /** @deprecated */
3179     webkitTextStrokeColor: string;
3180     /** @deprecated */
3181     webkitTextStrokeWidth: string;
3182     /** @deprecated */
3183     webkitTransform: string;
3184     /** @deprecated */
3185     webkitTransformOrigin: string;
3186     /** @deprecated */
3187     webkitTransformStyle: string;
3188     /** @deprecated */
3189     webkitTransition: string;
3190     /** @deprecated */
3191     webkitTransitionDelay: string;
3192     /** @deprecated */
3193     webkitTransitionDuration: string;
3194     /** @deprecated */
3195     webkitTransitionProperty: string;
3196     /** @deprecated */
3197     webkitTransitionTimingFunction: string;
3198     /** @deprecated */
3199     webkitUserSelect: string;
3200     whiteSpace: string;
3201     widows: string;
3202     width: string;
3203     willChange: string;
3204     wordBreak: string;
3205     wordSpacing: string;
3206     wordWrap: string;
3207     writingMode: string;
3208     zIndex: string;
3209     /** @deprecated */
3210     zoom: string;
3211     getPropertyPriority(property: string): string;
3212     getPropertyValue(property: string): string;
3213     item(index: number): string;
3214     removeProperty(property: string): string;
3215     setProperty(property: string, value: string | null, priority?: string): void;
3216     [index: number]: string;
3217 }
3218
3219 declare var CSSStyleDeclaration: {
3220     prototype: CSSStyleDeclaration;
3221     new(): CSSStyleDeclaration;
3222 };
3223
3224 /** CSSStyleRule represents a single CSS style rule. It implements the CSSRule interface with a type value of 1 (CSSRule.STYLE_RULE). */
3225 interface CSSStyleRule extends CSSRule {
3226     selectorText: string;
3227     readonly style: CSSStyleDeclaration;
3228 }
3229
3230 declare var CSSStyleRule: {
3231     prototype: CSSStyleRule;
3232     new(): CSSStyleRule;
3233 };
3234
3235 /** A single CSS style sheet. It inherits properties and methods from its parent, StyleSheet. */
3236 interface CSSStyleSheet extends StyleSheet {
3237     readonly cssRules: CSSRuleList;
3238     readonly ownerRule: CSSRule | null;
3239     readonly rules: CSSRuleList;
3240     addRule(selector?: string, style?: string, index?: number): number;
3241     deleteRule(index: number): void;
3242     insertRule(rule: string, index?: number): number;
3243     removeRule(index?: number): void;
3244 }
3245
3246 declare var CSSStyleSheet: {
3247     prototype: CSSStyleSheet;
3248     new(): CSSStyleSheet;
3249 };
3250
3251 /** 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). */
3252 interface CSSSupportsRule extends CSSConditionRule {
3253 }
3254
3255 declare var CSSSupportsRule: {
3256     prototype: CSSSupportsRule;
3257     new(): CSSSupportsRule;
3258 };
3259
3260 /** 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. */
3261 interface Cache {
3262     add(request: RequestInfo): Promise<void>;
3263     addAll(requests: RequestInfo[]): Promise<void>;
3264     delete(request: RequestInfo, options?: CacheQueryOptions): Promise<boolean>;
3265     keys(request?: RequestInfo, options?: CacheQueryOptions): Promise<ReadonlyArray<Request>>;
3266     match(request: RequestInfo, options?: CacheQueryOptions): Promise<Response | undefined>;
3267     matchAll(request?: RequestInfo, options?: CacheQueryOptions): Promise<ReadonlyArray<Response>>;
3268     put(request: RequestInfo, response: Response): Promise<void>;
3269 }
3270
3271 declare var Cache: {
3272     prototype: Cache;
3273     new(): Cache;
3274 };
3275
3276 /** The storage for Cache objects. */
3277 interface CacheStorage {
3278     delete(cacheName: string): Promise<boolean>;
3279     has(cacheName: string): Promise<boolean>;
3280     keys(): Promise<string[]>;
3281     match(request: RequestInfo, options?: MultiCacheQueryOptions): Promise<Response | undefined>;
3282     open(cacheName: string): Promise<Cache>;
3283 }
3284
3285 declare var CacheStorage: {
3286     prototype: CacheStorage;
3287     new(): CacheStorage;
3288 };
3289
3290 interface CanvasCompositing {
3291     globalAlpha: number;
3292     globalCompositeOperation: string;
3293 }
3294
3295 interface CanvasDrawImage {
3296     drawImage(image: CanvasImageSource, dx: number, dy: number): void;
3297     drawImage(image: CanvasImageSource, dx: number, dy: number, dw: number, dh: number): void;
3298     drawImage(image: CanvasImageSource, sx: number, sy: number, sw: number, sh: number, dx: number, dy: number, dw: number, dh: number): void;
3299 }
3300
3301 interface CanvasDrawPath {
3302     beginPath(): void;
3303     clip(fillRule?: CanvasFillRule): void;
3304     clip(path: Path2D, fillRule?: CanvasFillRule): void;
3305     fill(fillRule?: CanvasFillRule): void;
3306     fill(path: Path2D, fillRule?: CanvasFillRule): void;
3307     isPointInPath(x: number, y: number, fillRule?: CanvasFillRule): boolean;
3308     isPointInPath(path: Path2D, x: number, y: number, fillRule?: CanvasFillRule): boolean;
3309     isPointInStroke(x: number, y: number): boolean;
3310     isPointInStroke(path: Path2D, x: number, y: number): boolean;
3311     stroke(): void;
3312     stroke(path: Path2D): void;
3313 }
3314
3315 interface CanvasFillStrokeStyles {
3316     fillStyle: string | CanvasGradient | CanvasPattern;
3317     strokeStyle: string | CanvasGradient | CanvasPattern;
3318     createLinearGradient(x0: number, y0: number, x1: number, y1: number): CanvasGradient;
3319     createPattern(image: CanvasImageSource, repetition: string | null): CanvasPattern | null;
3320     createRadialGradient(x0: number, y0: number, r0: number, x1: number, y1: number, r1: number): CanvasGradient;
3321 }
3322
3323 interface CanvasFilters {
3324     filter: string;
3325 }
3326
3327 /** An opaque object describing a gradient. It is returned by the methods CanvasRenderingContext2D.createLinearGradient() or CanvasRenderingContext2D.createRadialGradient(). */
3328 interface CanvasGradient {
3329     /**
3330      * 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.
3331      *
3332      * Throws an "IndexSizeError" DOMException if the offset is out of range. Throws a "SyntaxError" DOMException if the color cannot be parsed.
3333      */
3334     addColorStop(offset: number, color: string): void;
3335 }
3336
3337 declare var CanvasGradient: {
3338     prototype: CanvasGradient;
3339     new(): CanvasGradient;
3340 };
3341
3342 interface CanvasImageData {
3343     createImageData(sw: number, sh: number): ImageData;
3344     createImageData(imagedata: ImageData): ImageData;
3345     getImageData(sx: number, sy: number, sw: number, sh: number): ImageData;
3346     putImageData(imagedata: ImageData, dx: number, dy: number): void;
3347     putImageData(imagedata: ImageData, dx: number, dy: number, dirtyX: number, dirtyY: number, dirtyWidth: number, dirtyHeight: number): void;
3348 }
3349
3350 interface CanvasImageSmoothing {
3351     imageSmoothingEnabled: boolean;
3352     imageSmoothingQuality: ImageSmoothingQuality;
3353 }
3354
3355 interface CanvasPath {
3356     arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, anticlockwise?: boolean): void;
3357     arcTo(x1: number, y1: number, x2: number, y2: number, radius: number): void;
3358     bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number): void;
3359     closePath(): void;
3360     ellipse(x: number, y: number, radiusX: number, radiusY: number, rotation: number, startAngle: number, endAngle: number, anticlockwise?: boolean): void;
3361     lineTo(x: number, y: number): void;
3362     moveTo(x: number, y: number): void;
3363     quadraticCurveTo(cpx: number, cpy: number, x: number, y: number): void;
3364     rect(x: number, y: number, w: number, h: number): void;
3365 }
3366
3367 interface CanvasPathDrawingStyles {
3368     lineCap: CanvasLineCap;
3369     lineDashOffset: number;
3370     lineJoin: CanvasLineJoin;
3371     lineWidth: number;
3372     miterLimit: number;
3373     getLineDash(): number[];
3374     setLineDash(segments: number[]): void;
3375 }
3376
3377 /** An opaque object describing a pattern, based on an image, a canvas, or a video, created by the CanvasRenderingContext2D.createPattern() method. */
3378 interface CanvasPattern {
3379     /**
3380      * Sets the transformation matrix that will be used when rendering the pattern during a fill or stroke painting operation.
3381      */
3382     setTransform(transform?: DOMMatrix2DInit): void;
3383 }
3384
3385 declare var CanvasPattern: {
3386     prototype: CanvasPattern;
3387     new(): CanvasPattern;
3388 };
3389
3390 interface CanvasRect {
3391     clearRect(x: number, y: number, w: number, h: number): void;
3392     fillRect(x: number, y: number, w: number, h: number): void;
3393     strokeRect(x: number, y: number, w: number, h: number): void;
3394 }
3395
3396 /** 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. */
3397 interface CanvasRenderingContext2D extends CanvasCompositing, CanvasDrawImage, CanvasDrawPath, CanvasFillStrokeStyles, CanvasFilters, CanvasImageData, CanvasImageSmoothing, CanvasPath, CanvasPathDrawingStyles, CanvasRect, CanvasShadowStyles, CanvasState, CanvasText, CanvasTextDrawingStyles, CanvasTransform, CanvasUserInterface {
3398     readonly canvas: HTMLCanvasElement;
3399 }
3400
3401 declare var CanvasRenderingContext2D: {
3402     prototype: CanvasRenderingContext2D;
3403     new(): CanvasRenderingContext2D;
3404 };
3405
3406 interface CanvasShadowStyles {
3407     shadowBlur: number;
3408     shadowColor: string;
3409     shadowOffsetX: number;
3410     shadowOffsetY: number;
3411 }
3412
3413 interface CanvasState {
3414     restore(): void;
3415     save(): void;
3416 }
3417
3418 interface CanvasText {
3419     fillText(text: string, x: number, y: number, maxWidth?: number): void;
3420     measureText(text: string): TextMetrics;
3421     strokeText(text: string, x: number, y: number, maxWidth?: number): void;
3422 }
3423
3424 interface CanvasTextDrawingStyles {
3425     direction: CanvasDirection;
3426     font: string;
3427     textAlign: CanvasTextAlign;
3428     textBaseline: CanvasTextBaseline;
3429 }
3430
3431 interface CanvasTransform {
3432     getTransform(): DOMMatrix;
3433     resetTransform(): void;
3434     rotate(angle: number): void;
3435     scale(x: number, y: number): void;
3436     setTransform(a: number, b: number, c: number, d: number, e: number, f: number): void;
3437     setTransform(transform?: DOMMatrix2DInit): void;
3438     transform(a: number, b: number, c: number, d: number, e: number, f: number): void;
3439     translate(x: number, y: number): void;
3440 }
3441
3442 interface CanvasUserInterface {
3443     drawFocusIfNeeded(element: Element): void;
3444     drawFocusIfNeeded(path: Path2D, element: Element): void;
3445     scrollPathIntoView(): void;
3446     scrollPathIntoView(path: Path2D): void;
3447 }
3448
3449 interface CaretPosition {
3450     readonly offset: number;
3451     readonly offsetNode: Node;
3452     getClientRect(): DOMRect | null;
3453 }
3454
3455 declare var CaretPosition: {
3456     prototype: CaretPosition;
3457     new(): CaretPosition;
3458 };
3459
3460 /** 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. */
3461 interface ChannelMergerNode extends AudioNode {
3462 }
3463
3464 declare var ChannelMergerNode: {
3465     prototype: ChannelMergerNode;
3466     new(context: BaseAudioContext, options?: ChannelMergerOptions): ChannelMergerNode;
3467 };
3468
3469 /** 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. */
3470 interface ChannelSplitterNode extends AudioNode {
3471 }
3472
3473 declare var ChannelSplitterNode: {
3474     prototype: ChannelSplitterNode;
3475     new(context: BaseAudioContext, options?: ChannelSplitterOptions): ChannelSplitterNode;
3476 };
3477
3478 /** 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. */
3479 interface CharacterData extends Node, ChildNode, NonDocumentTypeChildNode {
3480     data: string;
3481     readonly length: number;
3482     readonly ownerDocument: Document;
3483     appendData(data: string): void;
3484     deleteData(offset: number, count: number): void;
3485     insertData(offset: number, data: string): void;
3486     replaceData(offset: number, count: number, data: string): void;
3487     substringData(offset: number, count: number): string;
3488 }
3489
3490 declare var CharacterData: {
3491     prototype: CharacterData;
3492     new(): CharacterData;
3493 };
3494
3495 interface ChildNode extends Node {
3496     /**
3497      * Inserts nodes just after node, while replacing strings in nodes with equivalent Text nodes.
3498      *
3499      * Throws a "HierarchyRequestError" DOMException if the constraints of the node tree are violated.
3500      */
3501     after(...nodes: (Node | string)[]): void;
3502     /**
3503      * Inserts nodes just before node, while replacing strings in nodes with equivalent Text nodes.
3504      *
3505      * Throws a "HierarchyRequestError" DOMException if the constraints of the node tree are violated.
3506      */
3507     before(...nodes: (Node | string)[]): void;
3508     /**
3509      * Removes node.
3510      */
3511     remove(): void;
3512     /**
3513      * Replaces node with nodes, while replacing strings in nodes with equivalent Text nodes.
3514      *
3515      * Throws a "HierarchyRequestError" DOMException if the constraints of the node tree are violated.
3516      */
3517     replaceWith(...nodes: (Node | string)[]): void;
3518 }
3519
3520 interface ClientRect {
3521     bottom: number;
3522     readonly height: number;
3523     left: number;
3524     right: number;
3525     top: number;
3526     readonly width: number;
3527 }
3528
3529 declare var ClientRect: {
3530     prototype: ClientRect;
3531     new(): ClientRect;
3532 };
3533
3534 interface ClientRectList {
3535     readonly length: number;
3536     item(index: number): ClientRect;
3537     [index: number]: ClientRect;
3538 }
3539
3540 declare var ClientRectList: {
3541     prototype: ClientRectList;
3542     new(): ClientRectList;
3543 };
3544
3545 interface Clipboard extends EventTarget {
3546     readText(): Promise<string>;
3547     writeText(data: string): Promise<void>;
3548 }
3549
3550 declare var Clipboard: {
3551     prototype: Clipboard;
3552     new(): Clipboard;
3553 };
3554
3555 /** Events providing information related to modification of the clipboard, that is cut, copy, and paste events. */
3556 interface ClipboardEvent extends Event {
3557     readonly clipboardData: DataTransfer | null;
3558 }
3559
3560 declare var ClipboardEvent: {
3561     prototype: ClipboardEvent;
3562     new(type: string, eventInitDict?: ClipboardEventInit): ClipboardEvent;
3563 };
3564
3565 /** 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. */
3566 interface CloseEvent extends Event {
3567     /**
3568      * Returns the WebSocket connection close code provided by the server.
3569      */
3570     readonly code: number;
3571     /**
3572      * Returns the WebSocket connection close reason provided by the server.
3573      */
3574     readonly reason: string;
3575     /**
3576      * Returns true if the connection closed cleanly; false otherwise.
3577      */
3578     readonly wasClean: boolean;
3579 }
3580
3581 declare var CloseEvent: {
3582     prototype: CloseEvent;
3583     new(type: string, eventInitDict?: CloseEventInit): CloseEvent;
3584 };
3585
3586 /** Textual notations within markup; although it is generally not visually shown, such comments are available to be read in the source view. */
3587 interface Comment extends CharacterData {
3588 }
3589
3590 declare var Comment: {
3591     prototype: Comment;
3592     new(data?: string): Comment;
3593 };
3594
3595 /** The DOM CompositionEvent represents events that occur due to the user indirectly entering text. */
3596 interface CompositionEvent extends UIEvent {
3597     readonly data: string;
3598 }
3599
3600 declare var CompositionEvent: {
3601     prototype: CompositionEvent;
3602     new(type: string, eventInitDict?: CompositionEventInit): CompositionEvent;
3603 };
3604
3605 interface ConcatParams extends Algorithm {
3606     algorithmId: Uint8Array;
3607     hash?: string | Algorithm;
3608     partyUInfo: Uint8Array;
3609     partyVInfo: Uint8Array;
3610     privateInfo?: Uint8Array;
3611     publicInfo?: Uint8Array;
3612 }
3613
3614 interface ConstantSourceNode extends AudioScheduledSourceNode {
3615     readonly offset: AudioParam;
3616     addEventListener<K extends keyof AudioScheduledSourceNodeEventMap>(type: K, listener: (this: ConstantSourceNode, ev: AudioScheduledSourceNodeEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
3617     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
3618     removeEventListener<K extends keyof AudioScheduledSourceNodeEventMap>(type: K, listener: (this: ConstantSourceNode, ev: AudioScheduledSourceNodeEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
3619     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
3620 }
3621
3622 declare var ConstantSourceNode: {
3623     prototype: ConstantSourceNode;
3624     new(context: BaseAudioContext, options?: ConstantSourceOptions): ConstantSourceNode;
3625 };
3626
3627 /** 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. */
3628 interface ConvolverNode extends AudioNode {
3629     buffer: AudioBuffer | null;
3630     normalize: boolean;
3631 }
3632
3633 declare var ConvolverNode: {
3634     prototype: ConvolverNode;
3635     new(context: BaseAudioContext, options?: ConvolverOptions): ConvolverNode;
3636 };
3637
3638 /** The position and altitude of the device on Earth, as well as the accuracy with which these properties are calculated. */
3639 interface Coordinates {
3640     readonly accuracy: number;
3641     readonly altitude: number | null;
3642     readonly altitudeAccuracy: number | null;
3643     readonly heading: number | null;
3644     readonly latitude: number;
3645     readonly longitude: number;
3646     readonly speed: number | null;
3647 }
3648
3649 /** This Streams API interface provides a built-in byte length queuing strategy that can be used when constructing streams. */
3650 interface CountQueuingStrategy extends QueuingStrategy {
3651     highWaterMark: number;
3652     size(chunk: any): 1;
3653 }
3654
3655 declare var CountQueuingStrategy: {
3656     prototype: CountQueuingStrategy;
3657     new(options: { highWaterMark: number }): CountQueuingStrategy;
3658 };
3659
3660 interface Credential {
3661     readonly id: string;
3662     readonly type: string;
3663 }
3664
3665 declare var Credential: {
3666     prototype: Credential;
3667     new(): Credential;
3668 };
3669
3670 interface CredentialsContainer {
3671     create(options?: CredentialCreationOptions): Promise<Credential | null>;
3672     get(options?: CredentialRequestOptions): Promise<Credential | null>;
3673     preventSilentAccess(): Promise<void>;
3674     store(credential: Credential): Promise<Credential>;
3675 }
3676
3677 declare var CredentialsContainer: {
3678     prototype: CredentialsContainer;
3679     new(): CredentialsContainer;
3680 };
3681
3682 /** Basic cryptography features available in the current context. It allows access to a cryptographically strong random number generator and to cryptographic primitives. */
3683 interface Crypto {
3684     readonly subtle: SubtleCrypto;
3685     getRandomValues<T extends Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | null>(array: T): T;
3686 }
3687
3688 declare var Crypto: {
3689     prototype: Crypto;
3690     new(): Crypto;
3691 };
3692
3693 /** The CryptoKey dictionary of the Web Crypto API represents a cryptographic key. */
3694 interface CryptoKey {
3695     readonly algorithm: KeyAlgorithm;
3696     readonly extractable: boolean;
3697     readonly type: KeyType;
3698     readonly usages: KeyUsage[];
3699 }
3700
3701 declare var CryptoKey: {
3702     prototype: CryptoKey;
3703     new(): CryptoKey;
3704 };
3705
3706 /** The CryptoKeyPair dictionary of the Web Crypto API represents a key pair for an asymmetric cryptography algorithm, also known as a public-key algorithm. */
3707 interface CryptoKeyPair {
3708     privateKey: CryptoKey;
3709     publicKey: CryptoKey;
3710 }
3711
3712 declare var CryptoKeyPair: {
3713     prototype: CryptoKeyPair;
3714     new(): CryptoKeyPair;
3715 };
3716
3717 interface CustomElementRegistry {
3718     define(name: string, constructor: CustomElementConstructor, options?: ElementDefinitionOptions): void;
3719     get(name: string): any;
3720     upgrade(root: Node): void;
3721     whenDefined(name: string): Promise<void>;
3722 }
3723
3724 declare var CustomElementRegistry: {
3725     prototype: CustomElementRegistry;
3726     new(): CustomElementRegistry;
3727 };
3728
3729 interface CustomEvent<T = any> extends Event {
3730     /**
3731      * Returns any custom data event was created with. Typically used for synthetic events.
3732      */
3733     readonly detail: T;
3734     initCustomEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, detailArg: T): void;
3735 }
3736
3737 declare var CustomEvent: {
3738     prototype: CustomEvent;
3739     new<T>(typeArg: string, eventInitDict?: CustomEventInit<T>): CustomEvent<T>;
3740 };
3741
3742 /** An error object that contains an error name. */
3743 interface DOMError {
3744     readonly name: string;
3745     toString(): string;
3746 }
3747
3748 declare var DOMError: {
3749     prototype: DOMError;
3750     new(): DOMError;
3751 };
3752
3753 /** An abnormal event (called an exception) which occurs as a result of calling a method or accessing a property of a web API. */
3754 interface DOMException {
3755     readonly code: number;
3756     readonly message: string;
3757     readonly name: string;
3758     readonly ABORT_ERR: number;
3759     readonly DATA_CLONE_ERR: number;
3760     readonly DOMSTRING_SIZE_ERR: number;
3761     readonly HIERARCHY_REQUEST_ERR: number;
3762     readonly INDEX_SIZE_ERR: number;
3763     readonly INUSE_ATTRIBUTE_ERR: number;
3764     readonly INVALID_ACCESS_ERR: number;
3765     readonly INVALID_CHARACTER_ERR: number;
3766     readonly INVALID_MODIFICATION_ERR: number;
3767     readonly INVALID_NODE_TYPE_ERR: number;
3768     readonly INVALID_STATE_ERR: number;
3769     readonly NAMESPACE_ERR: number;
3770     readonly NETWORK_ERR: number;
3771     readonly NOT_FOUND_ERR: number;
3772     readonly NOT_SUPPORTED_ERR: number;
3773     readonly NO_DATA_ALLOWED_ERR: number;
3774     readonly NO_MODIFICATION_ALLOWED_ERR: number;
3775     readonly QUOTA_EXCEEDED_ERR: number;
3776     readonly SECURITY_ERR: number;
3777     readonly SYNTAX_ERR: number;
3778     readonly TIMEOUT_ERR: number;
3779     readonly TYPE_MISMATCH_ERR: number;
3780     readonly URL_MISMATCH_ERR: number;
3781     readonly VALIDATION_ERR: number;
3782     readonly WRONG_DOCUMENT_ERR: number;
3783 }
3784
3785 declare var DOMException: {
3786     prototype: DOMException;
3787     new(message?: string, name?: string): DOMException;
3788     readonly ABORT_ERR: number;
3789     readonly DATA_CLONE_ERR: number;
3790     readonly DOMSTRING_SIZE_ERR: number;
3791     readonly HIERARCHY_REQUEST_ERR: number;
3792     readonly INDEX_SIZE_ERR: number;
3793     readonly INUSE_ATTRIBUTE_ERR: number;
3794     readonly INVALID_ACCESS_ERR: number;
3795     readonly INVALID_CHARACTER_ERR: number;
3796     readonly INVALID_MODIFICATION_ERR: number;
3797     readonly INVALID_NODE_TYPE_ERR: number;
3798     readonly INVALID_STATE_ERR: number;
3799     readonly NAMESPACE_ERR: number;
3800     readonly NETWORK_ERR: number;
3801     readonly NOT_FOUND_ERR: number;
3802     readonly NOT_SUPPORTED_ERR: number;
3803     readonly NO_DATA_ALLOWED_ERR: number;
3804     readonly NO_MODIFICATION_ALLOWED_ERR: number;
3805     readonly QUOTA_EXCEEDED_ERR: number;
3806     readonly SECURITY_ERR: number;
3807     readonly SYNTAX_ERR: number;
3808     readonly TIMEOUT_ERR: number;
3809     readonly TYPE_MISMATCH_ERR: number;
3810     readonly URL_MISMATCH_ERR: number;
3811     readonly VALIDATION_ERR: number;
3812     readonly WRONG_DOCUMENT_ERR: number;
3813 };
3814
3815 /** An object providing methods which are not dependent on any particular document. Such an object is returned by the Document.implementation property. */
3816 interface DOMImplementation {
3817     createDocument(namespaceURI: string | null, qualifiedName: string | null, doctype: DocumentType | null): Document;
3818     createDocumentType(qualifiedName: string, publicId: string, systemId: string): DocumentType;
3819     createHTMLDocument(title?: string): Document;
3820     /** @deprecated */
3821     hasFeature(...args: any[]): true;
3822 }
3823
3824 declare var DOMImplementation: {
3825     prototype: DOMImplementation;
3826     new(): DOMImplementation;
3827 };
3828
3829 interface DOML2DeprecatedColorProperty {
3830     color: string;
3831 }
3832
3833 interface DOMMatrix extends DOMMatrixReadOnly {
3834     a: number;
3835     b: number;
3836     c: number;
3837     d: number;
3838     e: number;
3839     f: number;
3840     m11: number;
3841     m12: number;
3842     m13: number;
3843     m14: number;
3844     m21: number;
3845     m22: number;
3846     m23: number;
3847     m24: number;
3848     m31: number;
3849     m32: number;
3850     m33: number;
3851     m34: number;
3852     m41: number;
3853     m42: number;
3854     m43: number;
3855     m44: number;
3856     invertSelf(): DOMMatrix;
3857     multiplySelf(other?: DOMMatrixInit): DOMMatrix;
3858     preMultiplySelf(other?: DOMMatrixInit): DOMMatrix;
3859     rotateAxisAngleSelf(x?: number, y?: number, z?: number, angle?: number): DOMMatrix;
3860     rotateFromVectorSelf(x?: number, y?: number): DOMMatrix;
3861     rotateSelf(rotX?: number, rotY?: number, rotZ?: number): DOMMatrix;
3862     scale3dSelf(scale?: number, originX?: number, originY?: number, originZ?: number): DOMMatrix;
3863     scaleSelf(scaleX?: number, scaleY?: number, scaleZ?: number, originX?: number, originY?: number, originZ?: number): DOMMatrix;
3864     setMatrixValue(transformList: string): DOMMatrix;
3865     skewXSelf(sx?: number): DOMMatrix;
3866     skewYSelf(sy?: number): DOMMatrix;
3867     translateSelf(tx?: number, ty?: number, tz?: number): DOMMatrix;
3868 }
3869
3870 declare var DOMMatrix: {
3871     prototype: DOMMatrix;
3872     new(init?: string | number[]): DOMMatrix;
3873     fromFloat32Array(array32: Float32Array): DOMMatrix;
3874     fromFloat64Array(array64: Float64Array): DOMMatrix;
3875     fromMatrix(other?: DOMMatrixInit): DOMMatrix;
3876 };
3877
3878 type SVGMatrix = DOMMatrix;
3879 declare var SVGMatrix: typeof DOMMatrix;
3880
3881 type WebKitCSSMatrix = DOMMatrix;
3882 declare var WebKitCSSMatrix: typeof DOMMatrix;
3883
3884 interface DOMMatrixReadOnly {
3885     readonly a: number;
3886     readonly b: number;
3887     readonly c: number;
3888     readonly d: number;
3889     readonly e: number;
3890     readonly f: number;
3891     readonly is2D: boolean;
3892     readonly isIdentity: boolean;
3893     readonly m11: number;
3894     readonly m12: number;
3895     readonly m13: number;
3896     readonly m14: number;
3897     readonly m21: number;
3898     readonly m22: number;
3899     readonly m23: number;
3900     readonly m24: number;
3901     readonly m31: number;
3902     readonly m32: number;
3903     readonly m33: number;
3904     readonly m34: number;
3905     readonly m41: number;
3906     readonly m42: number;
3907     readonly m43: number;
3908     readonly m44: number;
3909     flipX(): DOMMatrix;
3910     flipY(): DOMMatrix;
3911     inverse(): DOMMatrix;
3912     multiply(other?: DOMMatrixInit): DOMMatrix;
3913     rotate(rotX?: number, rotY?: number, rotZ?: number): DOMMatrix;
3914     rotateAxisAngle(x?: number, y?: number, z?: number, angle?: number): DOMMatrix;
3915     rotateFromVector(x?: number, y?: number): DOMMatrix;
3916     scale(scaleX?: number, scaleY?: number, scaleZ?: number, originX?: number, originY?: number, originZ?: number): DOMMatrix;
3917     scale3d(scale?: number, originX?: number, originY?: number, originZ?: number): DOMMatrix;
3918     /** @deprecated */
3919     scaleNonUniform(scaleX?: number, scaleY?: number): DOMMatrix;
3920     skewX(sx?: number): DOMMatrix;
3921     skewY(sy?: number): DOMMatrix;
3922     toFloat32Array(): Float32Array;
3923     toFloat64Array(): Float64Array;
3924     toJSON(): any;
3925     transformPoint(point?: DOMPointInit): DOMPoint;
3926     translate(tx?: number, ty?: number, tz?: number): DOMMatrix;
3927     toString(): string;
3928 }
3929
3930 declare var DOMMatrixReadOnly: {
3931     prototype: DOMMatrixReadOnly;
3932     new(init?: string | number[]): DOMMatrixReadOnly;
3933     fromFloat32Array(array32: Float32Array): DOMMatrixReadOnly;
3934     fromFloat64Array(array64: Float64Array): DOMMatrixReadOnly;
3935     fromMatrix(other?: DOMMatrixInit): DOMMatrixReadOnly;
3936     toString(): string;
3937 };
3938
3939 /** Provides the ability to parse XML or HTML source code from a string into a DOM Document. */
3940 interface DOMParser {
3941     parseFromString(str: string, type: SupportedType): Document;
3942 }
3943
3944 declare var DOMParser: {
3945     prototype: DOMParser;
3946     new(): DOMParser;
3947 };
3948
3949 interface DOMPoint extends DOMPointReadOnly {
3950     w: number;
3951     x: number;
3952     y: number;
3953     z: number;
3954 }
3955
3956 declare var DOMPoint: {
3957     prototype: DOMPoint;
3958     new(x?: number, y?: number, z?: number, w?: number): DOMPoint;
3959     fromPoint(other?: DOMPointInit): DOMPoint;
3960 };
3961
3962 type SVGPoint = DOMPoint;
3963 declare var SVGPoint: typeof DOMPoint;
3964
3965 interface DOMPointReadOnly {
3966     readonly w: number;
3967     readonly x: number;
3968     readonly y: number;
3969     readonly z: number;
3970     matrixTransform(matrix?: DOMMatrixInit): DOMPoint;
3971     toJSON(): any;
3972 }
3973
3974 declare var DOMPointReadOnly: {
3975     prototype: DOMPointReadOnly;
3976     new(x?: number, y?: number, z?: number, w?: number): DOMPointReadOnly;
3977     fromPoint(other?: DOMPointInit): DOMPointReadOnly;
3978 };
3979
3980 interface DOMQuad {
3981     readonly p1: DOMPoint;
3982     readonly p2: DOMPoint;
3983     readonly p3: DOMPoint;
3984     readonly p4: DOMPoint;
3985     getBounds(): DOMRect;
3986     toJSON(): any;
3987 }
3988
3989 declare var DOMQuad: {
3990     prototype: DOMQuad;
3991     new(p1?: DOMPointInit, p2?: DOMPointInit, p3?: DOMPointInit, p4?: DOMPointInit): DOMQuad;
3992     fromQuad(other?: DOMQuadInit): DOMQuad;
3993     fromRect(other?: DOMRectInit): DOMQuad;
3994 };
3995
3996 interface DOMRect extends DOMRectReadOnly {
3997     height: number;
3998     width: number;
3999     x: number;
4000     y: number;
4001 }
4002
4003 declare var DOMRect: {
4004     prototype: DOMRect;
4005     new(x?: number, y?: number, width?: number, height?: number): DOMRect;
4006     fromRect(other?: DOMRectInit): DOMRect;
4007 };
4008
4009 type SVGRect = DOMRect;
4010 declare var SVGRect: typeof DOMRect;
4011
4012 interface DOMRectList {
4013     readonly length: number;
4014     item(index: number): DOMRect | null;
4015     [index: number]: DOMRect;
4016 }
4017
4018 declare var DOMRectList: {
4019     prototype: DOMRectList;
4020     new(): DOMRectList;
4021 };
4022
4023 interface DOMRectReadOnly {
4024     readonly bottom: number;
4025     readonly height: number;
4026     readonly left: number;
4027     readonly right: number;
4028     readonly top: number;
4029     readonly width: number;
4030     readonly x: number;
4031     readonly y: number;
4032     toJSON(): any;
4033 }
4034
4035 declare var DOMRectReadOnly: {
4036     prototype: DOMRectReadOnly;
4037     new(x?: number, y?: number, width?: number, height?: number): DOMRectReadOnly;
4038     fromRect(other?: DOMRectInit): DOMRectReadOnly;
4039 };
4040
4041 interface DOMSettableTokenList extends DOMTokenList {
4042     value: string;
4043 }
4044
4045 declare var DOMSettableTokenList: {
4046     prototype: DOMSettableTokenList;
4047     new(): DOMSettableTokenList;
4048 };
4049
4050 /** A type returned by some APIs which contains a list of DOMString (strings). */
4051 interface DOMStringList {
4052     /**
4053      * Returns the number of strings in strings.
4054      */
4055     readonly length: number;
4056     /**
4057      * Returns true if strings contains string, and false otherwise.
4058      */
4059     contains(string: string): boolean;
4060     /**
4061      * Returns the string with index index from strings.
4062      */
4063     item(index: number): string | null;
4064     [index: number]: string;
4065 }
4066
4067 declare var DOMStringList: {
4068     prototype: DOMStringList;
4069     new(): DOMStringList;
4070 };
4071
4072 /** Used by the dataset HTML attribute to represent data for custom attributes added to elements. */
4073 interface DOMStringMap {
4074     [name: string]: string | undefined;
4075 }
4076
4077 declare var DOMStringMap: {
4078     prototype: DOMStringMap;
4079     new(): DOMStringMap;
4080 };
4081
4082 /** 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. */
4083 interface DOMTokenList {
4084     /**
4085      * Returns the number of tokens.
4086      */
4087     readonly length: number;
4088     /**
4089      * Returns the associated set as string.
4090      *
4091      * Can be set, to change the associated attribute.
4092      */
4093     value: string;
4094     toString(): string;
4095     /**
4096      * Adds all arguments passed, except those already present.
4097      *
4098      * Throws a "SyntaxError" DOMException if one of the arguments is the empty string.
4099      *
4100      * Throws an "InvalidCharacterError" DOMException if one of the arguments contains any ASCII whitespace.
4101      */
4102     add(...tokens: string[]): void;
4103     /**
4104      * Returns true if token is present, and false otherwise.
4105      */
4106     contains(token: string): boolean;
4107     /**
4108      * Returns the token with index index.
4109      */
4110     item(index: number): string | null;
4111     /**
4112      * Removes arguments passed, if they are present.
4113      *
4114      * Throws a "SyntaxError" DOMException if one of the arguments is the empty string.
4115      *
4116      * Throws an "InvalidCharacterError" DOMException if one of the arguments contains any ASCII whitespace.
4117      */
4118     remove(...tokens: string[]): void;
4119     /**
4120      * Replaces token with newToken.
4121      *
4122      * Returns true if token was replaced with newToken, and false otherwise.
4123      *
4124      * Throws a "SyntaxError" DOMException if one of the arguments is the empty string.
4125      *
4126      * Throws an "InvalidCharacterError" DOMException if one of the arguments contains any ASCII whitespace.
4127      */
4128     replace(oldToken: string, newToken: string): void;
4129     /**
4130      * Returns true if token is in the associated attribute's supported tokens. Returns false otherwise.
4131      *
4132      * Throws a TypeError if the associated attribute has no supported tokens defined.
4133      */
4134     supports(token: string): boolean;
4135     /**
4136      * 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()).
4137      *
4138      * Returns true if token is now present, and false otherwise.
4139      *
4140      * Throws a "SyntaxError" DOMException if token is empty.
4141      *
4142      * Throws an "InvalidCharacterError" DOMException if token contains any spaces.
4143      */
4144     toggle(token: string, force?: boolean): boolean;
4145     forEach(callbackfn: (value: string, key: number, parent: DOMTokenList) => void, thisArg?: any): void;
4146     [index: number]: string;
4147 }
4148
4149 declare var DOMTokenList: {
4150     prototype: DOMTokenList;
4151     new(): DOMTokenList;
4152 };
4153
4154 interface DataCue extends TextTrackCue {
4155     data: ArrayBuffer;
4156     addEventListener<K extends keyof TextTrackCueEventMap>(type: K, listener: (this: DataCue, ev: TextTrackCueEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
4157     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
4158     removeEventListener<K extends keyof TextTrackCueEventMap>(type: K, listener: (this: DataCue, ev: TextTrackCueEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
4159     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
4160 }
4161
4162 declare var DataCue: {
4163     prototype: DataCue;
4164     new(): DataCue;
4165 };
4166
4167 /** 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. */
4168 interface DataTransfer {
4169     /**
4170      * 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.
4171      *
4172      * Can be set, to change the selected operation.
4173      *
4174      * The possible values are "none", "copy", "link", and "move".
4175      */
4176     dropEffect: string;
4177     /**
4178      * Returns the kinds of operations that are to be allowed.
4179      *
4180      * Can be set (during the dragstart event), to change the allowed operations.
4181      *
4182      * The possible values are "none", "copy", "copyLink", "copyMove", "link", "linkMove", "move", "all", and "uninitialized",
4183      */
4184     effectAllowed: string;
4185     /**
4186      * Returns a FileList of the files being dragged, if any.
4187      */
4188     readonly files: FileList;
4189     /**
4190      * Returns a DataTransferItemList object, with the drag data.
4191      */
4192     readonly items: DataTransferItemList;
4193     /**
4194      * 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".
4195      */
4196     readonly types: ReadonlyArray<string>;
4197     /**
4198      * Removes the data of the specified formats. Removes all data if the argument is omitted.
4199      */
4200     clearData(format?: string): void;
4201     /**
4202      * Returns the specified data. If there is no such data, returns the empty string.
4203      */
4204     getData(format: string): string;
4205     /**
4206      * Adds the specified data.
4207      */
4208     setData(format: string, data: string): void;
4209     /**
4210      * Uses the given element to update the drag feedback, replacing any previously specified feedback.
4211      */
4212     setDragImage(image: Element, x: number, y: number): void;
4213 }
4214
4215 declare var DataTransfer: {
4216     prototype: DataTransfer;
4217     new(): DataTransfer;
4218 };
4219
4220 /** 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. */
4221 interface DataTransferItem {
4222     /**
4223      * Returns the drag data item kind, one of: "string", "file".
4224      */
4225     readonly kind: string;
4226     /**
4227      * Returns the drag data item type string.
4228      */
4229     readonly type: string;
4230     /**
4231      * Returns a File object, if the drag data item kind is File.
4232      */
4233     getAsFile(): File | null;
4234     /**
4235      * Invokes the callback with the string data as the argument, if the drag data item kind is text.
4236      */
4237     getAsString(callback: FunctionStringCallback | null): void;
4238     webkitGetAsEntry(): any;
4239 }
4240
4241 declare var DataTransferItem: {
4242     prototype: DataTransferItem;
4243     new(): DataTransferItem;
4244 };
4245
4246 /** 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. */
4247 interface DataTransferItemList {
4248     /**
4249      * Returns the number of items in the drag data store.
4250      */
4251     readonly length: number;
4252     /**
4253      * 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.
4254      */
4255     add(data: string, type: string): DataTransferItem | null;
4256     add(data: File): DataTransferItem | null;
4257     /**
4258      * Removes all the entries in the drag data store.
4259      */
4260     clear(): void;
4261     item(index: number): DataTransferItem;
4262     /**
4263      * Removes the indexth entry in the drag data store.
4264      */
4265     remove(index: number): void;
4266     [name: number]: DataTransferItem;
4267 }
4268
4269 declare var DataTransferItemList: {
4270     prototype: DataTransferItemList;
4271     new(): DataTransferItemList;
4272 };
4273
4274 interface DeferredPermissionRequest {
4275     readonly id: number;
4276     readonly type: MSWebViewPermissionType;
4277     readonly uri: string;
4278     allow(): void;
4279     deny(): void;
4280 }
4281
4282 declare var DeferredPermissionRequest: {
4283     prototype: DeferredPermissionRequest;
4284     new(): DeferredPermissionRequest;
4285 };
4286
4287 /** 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. */
4288 interface DelayNode extends AudioNode {
4289     readonly delayTime: AudioParam;
4290 }
4291
4292 declare var DelayNode: {
4293     prototype: DelayNode;
4294     new(context: BaseAudioContext, options?: DelayOptions): DelayNode;
4295 };
4296
4297 /** Provides information about the amount of acceleration the device is experiencing along all three axes. */
4298 interface DeviceAcceleration {
4299     readonly x: number | null;
4300     readonly y: number | null;
4301     readonly z: number | null;
4302 }
4303
4304 declare var DeviceAcceleration: {
4305     prototype: DeviceAcceleration;
4306     new(): DeviceAcceleration;
4307 };
4308
4309 /** The DeviceLightEvent provides web developers with information from photo sensors or similiar detectors about ambient light levels near the device. For example this may be useful to adjust the screen's brightness based on the current ambient light level in order to save energy or provide better readability. */
4310 interface DeviceLightEvent extends Event {
4311     readonly value: number;
4312 }
4313
4314 declare var DeviceLightEvent: {
4315     prototype: DeviceLightEvent;
4316     new(typeArg: string, eventInitDict?: DeviceLightEventInit): DeviceLightEvent;
4317 };
4318
4319 /** The DeviceMotionEvent provides web developers with information about the speed of changes for the device's position and orientation. */
4320 interface DeviceMotionEvent extends Event {
4321     readonly acceleration: DeviceMotionEventAcceleration | null;
4322     readonly accelerationIncludingGravity: DeviceMotionEventAcceleration | null;
4323     readonly interval: number;
4324     readonly rotationRate: DeviceMotionEventRotationRate | null;
4325 }
4326
4327 declare var DeviceMotionEvent: {
4328     prototype: DeviceMotionEvent;
4329     new(type: string, eventInitDict?: DeviceMotionEventInit): DeviceMotionEvent;
4330     requestPermission(): Promise<PermissionState>;
4331 };
4332
4333 interface DeviceMotionEventAcceleration {
4334     readonly x: number | null;
4335     readonly y: number | null;
4336     readonly z: number | null;
4337 }
4338
4339 interface DeviceMotionEventRotationRate {
4340     readonly alpha: number | null;
4341     readonly beta: number | null;
4342     readonly gamma: number | null;
4343 }
4344
4345 /** The DeviceOrientationEvent provides web developers with information from the physical orientation of the device running the web page. */
4346 interface DeviceOrientationEvent extends Event {
4347     readonly absolute: boolean;
4348     readonly alpha: number | null;
4349     readonly beta: number | null;
4350     readonly gamma: number | null;
4351 }
4352
4353 declare var DeviceOrientationEvent: {
4354     prototype: DeviceOrientationEvent;
4355     new(type: string, eventInitDict?: DeviceOrientationEventInit): DeviceOrientationEvent;
4356     requestPermission(): Promise<PermissionState>;
4357 };
4358
4359 /** Provides information about the rate at which the device is rotating around all three axes. */
4360 interface DeviceRotationRate {
4361     readonly alpha: number | null;
4362     readonly beta: number | null;
4363     readonly gamma: number | null;
4364 }
4365
4366 declare var DeviceRotationRate: {
4367     prototype: DeviceRotationRate;
4368     new(): DeviceRotationRate;
4369 };
4370
4371 interface DhImportKeyParams extends Algorithm {
4372     generator: Uint8Array;
4373     prime: Uint8Array;
4374 }
4375
4376 interface DhKeyAlgorithm extends KeyAlgorithm {
4377     generator: Uint8Array;
4378     prime: Uint8Array;
4379 }
4380
4381 interface DhKeyDeriveParams extends Algorithm {
4382     public: CryptoKey;
4383 }
4384
4385 interface DhKeyGenParams extends Algorithm {
4386     generator: Uint8Array;
4387     prime: Uint8Array;
4388 }
4389
4390 interface DocumentEventMap extends GlobalEventHandlersEventMap, DocumentAndElementEventHandlersEventMap {
4391     "fullscreenchange": Event;
4392     "fullscreenerror": Event;
4393     "pointerlockchange": Event;
4394     "pointerlockerror": Event;
4395     "readystatechange": Event;
4396     "visibilitychange": Event;
4397 }
4398
4399 /** Any web page loaded in the browser and serves as an entry point into the web page's content, which is the DOM tree. */
4400 interface Document extends Node, DocumentAndElementEventHandlers, DocumentOrShadowRoot, GlobalEventHandlers, NonElementParentNode, ParentNode, XPathEvaluatorBase {
4401     /**
4402      * Sets or gets the URL for the current document.
4403      */
4404     readonly URL: string;
4405     /**
4406      * Sets or gets the color of all active links in the document.
4407      */
4408     /** @deprecated */
4409     alinkColor: string;
4410     /**
4411      * Returns a reference to the collection of elements contained by the object.
4412      */
4413     /** @deprecated */
4414     readonly all: HTMLAllCollection;
4415     /**
4416      * Retrieves a collection of all a objects that have a name and/or id property. Objects in this collection are in HTML source order.
4417      */
4418     /** @deprecated */
4419     readonly anchors: HTMLCollectionOf<HTMLAnchorElement>;
4420     /**
4421      * Retrieves a collection of all applet objects in the document.
4422      */
4423     /** @deprecated */
4424     readonly applets: HTMLCollectionOf<HTMLAppletElement>;
4425     /**
4426      * Deprecated. Sets or retrieves a value that indicates the background color behind the object.
4427      */
4428     /** @deprecated */
4429     bgColor: string;
4430     /**
4431      * Specifies the beginning and end of the document body.
4432      */
4433     body: HTMLElement;
4434     /**
4435      * Returns document's encoding.
4436      */
4437     readonly characterSet: string;
4438     /**
4439      * Gets or sets the character set used to encode the object.
4440      */
4441     readonly charset: string;
4442     /**
4443      * Gets a value that indicates whether standards-compliant mode is switched on for the object.
4444      */
4445     readonly compatMode: string;
4446     /**
4447      * Returns document's content type.
4448      */
4449     readonly contentType: string;
4450     /**
4451      * 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.
4452      *
4453      * Can be set, to add a new cookie to the element's set of HTTP cookies.
4454      *
4455      * 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.
4456      */
4457     cookie: string;
4458     /**
4459      * 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.
4460      *
4461      * 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.
4462      */
4463     readonly currentScript: HTMLOrSVGScriptElement | null;
4464     readonly defaultView: (WindowProxy & typeof globalThis) | null;
4465     /**
4466      * Sets or gets a value that indicates whether the document can be edited.
4467      */
4468     designMode: string;
4469     /**
4470      * Sets or retrieves a value that indicates the reading order of the object.
4471      */
4472     dir: string;
4473     /**
4474      * Gets an object representing the document type declaration associated with the current document.
4475      */
4476     readonly doctype: DocumentType | null;
4477     /**
4478      * Gets a reference to the root node of the document.
4479      */
4480     readonly documentElement: HTMLElement;
4481     /**
4482      * Returns document's URL.
4483      */
4484     readonly documentURI: string;
4485     /**
4486      * Sets or gets the security domain of the document.
4487      */
4488     domain: string;
4489     /**
4490      * Retrieves a collection of all embed objects in the document.
4491      */
4492     readonly embeds: HTMLCollectionOf<HTMLEmbedElement>;
4493     /**
4494      * Sets or gets the foreground (text) color of the document.
4495      */
4496     /** @deprecated */
4497     fgColor: string;
4498     /**
4499      * Retrieves a collection, in source order, of all form objects in the document.
4500      */
4501     readonly forms: HTMLCollectionOf<HTMLFormElement>;
4502     /** @deprecated */
4503     readonly fullscreen: boolean;
4504     /**
4505      * Returns true if document has the ability to display elements fullscreen and fullscreen is supported, or false otherwise.
4506      */
4507     readonly fullscreenEnabled: boolean;
4508     /**
4509      * Returns the head element.
4510      */
4511     readonly head: HTMLHeadElement;
4512     readonly hidden: boolean;
4513     /**
4514      * Retrieves a collection, in source order, of img objects in the document.
4515      */
4516     readonly images: HTMLCollectionOf<HTMLImageElement>;
4517     /**
4518      * Gets the implementation object of the current document.
4519      */
4520     readonly implementation: DOMImplementation;
4521     /**
4522      * Returns the character encoding used to create the webpage that is loaded into the document object.
4523      */
4524     readonly inputEncoding: string;
4525     /**
4526      * Gets the date that the page was last modified, if the page supplies one.
4527      */
4528     readonly lastModified: string;
4529     /**
4530      * Sets or gets the color of the document links.
4531      */
4532     /** @deprecated */
4533     linkColor: string;
4534     /**
4535      * Retrieves a collection of all a objects that specify the href property and all area objects in the document.
4536      */
4537     readonly links: HTMLCollectionOf<HTMLAnchorElement | HTMLAreaElement>;
4538     /**
4539      * Contains information about the current URL.
4540      */
4541     location: Location;
4542     onfullscreenchange: ((this: Document, ev: Event) => any) | null;
4543     onfullscreenerror: ((this: Document, ev: Event) => any) | null;
4544     onpointerlockchange: ((this: Document, ev: Event) => any) | null;
4545     onpointerlockerror: ((this: Document, ev: Event) => any) | null;
4546     /**
4547      * Fires when the state of the object has changed.
4548      * @param ev The event
4549      */
4550     onreadystatechange: ((this: Document, ev: Event) => any) | null;
4551     onvisibilitychange: ((this: Document, ev: Event) => any) | null;
4552     /**
4553      * Returns document's origin.
4554      */
4555     readonly origin: string;
4556     readonly ownerDocument: null;
4557     /**
4558      * Return an HTMLCollection of the embed elements in the Document.
4559      */
4560     readonly plugins: HTMLCollectionOf<HTMLEmbedElement>;
4561     /**
4562      * Retrieves a value that indicates the current state of the object.
4563      */
4564     readonly readyState: DocumentReadyState;
4565     /**
4566      * Gets the URL of the location that referred the user to the current page.
4567      */
4568     readonly referrer: string;
4569     /**
4570      * Retrieves a collection of all script objects in the document.
4571      */
4572     readonly scripts: HTMLCollectionOf<HTMLScriptElement>;
4573     readonly scrollingElement: Element | null;
4574     readonly timeline: DocumentTimeline;
4575     /**
4576      * Contains the title of the document.
4577      */
4578     title: string;
4579     readonly visibilityState: VisibilityState;
4580     /**
4581      * Sets or gets the color of the links that the user has visited.
4582      */
4583     /** @deprecated */
4584     vlinkColor: string;
4585     /**
4586      * Moves node from another document and returns it.
4587      *
4588      * If node is a document, throws a "NotSupportedError" DOMException or, if node is a shadow root, throws a "HierarchyRequestError" DOMException.
4589      */
4590     adoptNode<T extends Node>(source: T): T;
4591     /** @deprecated */
4592     captureEvents(): void;
4593     caretPositionFromPoint(x: number, y: number): CaretPosition | null;
4594     /** @deprecated */
4595     caretRangeFromPoint(x: number, y: number): Range;
4596     /** @deprecated */
4597     clear(): void;
4598     /**
4599      * Closes an output stream and forces the sent data to display.
4600      */
4601     close(): void;
4602     /**
4603      * Creates an attribute object with a specified name.
4604      * @param name String that sets the attribute object's name.
4605      */
4606     createAttribute(localName: string): Attr;
4607     createAttributeNS(namespace: string | null, qualifiedName: string): Attr;
4608     /**
4609      * Returns a CDATASection node whose data is data.
4610      */
4611     createCDATASection(data: string): CDATASection;
4612     /**
4613      * Creates a comment object with the specified data.
4614      * @param data Sets the comment object's data.
4615      */
4616     createComment(data: string): Comment;
4617     /**
4618      * Creates a new document.
4619      */
4620     createDocumentFragment(): DocumentFragment;
4621     /**
4622      * Creates an instance of the element for the specified tag.
4623      * @param tagName The name of an element.
4624      */
4625     createElement<K extends keyof HTMLElementTagNameMap>(tagName: K, options?: ElementCreationOptions): HTMLElementTagNameMap[K];
4626     /** @deprecated */
4627     createElement<K extends keyof HTMLElementDeprecatedTagNameMap>(tagName: K, options?: ElementCreationOptions): HTMLElementDeprecatedTagNameMap[K];
4628     createElement(tagName: string, options?: ElementCreationOptions): HTMLElement;
4629     /**
4630      * 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.
4631      *
4632      * If localName does not match the Name production an "InvalidCharacterError" DOMException will be thrown.
4633      *
4634      * If one of the following conditions is true a "NamespaceError" DOMException will be thrown:
4635      *
4636      * localName does not match the QName production.
4637      * Namespace prefix is not null and namespace is the empty string.
4638      * Namespace prefix is "xml" and namespace is not the XML namespace.
4639      * qualifiedName or namespace prefix is "xmlns" and namespace is not the XMLNS namespace.
4640      * namespace is the XMLNS namespace and neither qualifiedName nor namespace prefix is "xmlns".
4641      *
4642      * When supplied, options's is can be used to create a customized built-in element.
4643      */
4644     createElementNS(namespaceURI: "http://www.w3.org/1999/xhtml", qualifiedName: string): HTMLElement;
4645     createElementNS<K extends keyof SVGElementTagNameMap>(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: K): SVGElementTagNameMap[K];
4646     createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: string): SVGElement;
4647     createElementNS(namespaceURI: string | null, qualifiedName: string, options?: ElementCreationOptions): Element;
4648     createElementNS(namespace: string | null, qualifiedName: string, options?: string | ElementCreationOptions): Element;
4649     createEvent(eventInterface: "AnimationEvent"): AnimationEvent;
4650     createEvent(eventInterface: "AnimationPlaybackEvent"): AnimationPlaybackEvent;
4651     createEvent(eventInterface: "AudioProcessingEvent"): AudioProcessingEvent;
4652     createEvent(eventInterface: "BeforeUnloadEvent"): BeforeUnloadEvent;
4653     createEvent(eventInterface: "ClipboardEvent"): ClipboardEvent;
4654     createEvent(eventInterface: "CloseEvent"): CloseEvent;
4655     createEvent(eventInterface: "CompositionEvent"): CompositionEvent;
4656     createEvent(eventInterface: "CustomEvent"): CustomEvent;
4657     createEvent(eventInterface: "DeviceLightEvent"): DeviceLightEvent;
4658     createEvent(eventInterface: "DeviceMotionEvent"): DeviceMotionEvent;
4659     createEvent(eventInterface: "DeviceOrientationEvent"): DeviceOrientationEvent;
4660     createEvent(eventInterface: "DragEvent"): DragEvent;
4661     createEvent(eventInterface: "ErrorEvent"): ErrorEvent;
4662     createEvent(eventInterface: "Event"): Event;
4663     createEvent(eventInterface: "Events"): Event;
4664     createEvent(eventInterface: "FocusEvent"): FocusEvent;
4665     createEvent(eventInterface: "FocusNavigationEvent"): FocusNavigationEvent;
4666     createEvent(eventInterface: "GamepadEvent"): GamepadEvent;
4667     createEvent(eventInterface: "HashChangeEvent"): HashChangeEvent;
4668     createEvent(eventInterface: "IDBVersionChangeEvent"): IDBVersionChangeEvent;
4669     createEvent(eventInterface: "InputEvent"): InputEvent;
4670     createEvent(eventInterface: "KeyboardEvent"): KeyboardEvent;
4671     createEvent(eventInterface: "ListeningStateChangedEvent"): ListeningStateChangedEvent;
4672     createEvent(eventInterface: "MSGestureEvent"): MSGestureEvent;
4673     createEvent(eventInterface: "MSMediaKeyMessageEvent"): MSMediaKeyMessageEvent;
4674     createEvent(eventInterface: "MSMediaKeyNeededEvent"): MSMediaKeyNeededEvent;
4675     createEvent(eventInterface: "MSPointerEvent"): MSPointerEvent;
4676     createEvent(eventInterface: "MediaEncryptedEvent"): MediaEncryptedEvent;
4677     createEvent(eventInterface: "MediaKeyMessageEvent"): MediaKeyMessageEvent;
4678     createEvent(eventInterface: "MediaQueryListEvent"): MediaQueryListEvent;
4679     createEvent(eventInterface: "MediaStreamErrorEvent"): MediaStreamErrorEvent;
4680     createEvent(eventInterface: "MediaStreamEvent"): MediaStreamEvent;
4681     createEvent(eventInterface: "MediaStreamTrackEvent"): MediaStreamTrackEvent;
4682     createEvent(eventInterface: "MessageEvent"): MessageEvent;
4683     createEvent(eventInterface: "MouseEvent"): MouseEvent;
4684     createEvent(eventInterface: "MouseEvents"): MouseEvent;
4685     createEvent(eventInterface: "MutationEvent"): MutationEvent;
4686     createEvent(eventInterface: "MutationEvents"): MutationEvent;
4687     createEvent(eventInterface: "OfflineAudioCompletionEvent"): OfflineAudioCompletionEvent;
4688     createEvent(eventInterface: "OverflowEvent"): OverflowEvent;
4689     createEvent(eventInterface: "PageTransitionEvent"): PageTransitionEvent;
4690     createEvent(eventInterface: "PaymentRequestUpdateEvent"): PaymentRequestUpdateEvent;
4691     createEvent(eventInterface: "PermissionRequestedEvent"): PermissionRequestedEvent;
4692     createEvent(eventInterface: "PointerEvent"): PointerEvent;
4693     createEvent(eventInterface: "PopStateEvent"): PopStateEvent;
4694     createEvent(eventInterface: "ProgressEvent"): ProgressEvent;
4695     createEvent(eventInterface: "PromiseRejectionEvent"): PromiseRejectionEvent;
4696     createEvent(eventInterface: "RTCDTMFToneChangeEvent"): RTCDTMFToneChangeEvent;
4697     createEvent(eventInterface: "RTCDataChannelEvent"): RTCDataChannelEvent;
4698     createEvent(eventInterface: "RTCDtlsTransportStateChangedEvent"): RTCDtlsTransportStateChangedEvent;
4699     createEvent(eventInterface: "RTCErrorEvent"): RTCErrorEvent;
4700     createEvent(eventInterface: "RTCIceCandidatePairChangedEvent"): RTCIceCandidatePairChangedEvent;
4701     createEvent(eventInterface: "RTCIceGathererEvent"): RTCIceGathererEvent;
4702     createEvent(eventInterface: "RTCIceTransportStateChangedEvent"): RTCIceTransportStateChangedEvent;
4703     createEvent(eventInterface: "RTCPeerConnectionIceErrorEvent"): RTCPeerConnectionIceErrorEvent;
4704     createEvent(eventInterface: "RTCPeerConnectionIceEvent"): RTCPeerConnectionIceEvent;
4705     createEvent(eventInterface: "RTCSsrcConflictEvent"): RTCSsrcConflictEvent;
4706     createEvent(eventInterface: "RTCStatsEvent"): RTCStatsEvent;
4707     createEvent(eventInterface: "RTCTrackEvent"): RTCTrackEvent;
4708     createEvent(eventInterface: "SVGZoomEvent"): SVGZoomEvent;
4709     createEvent(eventInterface: "SVGZoomEvents"): SVGZoomEvent;
4710     createEvent(eventInterface: "SecurityPolicyViolationEvent"): SecurityPolicyViolationEvent;
4711     createEvent(eventInterface: "ServiceWorkerMessageEvent"): ServiceWorkerMessageEvent;
4712     createEvent(eventInterface: "SpeechRecognitionEvent"): SpeechRecognitionEvent;
4713     createEvent(eventInterface: "SpeechSynthesisErrorEvent"): SpeechSynthesisErrorEvent;
4714     createEvent(eventInterface: "SpeechSynthesisEvent"): SpeechSynthesisEvent;
4715     createEvent(eventInterface: "StorageEvent"): StorageEvent;
4716     createEvent(eventInterface: "TextEvent"): TextEvent;
4717     createEvent(eventInterface: "TouchEvent"): TouchEvent;
4718     createEvent(eventInterface: "TrackEvent"): TrackEvent;
4719     createEvent(eventInterface: "TransitionEvent"): TransitionEvent;
4720     createEvent(eventInterface: "UIEvent"): UIEvent;
4721     createEvent(eventInterface: "UIEvents"): UIEvent;
4722     createEvent(eventInterface: "VRDisplayEvent"): VRDisplayEvent;
4723     createEvent(eventInterface: "VRDisplayEvent "): VRDisplayEvent ;
4724     createEvent(eventInterface: "WebGLContextEvent"): WebGLContextEvent;
4725     createEvent(eventInterface: "WheelEvent"): WheelEvent;
4726     createEvent(eventInterface: string): Event;
4727     /**
4728      * Creates a NodeIterator object that you can use to traverse filtered lists of nodes or elements in a document.
4729      * @param root The root element or node to start traversing on.
4730      * @param whatToShow The type of nodes or elements to appear in the node list
4731      * @param filter A custom NodeFilter function to use. For more information, see filter. Use null for no filter.
4732      * @param entityReferenceExpansion A flag that specifies whether entity reference nodes are expanded.
4733      */
4734     createNodeIterator(root: Node, whatToShow?: number, filter?: NodeFilter | null): NodeIterator;
4735     /**
4736      * 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.
4737      */
4738     createProcessingInstruction(target: string, data: string): ProcessingInstruction;
4739     /**
4740      *  Returns an empty range object that has both of its boundary points positioned at the beginning of the document.
4741      */
4742     createRange(): Range;
4743     /**
4744      * Creates a text string from the specified value.
4745      * @param data String that specifies the nodeValue property of the text node.
4746      */
4747     createTextNode(data: string): Text;
4748     /**
4749      * Creates a TreeWalker object that you can use to traverse filtered lists of nodes or elements in a document.
4750      * @param root The root element or node to start traversing on.
4751      * @param whatToShow The type of nodes or elements to appear in the node list. For more information, see whatToShow.
4752      * @param filter A custom NodeFilter function to use.
4753      * @param entityReferenceExpansion A flag that specifies whether entity reference nodes are expanded.
4754      */
4755     createTreeWalker(root: Node, whatToShow?: number, filter?: NodeFilter | null): TreeWalker;
4756     /** @deprecated */
4757     createTreeWalker(root: Node, whatToShow: number, filter: NodeFilter | null, entityReferenceExpansion?: boolean): TreeWalker;
4758     /**
4759      * Returns the element for the specified x coordinate and the specified y coordinate.
4760      * @param x The x-offset
4761      * @param y The y-offset
4762      */
4763     elementFromPoint(x: number, y: number): Element | null;
4764     elementsFromPoint(x: number, y: number): Element[];
4765     /**
4766      * Executes a command on the current document, current selection, or the given range.
4767      * @param commandId String that specifies the command to execute. This command can be any of the command identifiers that can be executed in script.
4768      * @param showUI Display the user interface, defaults to false.
4769      * @param value Value to assign.
4770      */
4771     execCommand(commandId: string, showUI?: boolean, value?: string): boolean;
4772     /**
4773      * Stops document's fullscreen element from being displayed fullscreen and resolves promise when done.
4774      */
4775     exitFullscreen(): Promise<void>;
4776     exitPointerLock(): void;
4777     getAnimations(): Animation[];
4778     /**
4779      * Returns a reference to the first object with the specified value of the ID or NAME attribute.
4780      * @param elementId String that specifies the ID value. Case-insensitive.
4781      */
4782     getElementById(elementId: string): HTMLElement | null;
4783     /**
4784      * 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.
4785      */
4786     getElementsByClassName(classNames: string): HTMLCollectionOf<Element>;
4787     /**
4788      * Gets a collection of objects based on the value of the NAME or ID attribute.
4789      * @param elementName Gets a collection of objects based on the value of the NAME or ID attribute.
4790      */
4791     getElementsByName(elementName: string): NodeListOf<HTMLElement>;
4792     /**
4793      * Retrieves a collection of objects based on the specified element name.
4794      * @param name Specifies the name of an element.
4795      */
4796     getElementsByTagName<K extends keyof HTMLElementTagNameMap>(qualifiedName: K): HTMLCollectionOf<HTMLElementTagNameMap[K]>;
4797     getElementsByTagName<K extends keyof SVGElementTagNameMap>(qualifiedName: K): HTMLCollectionOf<SVGElementTagNameMap[K]>;
4798     getElementsByTagName(qualifiedName: string): HTMLCollectionOf<Element>;
4799     /**
4800      * If namespace and localName are "*" returns a HTMLCollection of all descendant elements.
4801      *
4802      * If only namespace is "*" returns a HTMLCollection of all descendant elements whose local name is localName.
4803      *
4804      * If only localName is "*" returns a HTMLCollection of all descendant elements whose namespace is namespace.
4805      *
4806      * Otherwise, returns a HTMLCollection of all descendant elements whose namespace is namespace and local name is localName.
4807      */
4808     getElementsByTagNameNS(namespaceURI: "http://www.w3.org/1999/xhtml", localName: string): HTMLCollectionOf<HTMLElement>;
4809     getElementsByTagNameNS(namespaceURI: "http://www.w3.org/2000/svg", localName: string): HTMLCollectionOf<SVGElement>;
4810     getElementsByTagNameNS(namespaceURI: string, localName: string): HTMLCollectionOf<Element>;
4811     /**
4812      * Returns an object representing the current selection of the document that is loaded into the object displaying a webpage.
4813      */
4814     getSelection(): Selection | null;
4815     /**
4816      * Gets a value indicating whether the object currently has focus.
4817      */
4818     hasFocus(): boolean;
4819     /**
4820      * Returns a copy of node. If deep is true, the copy also includes the node's descendants.
4821      *
4822      * If node is a document or a shadow root, throws a "NotSupportedError" DOMException.
4823      */
4824     importNode<T extends Node>(importedNode: T, deep: boolean): T;
4825     /**
4826      * 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.
4827      * @param url Specifies a MIME type for the document.
4828      * @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.
4829      * @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.
4830      * @param replace Specifies whether the existing entry for the document is replaced in the history list.
4831      */
4832     open(url?: string, name?: string, features?: string, replace?: boolean): Document;
4833     /**
4834      * Returns a Boolean value that indicates whether a specified command can be successfully executed using execCommand, given the current state of the document.
4835      * @param commandId Specifies a command identifier.
4836      */
4837     queryCommandEnabled(commandId: string): boolean;
4838     /**
4839      * Returns a Boolean value that indicates whether the specified command is in the indeterminate state.
4840      * @param commandId String that specifies a command identifier.
4841      */
4842     queryCommandIndeterm(commandId: string): boolean;
4843     /**
4844      * Returns a Boolean value that indicates the current state of the command.
4845      * @param commandId String that specifies a command identifier.
4846      */
4847     queryCommandState(commandId: string): boolean;
4848     /**
4849      * Returns a Boolean value that indicates whether the current command is supported on the current range.
4850      * @param commandId Specifies a command identifier.
4851      */
4852     queryCommandSupported(commandId: string): boolean;
4853     /**
4854      * Returns the current value of the document, range, or current selection for the given command.
4855      * @param commandId String that specifies a command identifier.
4856      */
4857     queryCommandValue(commandId: string): string;
4858     /** @deprecated */
4859     releaseEvents(): void;
4860     /**
4861      * Writes one or more HTML expressions to a document in the specified window.
4862      * @param content Specifies the text and HTML tags to write.
4863      */
4864     write(...text: string[]): void;
4865     /**
4866      * Writes one or more HTML expressions, followed by a carriage return, to a document in the specified window.
4867      * @param content The text and HTML tags to write.
4868      */
4869     writeln(...text: string[]): void;
4870     addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
4871     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
4872     removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
4873     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
4874 }
4875
4876 declare var Document: {
4877     prototype: Document;
4878     new(): Document;
4879 };
4880
4881 interface DocumentAndElementEventHandlersEventMap {
4882     "copy": ClipboardEvent;
4883     "cut": ClipboardEvent;
4884     "paste": ClipboardEvent;
4885 }
4886
4887 interface DocumentAndElementEventHandlers {
4888     oncopy: ((this: DocumentAndElementEventHandlers, ev: ClipboardEvent) => any) | null;
4889     oncut: ((this: DocumentAndElementEventHandlers, ev: ClipboardEvent) => any) | null;
4890     onpaste: ((this: DocumentAndElementEventHandlers, ev: ClipboardEvent) => any) | null;
4891     addEventListener<K extends keyof DocumentAndElementEventHandlersEventMap>(type: K, listener: (this: DocumentAndElementEventHandlers, ev: DocumentAndElementEventHandlersEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
4892     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
4893     removeEventListener<K extends keyof DocumentAndElementEventHandlersEventMap>(type: K, listener: (this: DocumentAndElementEventHandlers, ev: DocumentAndElementEventHandlersEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
4894     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
4895 }
4896
4897 interface DocumentEvent {
4898     createEvent(eventInterface: "AnimationEvent"): AnimationEvent;
4899     createEvent(eventInterface: "AnimationPlaybackEvent"): AnimationPlaybackEvent;
4900     createEvent(eventInterface: "AudioProcessingEvent"): AudioProcessingEvent;
4901     createEvent(eventInterface: "BeforeUnloadEvent"): BeforeUnloadEvent;
4902     createEvent(eventInterface: "ClipboardEvent"): ClipboardEvent;
4903     createEvent(eventInterface: "CloseEvent"): CloseEvent;
4904     createEvent(eventInterface: "CompositionEvent"): CompositionEvent;
4905     createEvent(eventInterface: "CustomEvent"): CustomEvent;
4906     createEvent(eventInterface: "DeviceLightEvent"): DeviceLightEvent;
4907     createEvent(eventInterface: "DeviceMotionEvent"): DeviceMotionEvent;
4908     createEvent(eventInterface: "DeviceOrientationEvent"): DeviceOrientationEvent;
4909     createEvent(eventInterface: "DragEvent"): DragEvent;
4910     createEvent(eventInterface: "ErrorEvent"): ErrorEvent;
4911     createEvent(eventInterface: "Event"): Event;
4912     createEvent(eventInterface: "Events"): Event;
4913     createEvent(eventInterface: "FocusEvent"): FocusEvent;
4914     createEvent(eventInterface: "FocusNavigationEvent"): FocusNavigationEvent;
4915     createEvent(eventInterface: "GamepadEvent"): GamepadEvent;
4916     createEvent(eventInterface: "HashChangeEvent"): HashChangeEvent;
4917     createEvent(eventInterface: "IDBVersionChangeEvent"): IDBVersionChangeEvent;
4918     createEvent(eventInterface: "InputEvent"): InputEvent;
4919     createEvent(eventInterface: "KeyboardEvent"): KeyboardEvent;
4920     createEvent(eventInterface: "ListeningStateChangedEvent"): ListeningStateChangedEvent;
4921     createEvent(eventInterface: "MSGestureEvent"): MSGestureEvent;
4922     createEvent(eventInterface: "MSMediaKeyMessageEvent"): MSMediaKeyMessageEvent;
4923     createEvent(eventInterface: "MSMediaKeyNeededEvent"): MSMediaKeyNeededEvent;
4924     createEvent(eventInterface: "MSPointerEvent"): MSPointerEvent;
4925     createEvent(eventInterface: "MediaEncryptedEvent"): MediaEncryptedEvent;
4926     createEvent(eventInterface: "MediaKeyMessageEvent"): MediaKeyMessageEvent;
4927     createEvent(eventInterface: "MediaQueryListEvent"): MediaQueryListEvent;
4928     createEvent(eventInterface: "MediaStreamErrorEvent"): MediaStreamErrorEvent;
4929     createEvent(eventInterface: "MediaStreamEvent"): MediaStreamEvent;
4930     createEvent(eventInterface: "MediaStreamTrackEvent"): MediaStreamTrackEvent;
4931     createEvent(eventInterface: "MessageEvent"): MessageEvent;
4932     createEvent(eventInterface: "MouseEvent"): MouseEvent;
4933     createEvent(eventInterface: "MouseEvents"): MouseEvent;
4934     createEvent(eventInterface: "MutationEvent"): MutationEvent;
4935     createEvent(eventInterface: "MutationEvents"): MutationEvent;
4936     createEvent(eventInterface: "OfflineAudioCompletionEvent"): OfflineAudioCompletionEvent;
4937     createEvent(eventInterface: "OverflowEvent"): OverflowEvent;
4938     createEvent(eventInterface: "PageTransitionEvent"): PageTransitionEvent;
4939     createEvent(eventInterface: "PaymentRequestUpdateEvent"): PaymentRequestUpdateEvent;
4940     createEvent(eventInterface: "PermissionRequestedEvent"): PermissionRequestedEvent;
4941     createEvent(eventInterface: "PointerEvent"): PointerEvent;
4942     createEvent(eventInterface: "PopStateEvent"): PopStateEvent;
4943     createEvent(eventInterface: "ProgressEvent"): ProgressEvent;
4944     createEvent(eventInterface: "PromiseRejectionEvent"): PromiseRejectionEvent;
4945     createEvent(eventInterface: "RTCDTMFToneChangeEvent"): RTCDTMFToneChangeEvent;
4946     createEvent(eventInterface: "RTCDataChannelEvent"): RTCDataChannelEvent;
4947     createEvent(eventInterface: "RTCDtlsTransportStateChangedEvent"): RTCDtlsTransportStateChangedEvent;
4948     createEvent(eventInterface: "RTCErrorEvent"): RTCErrorEvent;
4949     createEvent(eventInterface: "RTCIceCandidatePairChangedEvent"): RTCIceCandidatePairChangedEvent;
4950     createEvent(eventInterface: "RTCIceGathererEvent"): RTCIceGathererEvent;
4951     createEvent(eventInterface: "RTCIceTransportStateChangedEvent"): RTCIceTransportStateChangedEvent;
4952     createEvent(eventInterface: "RTCPeerConnectionIceErrorEvent"): RTCPeerConnectionIceErrorEvent;
4953     createEvent(eventInterface: "RTCPeerConnectionIceEvent"): RTCPeerConnectionIceEvent;
4954     createEvent(eventInterface: "RTCSsrcConflictEvent"): RTCSsrcConflictEvent;
4955     createEvent(eventInterface: "RTCStatsEvent"): RTCStatsEvent;
4956     createEvent(eventInterface: "RTCTrackEvent"): RTCTrackEvent;
4957     createEvent(eventInterface: "SVGZoomEvent"): SVGZoomEvent;
4958     createEvent(eventInterface: "SVGZoomEvents"): SVGZoomEvent;
4959     createEvent(eventInterface: "SecurityPolicyViolationEvent"): SecurityPolicyViolationEvent;
4960     createEvent(eventInterface: "ServiceWorkerMessageEvent"): ServiceWorkerMessageEvent;
4961     createEvent(eventInterface: "SpeechRecognitionEvent"): SpeechRecognitionEvent;
4962     createEvent(eventInterface: "SpeechSynthesisErrorEvent"): SpeechSynthesisErrorEvent;
4963     createEvent(eventInterface: "SpeechSynthesisEvent"): SpeechSynthesisEvent;
4964     createEvent(eventInterface: "StorageEvent"): StorageEvent;
4965     createEvent(eventInterface: "TextEvent"): TextEvent;
4966     createEvent(eventInterface: "TouchEvent"): TouchEvent;
4967     createEvent(eventInterface: "TrackEvent"): TrackEvent;
4968     createEvent(eventInterface: "TransitionEvent"): TransitionEvent;
4969     createEvent(eventInterface: "UIEvent"): UIEvent;
4970     createEvent(eventInterface: "UIEvents"): UIEvent;
4971     createEvent(eventInterface: "VRDisplayEvent"): VRDisplayEvent;
4972     createEvent(eventInterface: "VRDisplayEvent "): VRDisplayEvent ;
4973     createEvent(eventInterface: "WebGLContextEvent"): WebGLContextEvent;
4974     createEvent(eventInterface: "WheelEvent"): WheelEvent;
4975     createEvent(eventInterface: string): Event;
4976 }
4977
4978 /** 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. */
4979 interface DocumentFragment extends Node, NonElementParentNode, ParentNode {
4980     readonly ownerDocument: Document;
4981     getElementById(elementId: string): HTMLElement | null;
4982 }
4983
4984 declare var DocumentFragment: {
4985     prototype: DocumentFragment;
4986     new(): DocumentFragment;
4987 };
4988
4989 interface DocumentOrShadowRoot {
4990     readonly activeElement: Element | null;
4991     /**
4992      * Returns document's fullscreen element.
4993      */
4994     readonly fullscreenElement: Element | null;
4995     readonly pointerLockElement: Element | null;
4996     /**
4997      * Retrieves a collection of styleSheet objects representing the style sheets that correspond to each instance of a link or style object in the document.
4998      */
4999     readonly styleSheets: StyleSheetList;
5000     caretPositionFromPoint(x: number, y: number): CaretPosition | null;
5001     /** @deprecated */
5002     caretRangeFromPoint(x: number, y: number): Range;
5003     elementFromPoint(x: number, y: number): Element | null;
5004     elementsFromPoint(x: number, y: number): Element[];
5005     getSelection(): Selection | null;
5006 }
5007
5008 interface DocumentTimeline extends AnimationTimeline {
5009 }
5010
5011 declare var DocumentTimeline: {
5012     prototype: DocumentTimeline;
5013     new(options?: DocumentTimelineOptions): DocumentTimeline;
5014 };
5015
5016 /** A Node containing a doctype. */
5017 interface DocumentType extends Node, ChildNode {
5018     readonly name: string;
5019     readonly ownerDocument: Document;
5020     readonly publicId: string;
5021     readonly systemId: string;
5022 }
5023
5024 declare var DocumentType: {
5025     prototype: DocumentType;
5026     new(): DocumentType;
5027 };
5028
5029 /** 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. */
5030 interface DragEvent extends MouseEvent {
5031     /**
5032      * Returns the DataTransfer object for the event.
5033      */
5034     readonly dataTransfer: DataTransfer | null;
5035 }
5036
5037 declare var DragEvent: {
5038     prototype: DragEvent;
5039     new(type: string, eventInitDict?: DragEventInit): DragEvent;
5040 };
5041
5042 /** Inherits properties from its parent, AudioNode. */
5043 interface DynamicsCompressorNode extends AudioNode {
5044     readonly attack: AudioParam;
5045     readonly knee: AudioParam;
5046     readonly ratio: AudioParam;
5047     readonly reduction: number;
5048     readonly release: AudioParam;
5049     readonly threshold: AudioParam;
5050 }
5051
5052 declare var DynamicsCompressorNode: {
5053     prototype: DynamicsCompressorNode;
5054     new(context: BaseAudioContext, options?: DynamicsCompressorOptions): DynamicsCompressorNode;
5055 };
5056
5057 interface EXT_blend_minmax {
5058     readonly MAX_EXT: GLenum;
5059     readonly MIN_EXT: GLenum;
5060 }
5061
5062 /** 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. */
5063 interface EXT_frag_depth {
5064 }
5065
5066 interface EXT_sRGB {
5067     readonly FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT: GLenum;
5068     readonly SRGB8_ALPHA8_EXT: GLenum;
5069     readonly SRGB_ALPHA_EXT: GLenum;
5070     readonly SRGB_EXT: GLenum;
5071 }
5072
5073 interface EXT_shader_texture_lod {
5074 }
5075
5076 /** The EXT_texture_filter_anisotropic extension is part of the WebGL API and exposes two constants for anisotropic filtering (AF). */
5077 interface EXT_texture_filter_anisotropic {
5078     readonly MAX_TEXTURE_MAX_ANISOTROPY_EXT: GLenum;
5079     readonly TEXTURE_MAX_ANISOTROPY_EXT: GLenum;
5080 }
5081
5082 interface ElementEventMap {
5083     "fullscreenchange": Event;
5084     "fullscreenerror": Event;
5085 }
5086
5087 /** 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. */
5088 interface Element extends Node, Animatable, ChildNode, InnerHTML, NonDocumentTypeChildNode, ParentNode, Slotable {
5089     readonly assignedSlot: HTMLSlotElement | null;
5090     readonly attributes: NamedNodeMap;
5091     /**
5092      * Allows for manipulation of element's class content attribute as a set of whitespace-separated tokens through a DOMTokenList object.
5093      */
5094     readonly classList: DOMTokenList;
5095     /**
5096      * Returns the value of element's class content attribute. Can be set to change it.
5097      */
5098     className: string;
5099     readonly clientHeight: number;
5100     readonly clientLeft: number;
5101     readonly clientTop: number;
5102     readonly clientWidth: number;
5103     /**
5104      * Returns the value of element's id content attribute. Can be set to change it.
5105      */
5106     id: string;
5107     /**
5108      * Returns the local name.
5109      */
5110     readonly localName: string;
5111     /**
5112      * Returns the namespace.
5113      */
5114     readonly namespaceURI: string | null;
5115     onfullscreenchange: ((this: Element, ev: Event) => any) | null;
5116     onfullscreenerror: ((this: Element, ev: Event) => any) | null;
5117     outerHTML: string;
5118     readonly ownerDocument: Document;
5119     /**
5120      * Returns the namespace prefix.
5121      */
5122     readonly prefix: string | null;
5123     readonly scrollHeight: number;
5124     scrollLeft: number;
5125     scrollTop: number;
5126     readonly scrollWidth: number;
5127     /**
5128      * Returns element's shadow root, if any, and if shadow root's mode is "open", and null otherwise.
5129      */
5130     readonly shadowRoot: ShadowRoot | null;
5131     /**
5132      * Returns the value of element's slot content attribute. Can be set to change it.
5133      */
5134     slot: string;
5135     /**
5136      * Returns the HTML-uppercased qualified name.
5137      */
5138     readonly tagName: string;
5139     /**
5140      * Creates a shadow root for element and returns it.
5141      */
5142     attachShadow(init: ShadowRootInit): ShadowRoot;
5143     /**
5144      * Returns the first (starting at element) inclusive ancestor that matches selectors, and null otherwise.
5145      */
5146     closest<K extends keyof HTMLElementTagNameMap>(selector: K): HTMLElementTagNameMap[K] | null;
5147     closest<K extends keyof SVGElementTagNameMap>(selector: K): SVGElementTagNameMap[K] | null;
5148     closest<E extends Element = Element>(selector: string): E | null;
5149     /**
5150      * Returns element's first attribute whose qualified name is qualifiedName, and null if there is no such attribute otherwise.
5151      */
5152     getAttribute(qualifiedName: string): string | null;
5153     /**
5154      * Returns element's attribute whose namespace is namespace and local name is localName, and null if there is no such attribute otherwise.
5155      */
5156     getAttributeNS(namespace: string | null, localName: string): string | null;
5157     /**
5158      * Returns the qualified names of all element's attributes. Can contain duplicates.
5159      */
5160     getAttributeNames(): string[];
5161     getAttributeNode(name: string): Attr | null;
5162     getAttributeNodeNS(namespaceURI: string, localName: string): Attr | null;
5163     getBoundingClientRect(): DOMRect;
5164     getClientRects(): DOMRectList;
5165     /**
5166      * 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.
5167      */
5168     getElementsByClassName(classNames: string): HTMLCollectionOf<Element>;
5169     getElementsByTagName<K extends keyof HTMLElementTagNameMap>(qualifiedName: K): HTMLCollectionOf<HTMLElementTagNameMap[K]>;
5170     getElementsByTagName<K extends keyof SVGElementTagNameMap>(qualifiedName: K): HTMLCollectionOf<SVGElementTagNameMap[K]>;
5171     getElementsByTagName(qualifiedName: string): HTMLCollectionOf<Element>;
5172     getElementsByTagNameNS(namespaceURI: "http://www.w3.org/1999/xhtml", localName: string): HTMLCollectionOf<HTMLElement>;
5173     getElementsByTagNameNS(namespaceURI: "http://www.w3.org/2000/svg", localName: string): HTMLCollectionOf<SVGElement>;
5174     getElementsByTagNameNS(namespaceURI: string, localName: string): HTMLCollectionOf<Element>;
5175     /**
5176      * Returns true if element has an attribute whose qualified name is qualifiedName, and false otherwise.
5177      */
5178     hasAttribute(qualifiedName: string): boolean;
5179     /**
5180      * Returns true if element has an attribute whose namespace is namespace and local name is localName.
5181      */
5182     hasAttributeNS(namespace: string | null, localName: string): boolean;
5183     /**
5184      * Returns true if element has attributes, and false otherwise.
5185      */
5186     hasAttributes(): boolean;
5187     hasPointerCapture(pointerId: number): boolean;
5188     insertAdjacentElement(position: InsertPosition, insertedElement: Element): Element | null;
5189     insertAdjacentHTML(where: InsertPosition, html: string): void;
5190     insertAdjacentText(where: InsertPosition, text: string): void;
5191     /**
5192      * Returns true if matching selectors against element's root yields element, and false otherwise.
5193      */
5194     matches(selectors: string): boolean;
5195     msGetRegionContent(): any;
5196     releasePointerCapture(pointerId: number): void;
5197     /**
5198      * Removes element's first attribute whose qualified name is qualifiedName.
5199      */
5200     removeAttribute(qualifiedName: string): void;
5201     /**
5202      * Removes element's attribute whose namespace is namespace and local name is localName.
5203      */
5204     removeAttributeNS(namespace: string | null, localName: string): void;
5205     removeAttributeNode(attr: Attr): Attr;
5206     /**
5207      * Displays element fullscreen and resolves promise when done.
5208      *
5209      * 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.
5210      */
5211     requestFullscreen(options?: FullscreenOptions): Promise<void>;
5212     requestPointerLock(): void;
5213     scroll(options?: ScrollToOptions): void;
5214     scroll(x: number, y: number): void;
5215     scrollBy(options?: ScrollToOptions): void;
5216     scrollBy(x: number, y: number): void;
5217     scrollIntoView(arg?: boolean | ScrollIntoViewOptions): void;
5218     scrollTo(options?: ScrollToOptions): void;
5219     scrollTo(x: number, y: number): void;
5220     /**
5221      * Sets the value of element's first attribute whose qualified name is qualifiedName to value.
5222      */
5223     setAttribute(qualifiedName: string, value: string): void;
5224     /**
5225      * Sets the value of element's attribute whose namespace is namespace and local name is localName to value.
5226      */
5227     setAttributeNS(namespace: string | null, qualifiedName: string, value: string): void;
5228     setAttributeNode(attr: Attr): Attr | null;
5229     setAttributeNodeNS(attr: Attr): Attr | null;
5230     setPointerCapture(pointerId: number): void;
5231     /**
5232      * 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.
5233      *
5234      * Returns true if qualifiedName is now present, and false otherwise.
5235      */
5236     toggleAttribute(qualifiedName: string, force?: boolean): boolean;
5237     webkitMatchesSelector(selectors: string): boolean;
5238     addEventListener<K extends keyof ElementEventMap>(type: K, listener: (this: Element, ev: ElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
5239     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
5240     removeEventListener<K extends keyof ElementEventMap>(type: K, listener: (this: Element, ev: ElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
5241     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
5242 }
5243
5244 declare var Element: {
5245     prototype: Element;
5246     new(): Element;
5247 };
5248
5249 interface ElementCSSInlineStyle {
5250     readonly style: CSSStyleDeclaration;
5251 }
5252
5253 interface ElementContentEditable {
5254     contentEditable: string;
5255     inputMode: string;
5256     readonly isContentEditable: boolean;
5257 }
5258
5259 /** Events providing information related to errors in scripts or in files. */
5260 interface ErrorEvent extends Event {
5261     readonly colno: number;
5262     readonly error: any;
5263     readonly filename: string;
5264     readonly lineno: number;
5265     readonly message: string;
5266 }
5267
5268 declare var ErrorEvent: {
5269     prototype: ErrorEvent;
5270     new(type: string, eventInitDict?: ErrorEventInit): ErrorEvent;
5271 };
5272
5273 /** An event which takes place in the DOM. */
5274 interface Event {
5275     /**
5276      * 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.
5277      */
5278     readonly bubbles: boolean;
5279     cancelBubble: boolean;
5280     /**
5281      * 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.
5282      */
5283     readonly cancelable: boolean;
5284     /**
5285      * 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.
5286      */
5287     readonly composed: boolean;
5288     /**
5289      * Returns the object whose event listener's callback is currently being invoked.
5290      */
5291     readonly currentTarget: EventTarget | null;
5292     /**
5293      * Returns true if preventDefault() was invoked successfully to indicate cancelation, and false otherwise.
5294      */
5295     readonly defaultPrevented: boolean;
5296     /**
5297      * Returns the event's phase, which is one of NONE, CAPTURING_PHASE, AT_TARGET, and BUBBLING_PHASE.
5298      */
5299     readonly eventPhase: number;
5300     /**
5301      * Returns true if event was dispatched by the user agent, and false otherwise.
5302      */
5303     readonly isTrusted: boolean;
5304     returnValue: boolean;
5305     /** @deprecated */
5306     readonly srcElement: EventTarget | null;
5307     /**
5308      * Returns the object to which event is dispatched (its target).
5309      */
5310     readonly target: EventTarget | null;
5311     /**
5312      * Returns the event's timestamp as the number of milliseconds measured relative to the time origin.
5313      */
5314     readonly timeStamp: number;
5315     /**
5316      * Returns the type of event, e.g. "click", "hashchange", or "submit".
5317      */
5318     readonly type: string;
5319     /**
5320      * 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.
5321      */
5322     composedPath(): EventTarget[];
5323     initEvent(type: string, bubbles?: boolean, cancelable?: boolean): void;
5324     /**
5325      * 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.
5326      */
5327     preventDefault(): void;
5328     /**
5329      * 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.
5330      */
5331     stopImmediatePropagation(): void;
5332     /**
5333      * When dispatched in a tree, invoking this method prevents event from reaching any objects other than the current object.
5334      */
5335     stopPropagation(): void;
5336     readonly AT_TARGET: number;
5337     readonly BUBBLING_PHASE: number;
5338     readonly CAPTURING_PHASE: number;
5339     readonly NONE: number;
5340 }
5341
5342 declare var Event: {
5343     prototype: Event;
5344     new(type: string, eventInitDict?: EventInit): Event;
5345     readonly AT_TARGET: number;
5346     readonly BUBBLING_PHASE: number;
5347     readonly CAPTURING_PHASE: number;
5348     readonly NONE: number;
5349 };
5350
5351 interface EventListenerObject {
5352     handleEvent(evt: Event): void;
5353 }
5354
5355 interface EventSourceEventMap {
5356     "error": Event;
5357     "message": MessageEvent;
5358     "open": Event;
5359 }
5360
5361 interface EventSource extends EventTarget {
5362     onerror: ((this: EventSource, ev: Event) => any) | null;
5363     onmessage: ((this: EventSource, ev: MessageEvent) => any) | null;
5364     onopen: ((this: EventSource, ev: Event) => any) | null;
5365     /**
5366      * Returns the state of this EventSource object's connection. It can have the values described below.
5367      */
5368     readonly readyState: number;
5369     /**
5370      * Returns the URL providing the event stream.
5371      */
5372     readonly url: string;
5373     /**
5374      * Returns true if the credentials mode for connection requests to the URL providing the event stream is set to "include", and false otherwise.
5375      */
5376     readonly withCredentials: boolean;
5377     /**
5378      * Aborts any instances of the fetch algorithm started for this EventSource object, and sets the readyState attribute to CLOSED.
5379      */
5380     close(): void;
5381     readonly CLOSED: number;
5382     readonly CONNECTING: number;
5383     readonly OPEN: number;
5384     addEventListener<K extends keyof EventSourceEventMap>(type: K, listener: (this: EventSource, ev: EventSourceEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
5385     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
5386     removeEventListener<K extends keyof EventSourceEventMap>(type: K, listener: (this: EventSource, ev: EventSourceEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
5387     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
5388 }
5389
5390 declare var EventSource: {
5391     prototype: EventSource;
5392     new(url: string, eventSourceInitDict?: EventSourceInit): EventSource;
5393     readonly CLOSED: number;
5394     readonly CONNECTING: number;
5395     readonly OPEN: number;
5396 };
5397
5398 /** EventTarget is a DOM interface implemented by objects that can receive events and may have listeners for them. */
5399 interface EventTarget {
5400     /**
5401      * 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.
5402      *
5403      * 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.
5404      *
5405      * 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.
5406      *
5407      * 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.
5408      *
5409      * When set to true, options's once indicates that the callback will only be invoked once after which the event listener will be removed.
5410      *
5411      * The event listener is appended to target's event listener list and is not appended if it has the same type, callback, and capture.
5412      */
5413     addEventListener(type: string, listener: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions): void;
5414     /**
5415      * 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.
5416      */
5417     dispatchEvent(event: Event): boolean;
5418     /**
5419      * Removes the event listener in target's event listener list with the same type, callback, and options.
5420      */
5421     removeEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
5422 }
5423
5424 declare var EventTarget: {
5425     prototype: EventTarget;
5426     new(): EventTarget;
5427 };
5428
5429 interface ExtensionScriptApis {
5430     extensionIdToShortId(extensionId: string): number;
5431     fireExtensionApiTelemetry(functionName: string, isSucceeded: boolean, isSupported: boolean, errorString: string): void;
5432     genericFunction(routerAddress: any, parameters?: string, callbackId?: number): void;
5433     genericSynchronousFunction(functionId: number, parameters?: string): string;
5434     genericWebRuntimeCallout(to: any, from: any, payload: string): void;
5435     getExtensionId(): string;
5436     registerGenericFunctionCallbackHandler(callbackHandler: Function): void;
5437     registerGenericPersistentCallbackHandler(callbackHandler: Function): void;
5438     registerWebRuntimeCallbackHandler(handler: Function): any;
5439 }
5440
5441 declare var ExtensionScriptApis: {
5442     prototype: ExtensionScriptApis;
5443     new(): ExtensionScriptApis;
5444 };
5445
5446 interface External {
5447     /** @deprecated */
5448     AddSearchProvider(): void;
5449     /** @deprecated */
5450     IsSearchProviderInstalled(): void;
5451 }
5452
5453 declare var External: {
5454     prototype: External;
5455     new(): External;
5456 };
5457
5458 /** Provides information about files and allows JavaScript in a web page to access their content. */
5459 interface File extends Blob {
5460     readonly lastModified: number;
5461     readonly name: string;
5462 }
5463
5464 declare var File: {
5465     prototype: File;
5466     new(fileBits: BlobPart[], fileName: string, options?: FilePropertyBag): File;
5467 };
5468
5469 /** 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. */
5470 interface FileList {
5471     readonly length: number;
5472     item(index: number): File | null;
5473     [index: number]: File;
5474 }
5475
5476 declare var FileList: {
5477     prototype: FileList;
5478     new(): FileList;
5479 };
5480
5481 interface FileReaderEventMap {
5482     "abort": ProgressEvent<FileReader>;
5483     "error": ProgressEvent<FileReader>;
5484     "load": ProgressEvent<FileReader>;
5485     "loadend": ProgressEvent<FileReader>;
5486     "loadstart": ProgressEvent<FileReader>;
5487     "progress": ProgressEvent<FileReader>;
5488 }
5489
5490 /** 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. */
5491 interface FileReader extends EventTarget {
5492     readonly error: DOMException | null;
5493     onabort: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
5494     onerror: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
5495     onload: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
5496     onloadend: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
5497     onloadstart: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
5498     onprogress: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
5499     readonly readyState: number;
5500     readonly result: string | ArrayBuffer | null;
5501     abort(): void;
5502     readAsArrayBuffer(blob: Blob): void;
5503     readAsBinaryString(blob: Blob): void;
5504     readAsDataURL(blob: Blob): void;
5505     readAsText(blob: Blob, encoding?: string): void;
5506     readonly DONE: number;
5507     readonly EMPTY: number;
5508     readonly LOADING: number;
5509     addEventListener<K extends keyof FileReaderEventMap>(type: K, listener: (this: FileReader, ev: FileReaderEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
5510     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
5511     removeEventListener<K extends keyof FileReaderEventMap>(type: K, listener: (this: FileReader, ev: FileReaderEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
5512     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
5513 }
5514
5515 declare var FileReader: {
5516     prototype: FileReader;
5517     new(): FileReader;
5518     readonly DONE: number;
5519     readonly EMPTY: number;
5520     readonly LOADING: number;
5521 };
5522
5523 /** Focus-related events like focus, blur, focusin, or focusout. */
5524 interface FocusEvent extends UIEvent {
5525     readonly relatedTarget: EventTarget | null;
5526 }
5527
5528 declare var FocusEvent: {
5529     prototype: FocusEvent;
5530     new(type: string, eventInitDict?: FocusEventInit): FocusEvent;
5531 };
5532
5533 interface FocusNavigationEvent extends Event {
5534     readonly navigationReason: NavigationReason;
5535     readonly originHeight: number;
5536     readonly originLeft: number;
5537     readonly originTop: number;
5538     readonly originWidth: number;
5539     requestFocus(): void;
5540 }
5541
5542 declare var FocusNavigationEvent: {
5543     prototype: FocusNavigationEvent;
5544     new(type: string, eventInitDict?: FocusNavigationEventInit): FocusNavigationEvent;
5545 };
5546
5547 /** 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". */
5548 interface FormData {
5549     append(name: string, value: string | Blob, fileName?: string): void;
5550     delete(name: string): void;
5551     get(name: string): FormDataEntryValue | null;
5552     getAll(name: string): FormDataEntryValue[];
5553     has(name: string): boolean;
5554     set(name: string, value: string | Blob, fileName?: string): void;
5555     forEach(callbackfn: (value: FormDataEntryValue, key: string, parent: FormData) => void, thisArg?: any): void;
5556 }
5557
5558 declare var FormData: {
5559     prototype: FormData;
5560     new(form?: HTMLFormElement): FormData;
5561 };
5562
5563 /** 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. */
5564 interface GainNode extends AudioNode {
5565     readonly gain: AudioParam;
5566 }
5567
5568 declare var GainNode: {
5569     prototype: GainNode;
5570     new(context: BaseAudioContext, options?: GainOptions): GainNode;
5571 };
5572
5573 /** This Gamepad API interface defines an individual gamepad or other controller, allowing access to information such as button presses, axis positions, and id. */
5574 interface Gamepad {
5575     readonly axes: ReadonlyArray<number>;
5576     readonly buttons: ReadonlyArray<GamepadButton>;
5577     readonly connected: boolean;
5578     readonly hand: GamepadHand;
5579     readonly hapticActuators: ReadonlyArray<GamepadHapticActuator>;
5580     readonly id: string;
5581     readonly index: number;
5582     readonly mapping: GamepadMappingType;
5583     readonly pose: GamepadPose | null;
5584     readonly timestamp: number;
5585 }
5586
5587 declare var Gamepad: {
5588     prototype: Gamepad;
5589     new(): Gamepad;
5590 };
5591
5592 /** 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. */
5593 interface GamepadButton {
5594     readonly pressed: boolean;
5595     readonly touched: boolean;
5596     readonly value: number;
5597 }
5598
5599 declare var GamepadButton: {
5600     prototype: GamepadButton;
5601     new(): GamepadButton;
5602 };
5603
5604 /** 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. */
5605 interface GamepadEvent extends Event {
5606     readonly gamepad: Gamepad;
5607 }
5608
5609 declare var GamepadEvent: {
5610     prototype: GamepadEvent;
5611     new(type: string, eventInitDict: GamepadEventInit): GamepadEvent;
5612 };
5613
5614 /** This Gamepad API interface represents hardware in the controller designed to provide haptic feedback to the user (if available), most commonly vibration hardware. */
5615 interface GamepadHapticActuator {
5616     readonly type: GamepadHapticActuatorType;
5617     pulse(value: number, duration: number): Promise<boolean>;
5618 }
5619
5620 declare var GamepadHapticActuator: {
5621     prototype: GamepadHapticActuator;
5622     new(): GamepadHapticActuator;
5623 };
5624
5625 /** This Gamepad API interface represents the pose of a WebVR controller at a given timestamp (which includes orientation, position, velocity, and acceleration information.) */
5626 interface GamepadPose {
5627     readonly angularAcceleration: Float32Array | null;
5628     readonly angularVelocity: Float32Array | null;
5629     readonly hasOrientation: boolean;
5630     readonly hasPosition: boolean;
5631     readonly linearAcceleration: Float32Array | null;
5632     readonly linearVelocity: Float32Array | null;
5633     readonly orientation: Float32Array | null;
5634     readonly position: Float32Array | null;
5635 }
5636
5637 declare var GamepadPose: {
5638     prototype: GamepadPose;
5639     new(): GamepadPose;
5640 };
5641
5642 interface GenericTransformStream {
5643     /**
5644      * Returns a readable stream whose chunks are strings resulting from running encoding's decoder on the chunks written to writable.
5645      */
5646     readonly readable: ReadableStream;
5647     /**
5648      * Returns a writable stream which accepts [AllowShared] BufferSource chunks and runs them through encoding's decoder before making them available to readable.
5649      *
5650      * Typically this will be used via the pipeThrough() method on a ReadableStream source.
5651      *
5652      * ```
5653      * var decoder = new TextDecoderStream(encoding);
5654      * byteReadable
5655      *   .pipeThrough(decoder)
5656      *   .pipeTo(textWritable);
5657      * ```
5658      *
5659      * If the error mode is "fatal" and encoding's decoder returns error, both readable and writable will be errored with a TypeError.
5660      */
5661     readonly writable: WritableStream;
5662 }
5663
5664 /** 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. */
5665 interface Geolocation {
5666     clearWatch(watchId: number): void;
5667     getCurrentPosition(successCallback: PositionCallback, errorCallback?: PositionErrorCallback, options?: PositionOptions): void;
5668     watchPosition(successCallback: PositionCallback, errorCallback?: PositionErrorCallback, options?: PositionOptions): number;
5669 }
5670
5671 interface GlobalEventHandlersEventMap {
5672     "abort": UIEvent;
5673     "animationcancel": AnimationEvent;
5674     "animationend": AnimationEvent;
5675     "animationiteration": AnimationEvent;
5676     "animationstart": AnimationEvent;
5677     "auxclick": MouseEvent;
5678     "blur": FocusEvent;
5679     "cancel": Event;
5680     "canplay": Event;
5681     "canplaythrough": Event;
5682     "change": Event;
5683     "click": MouseEvent;
5684     "close": Event;
5685     "contextmenu": MouseEvent;
5686     "cuechange": Event;
5687     "dblclick": MouseEvent;
5688     "drag": DragEvent;
5689     "dragend": DragEvent;
5690     "dragenter": DragEvent;
5691     "dragexit": Event;
5692     "dragleave": DragEvent;
5693     "dragover": DragEvent;
5694     "dragstart": DragEvent;
5695     "drop": DragEvent;
5696     "durationchange": Event;
5697     "emptied": Event;
5698     "ended": Event;
5699     "error": ErrorEvent;
5700     "focus": FocusEvent;
5701     "focusin": FocusEvent;
5702     "focusout": FocusEvent;
5703     "gotpointercapture": PointerEvent;
5704     "input": Event;
5705     "invalid": Event;
5706     "keydown": KeyboardEvent;
5707     "keypress": KeyboardEvent;
5708     "keyup": KeyboardEvent;
5709     "load": Event;
5710     "loadeddata": Event;
5711     "loadedmetadata": Event;
5712     "loadstart": Event;
5713     "lostpointercapture": PointerEvent;
5714     "mousedown": MouseEvent;
5715     "mouseenter": MouseEvent;
5716     "mouseleave": MouseEvent;
5717     "mousemove": MouseEvent;
5718     "mouseout": MouseEvent;
5719     "mouseover": MouseEvent;
5720     "mouseup": MouseEvent;
5721     "pause": Event;
5722     "play": Event;
5723     "playing": Event;
5724     "pointercancel": PointerEvent;
5725     "pointerdown": PointerEvent;
5726     "pointerenter": PointerEvent;
5727     "pointerleave": PointerEvent;
5728     "pointermove": PointerEvent;
5729     "pointerout": PointerEvent;
5730     "pointerover": PointerEvent;
5731     "pointerup": PointerEvent;
5732     "progress": ProgressEvent;
5733     "ratechange": Event;
5734     "reset": Event;
5735     "resize": UIEvent;
5736     "scroll": Event;
5737     "securitypolicyviolation": SecurityPolicyViolationEvent;
5738     "seeked": Event;
5739     "seeking": Event;
5740     "select": Event;
5741     "selectionchange": Event;
5742     "selectstart": Event;
5743     "stalled": Event;
5744     "submit": Event;
5745     "suspend": Event;
5746     "timeupdate": Event;
5747     "toggle": Event;
5748     "touchcancel": TouchEvent;
5749     "touchend": TouchEvent;
5750     "touchmove": TouchEvent;
5751     "touchstart": TouchEvent;
5752     "transitioncancel": TransitionEvent;
5753     "transitionend": TransitionEvent;
5754     "transitionrun": TransitionEvent;
5755     "transitionstart": TransitionEvent;
5756     "volumechange": Event;
5757     "waiting": Event;
5758     "wheel": WheelEvent;
5759 }
5760
5761 interface GlobalEventHandlers {
5762     /**
5763      * Fires when the user aborts the download.
5764      * @param ev The event.
5765      */
5766     onabort: ((this: GlobalEventHandlers, ev: UIEvent) => any) | null;
5767     onanimationcancel: ((this: GlobalEventHandlers, ev: AnimationEvent) => any) | null;
5768     onanimationend: ((this: GlobalEventHandlers, ev: AnimationEvent) => any) | null;
5769     onanimationiteration: ((this: GlobalEventHandlers, ev: AnimationEvent) => any) | null;
5770     onanimationstart: ((this: GlobalEventHandlers, ev: AnimationEvent) => any) | null;
5771     onauxclick: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
5772     /**
5773      * Fires when the object loses the input focus.
5774      * @param ev The focus event.
5775      */
5776     onblur: ((this: GlobalEventHandlers, ev: FocusEvent) => any) | null;
5777     oncancel: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5778     /**
5779      * Occurs when playback is possible, but would require further buffering.
5780      * @param ev The event.
5781      */
5782     oncanplay: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5783     oncanplaythrough: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5784     /**
5785      * Fires when the contents of the object or selection have changed.
5786      * @param ev The event.
5787      */
5788     onchange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5789     /**
5790      * Fires when the user clicks the left mouse button on the object
5791      * @param ev The mouse event.
5792      */
5793     onclick: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
5794     onclose: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5795     /**
5796      * Fires when the user clicks the right mouse button in the client area, opening the context menu.
5797      * @param ev The mouse event.
5798      */
5799     oncontextmenu: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
5800     oncuechange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5801     /**
5802      * Fires when the user double-clicks the object.
5803      * @param ev The mouse event.
5804      */
5805     ondblclick: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
5806     /**
5807      * Fires on the source object continuously during a drag operation.
5808      * @param ev The event.
5809      */
5810     ondrag: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
5811     /**
5812      * Fires on the source object when the user releases the mouse at the close of a drag operation.
5813      * @param ev The event.
5814      */
5815     ondragend: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
5816     /**
5817      * Fires on the target element when the user drags the object to a valid drop target.
5818      * @param ev The drag event.
5819      */
5820     ondragenter: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
5821     ondragexit: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5822     /**
5823      * Fires on the target object when the user moves the mouse out of a valid drop target during a drag operation.
5824      * @param ev The drag event.
5825      */
5826     ondragleave: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
5827     /**
5828      * Fires on the target element continuously while the user drags the object over a valid drop target.
5829      * @param ev The event.
5830      */
5831     ondragover: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
5832     /**
5833      * Fires on the source object when the user starts to drag a text selection or selected object.
5834      * @param ev The event.
5835      */
5836     ondragstart: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
5837     ondrop: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
5838     /**
5839      * Occurs when the duration attribute is updated.
5840      * @param ev The event.
5841      */
5842     ondurationchange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5843     /**
5844      * Occurs when the media element is reset to its initial state.
5845      * @param ev The event.
5846      */
5847     onemptied: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5848     /**
5849      * Occurs when the end of playback is reached.
5850      * @param ev The event
5851      */
5852     onended: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5853     /**
5854      * Fires when an error occurs during object loading.
5855      * @param ev The event.
5856      */
5857     onerror: OnErrorEventHandler;
5858     /**
5859      * Fires when the object receives focus.
5860      * @param ev The event.
5861      */
5862     onfocus: ((this: GlobalEventHandlers, ev: FocusEvent) => any) | null;
5863     ongotpointercapture: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
5864     oninput: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5865     oninvalid: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5866     /**
5867      * Fires when the user presses a key.
5868      * @param ev The keyboard event
5869      */
5870     onkeydown: ((this: GlobalEventHandlers, ev: KeyboardEvent) => any) | null;
5871     /**
5872      * Fires when the user presses an alphanumeric key.
5873      * @param ev The event.
5874      */
5875     onkeypress: ((this: GlobalEventHandlers, ev: KeyboardEvent) => any) | null;
5876     /**
5877      * Fires when the user releases a key.
5878      * @param ev The keyboard event
5879      */
5880     onkeyup: ((this: GlobalEventHandlers, ev: KeyboardEvent) => any) | null;
5881     /**
5882      * Fires immediately after the browser loads the object.
5883      * @param ev The event.
5884      */
5885     onload: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5886     /**
5887      * Occurs when media data is loaded at the current playback position.
5888      * @param ev The event.
5889      */
5890     onloadeddata: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5891     /**
5892      * Occurs when the duration and dimensions of the media have been determined.
5893      * @param ev The event.
5894      */
5895     onloadedmetadata: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5896     /**
5897      * Occurs when Internet Explorer begins looking for media data.
5898      * @param ev The event.
5899      */
5900     onloadstart: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5901     onlostpointercapture: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
5902     /**
5903      * Fires when the user clicks the object with either mouse button.
5904      * @param ev The mouse event.
5905      */
5906     onmousedown: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
5907     onmouseenter: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
5908     onmouseleave: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
5909     /**
5910      * Fires when the user moves the mouse over the object.
5911      * @param ev The mouse event.
5912      */
5913     onmousemove: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
5914     /**
5915      * Fires when the user moves the mouse pointer outside the boundaries of the object.
5916      * @param ev The mouse event.
5917      */
5918     onmouseout: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
5919     /**
5920      * Fires when the user moves the mouse pointer into the object.
5921      * @param ev The mouse event.
5922      */
5923     onmouseover: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
5924     /**
5925      * Fires when the user releases a mouse button while the mouse is over the object.
5926      * @param ev The mouse event.
5927      */
5928     onmouseup: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
5929     /**
5930      * Occurs when playback is paused.
5931      * @param ev The event.
5932      */
5933     onpause: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5934     /**
5935      * Occurs when the play method is requested.
5936      * @param ev The event.
5937      */
5938     onplay: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5939     /**
5940      * Occurs when the audio or video has started playing.
5941      * @param ev The event.
5942      */
5943     onplaying: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5944     onpointercancel: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
5945     onpointerdown: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
5946     onpointerenter: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
5947     onpointerleave: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
5948     onpointermove: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
5949     onpointerout: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
5950     onpointerover: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
5951     onpointerup: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
5952     /**
5953      * Occurs to indicate progress while downloading media data.
5954      * @param ev The event.
5955      */
5956     onprogress: ((this: GlobalEventHandlers, ev: ProgressEvent) => any) | null;
5957     /**
5958      * Occurs when the playback rate is increased or decreased.
5959      * @param ev The event.
5960      */
5961     onratechange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5962     /**
5963      * Fires when the user resets a form.
5964      * @param ev The event.
5965      */
5966     onreset: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5967     onresize: ((this: GlobalEventHandlers, ev: UIEvent) => any) | null;
5968     /**
5969      * Fires when the user repositions the scroll box in the scroll bar on the object.
5970      * @param ev The event.
5971      */
5972     onscroll: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5973     onsecuritypolicyviolation: ((this: GlobalEventHandlers, ev: SecurityPolicyViolationEvent) => any) | null;
5974     /**
5975      * Occurs when the seek operation ends.
5976      * @param ev The event.
5977      */
5978     onseeked: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5979     /**
5980      * Occurs when the current playback position is moved.
5981      * @param ev The event.
5982      */
5983     onseeking: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5984     /**
5985      * Fires when the current selection changes.
5986      * @param ev The event.
5987      */
5988     onselect: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5989     onselectionchange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5990     onselectstart: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5991     /**
5992      * Occurs when the download has stopped.
5993      * @param ev The event.
5994      */
5995     onstalled: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5996     onsubmit: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5997     /**
5998      * Occurs if the load operation has been intentionally halted.
5999      * @param ev The event.
6000      */
6001     onsuspend: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6002     /**
6003      * Occurs to indicate the current playback position.
6004      * @param ev The event.
6005      */
6006     ontimeupdate: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6007     ontoggle: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6008     ontouchcancel?: ((this: GlobalEventHandlers, ev: TouchEvent) => any) | null;
6009     ontouchend?: ((this: GlobalEventHandlers, ev: TouchEvent) => any) | null;
6010     ontouchmove?: ((this: GlobalEventHandlers, ev: TouchEvent) => any) | null;
6011     ontouchstart?: ((this: GlobalEventHandlers, ev: TouchEvent) => any) | null;
6012     ontransitioncancel: ((this: GlobalEventHandlers, ev: TransitionEvent) => any) | null;
6013     ontransitionend: ((this: GlobalEventHandlers, ev: TransitionEvent) => any) | null;
6014     ontransitionrun: ((this: GlobalEventHandlers, ev: TransitionEvent) => any) | null;
6015     ontransitionstart: ((this: GlobalEventHandlers, ev: TransitionEvent) => any) | null;
6016     /**
6017      * Occurs when the volume is changed, or playback is muted or unmuted.
6018      * @param ev The event.
6019      */
6020     onvolumechange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6021     /**
6022      * Occurs when playback stops because the next frame of a video resource is not available.
6023      * @param ev The event.
6024      */
6025     onwaiting: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6026     onwheel: ((this: GlobalEventHandlers, ev: WheelEvent) => any) | null;
6027     addEventListener<K extends keyof GlobalEventHandlersEventMap>(type: K, listener: (this: GlobalEventHandlers, ev: GlobalEventHandlersEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6028     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6029     removeEventListener<K extends keyof GlobalEventHandlersEventMap>(type: K, listener: (this: GlobalEventHandlers, ev: GlobalEventHandlersEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6030     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6031 }
6032
6033 interface HTMLAllCollection {
6034     /**
6035      * Returns the number of elements in the collection.
6036      */
6037     readonly length: number;
6038     /**
6039      * Returns the item with index index from the collection (determined by tree order).
6040      */
6041     item(nameOrIndex?: string): HTMLCollection | Element | null;
6042     /**
6043      * Returns the item with ID or name name from the collection.
6044      *
6045      * If there are multiple matching items, then an HTMLCollection object containing all those elements is returned.
6046      *
6047      * 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.
6048      */
6049     namedItem(name: string): HTMLCollection | Element | null;
6050     [index: number]: Element;
6051 }
6052
6053 declare var HTMLAllCollection: {
6054     prototype: HTMLAllCollection;
6055     new(): HTMLAllCollection;
6056 };
6057
6058 /** 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. */
6059 interface HTMLAnchorElement extends HTMLElement, HTMLHyperlinkElementUtils {
6060     /**
6061      * Sets or retrieves the character set used to encode the object.
6062      */
6063     /** @deprecated */
6064     charset: string;
6065     /**
6066      * Sets or retrieves the coordinates of the object.
6067      */
6068     /** @deprecated */
6069     coords: string;
6070     download: string;
6071     /**
6072      * Sets or retrieves the language code of the object.
6073      */
6074     hreflang: string;
6075     /**
6076      * Sets or retrieves the shape of the object.
6077      */
6078     /** @deprecated */
6079     name: string;
6080     ping: string;
6081     referrerPolicy: string;
6082     /**
6083      * Sets or retrieves the relationship between the object and the destination of the link.
6084      */
6085     rel: string;
6086     readonly relList: DOMTokenList;
6087     /**
6088      * Sets or retrieves the relationship between the object and the destination of the link.
6089      */
6090     /** @deprecated */
6091     rev: string;
6092     /**
6093      * Sets or retrieves the shape of the object.
6094      */
6095     /** @deprecated */
6096     shape: string;
6097     /**
6098      * Sets or retrieves the window or frame at which to target content.
6099      */
6100     target: string;
6101     /**
6102      * Retrieves or sets the text of the object as a string.
6103      */
6104     text: string;
6105     type: string;
6106     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLAnchorElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6107     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6108     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLAnchorElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6109     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6110 }
6111
6112 declare var HTMLAnchorElement: {
6113     prototype: HTMLAnchorElement;
6114     new(): HTMLAnchorElement;
6115 };
6116
6117 interface HTMLAppletElement extends HTMLElement {
6118     /** @deprecated */
6119     align: string;
6120     /**
6121      * Sets or retrieves a text alternative to the graphic.
6122      */
6123     /** @deprecated */
6124     alt: string;
6125     /**
6126      * Sets or retrieves a character string that can be used to implement your own archive functionality for the object.
6127      */
6128     /** @deprecated */
6129     archive: string;
6130     /** @deprecated */
6131     code: string;
6132     /**
6133      * Sets or retrieves the URL of the component.
6134      */
6135     /** @deprecated */
6136     codeBase: string;
6137     readonly form: HTMLFormElement | null;
6138     /**
6139      * Sets or retrieves the height of the object.
6140      */
6141     /** @deprecated */
6142     height: string;
6143     /** @deprecated */
6144     hspace: number;
6145     /**
6146      * Sets or retrieves the shape of the object.
6147      */
6148     /** @deprecated */
6149     name: string;
6150     /** @deprecated */
6151     object: string;
6152     /** @deprecated */
6153     vspace: number;
6154     /** @deprecated */
6155     width: string;
6156     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLAppletElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6157     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6158     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLAppletElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6159     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6160 }
6161
6162 declare var HTMLAppletElement: {
6163     prototype: HTMLAppletElement;
6164     new(): HTMLAppletElement;
6165 };
6166
6167 /** 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. */
6168 interface HTMLAreaElement extends HTMLElement, HTMLHyperlinkElementUtils {
6169     /**
6170      * Sets or retrieves a text alternative to the graphic.
6171      */
6172     alt: string;
6173     /**
6174      * Sets or retrieves the coordinates of the object.
6175      */
6176     coords: string;
6177     download: string;
6178     /**
6179      * Sets or gets whether clicks in this region cause action.
6180      */
6181     /** @deprecated */
6182     noHref: boolean;
6183     ping: string;
6184     referrerPolicy: string;
6185     rel: string;
6186     readonly relList: DOMTokenList;
6187     /**
6188      * Sets or retrieves the shape of the object.
6189      */
6190     shape: string;
6191     /**
6192      * Sets or retrieves the window or frame at which to target content.
6193      */
6194     target: string;
6195     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLAreaElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6196     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6197     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLAreaElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6198     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6199 }
6200
6201 declare var HTMLAreaElement: {
6202     prototype: HTMLAreaElement;
6203     new(): HTMLAreaElement;
6204 };
6205
6206 /** Provides access to the properties of <audio> elements, as well as methods to manipulate them. It derives from the HTMLMediaElement interface. */
6207 interface HTMLAudioElement extends HTMLMediaElement {
6208     addEventListener<K extends keyof HTMLMediaElementEventMap>(type: K, listener: (this: HTMLAudioElement, ev: HTMLMediaElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6209     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6210     removeEventListener<K extends keyof HTMLMediaElementEventMap>(type: K, listener: (this: HTMLAudioElement, ev: HTMLMediaElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6211     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6212 }
6213
6214 declare var HTMLAudioElement: {
6215     prototype: HTMLAudioElement;
6216     new(): HTMLAudioElement;
6217 };
6218
6219 /** A HTML line break element (<br>). It inherits from HTMLElement. */
6220 interface HTMLBRElement extends HTMLElement {
6221     /**
6222      * Sets or retrieves the side on which floating objects are not to be positioned when any IHTMLBlockElement is inserted into the document.
6223      */
6224     /** @deprecated */
6225     clear: string;
6226     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLBRElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6227     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6228     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLBRElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6229     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6230 }
6231
6232 declare var HTMLBRElement: {
6233     prototype: HTMLBRElement;
6234     new(): HTMLBRElement;
6235 };
6236
6237 /** Contains the base URI for a document. This object inherits all of the properties and methods as described in the HTMLElement interface. */
6238 interface HTMLBaseElement extends HTMLElement {
6239     /**
6240      * Gets or sets the baseline URL on which relative links are based.
6241      */
6242     href: string;
6243     /**
6244      * Sets or retrieves the window or frame at which to target content.
6245      */
6246     target: string;
6247     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLBaseElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6248     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6249     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLBaseElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6250     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6251 }
6252
6253 declare var HTMLBaseElement: {
6254     prototype: HTMLBaseElement;
6255     new(): HTMLBaseElement;
6256 };
6257
6258 /** Provides special properties (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating <basefont> elements. */
6259 interface HTMLBaseFontElement extends HTMLElement, DOML2DeprecatedColorProperty {
6260     /**
6261      * Sets or retrieves the current typeface family.
6262      */
6263     /** @deprecated */
6264     face: string;
6265     /**
6266      * Sets or retrieves the font size of the object.
6267      */
6268     /** @deprecated */
6269     size: number;
6270     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLBaseFontElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6271     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6272     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLBaseFontElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6273     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6274 }
6275
6276 declare var HTMLBaseFontElement: {
6277     prototype: HTMLBaseFontElement;
6278     new(): HTMLBaseFontElement;
6279 };
6280
6281 interface HTMLBodyElementEventMap extends HTMLElementEventMap, WindowEventHandlersEventMap {
6282     "orientationchange": Event;
6283 }
6284
6285 /** Provides special properties (beyond those inherited from the regular HTMLElement interface) for manipulating <body> elements. */
6286 interface HTMLBodyElement extends HTMLElement, WindowEventHandlers {
6287     /** @deprecated */
6288     aLink: string;
6289     /** @deprecated */
6290     background: string;
6291     /** @deprecated */
6292     bgColor: string;
6293     /** @deprecated */
6294     link: string;
6295     /** @deprecated */
6296     onorientationchange: ((this: HTMLBodyElement, ev: Event) => any) | null;
6297     /** @deprecated */
6298     text: string;
6299     /** @deprecated */
6300     vLink: string;
6301     addEventListener<K extends keyof HTMLBodyElementEventMap>(type: K, listener: (this: HTMLBodyElement, ev: HTMLBodyElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6302     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6303     removeEventListener<K extends keyof HTMLBodyElementEventMap>(type: K, listener: (this: HTMLBodyElement, ev: HTMLBodyElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6304     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6305 }
6306
6307 declare var HTMLBodyElement: {
6308     prototype: HTMLBodyElement;
6309     new(): HTMLBodyElement;
6310 };
6311
6312 /** Provides properties and methods (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating <button> elements. */
6313 interface HTMLButtonElement extends HTMLElement {
6314     disabled: boolean;
6315     /**
6316      * Retrieves a reference to the form that the object is embedded in.
6317      */
6318     readonly form: HTMLFormElement | null;
6319     /**
6320      * Overrides the action attribute (where the data on a form is sent) on the parent form element.
6321      */
6322     formAction: string;
6323     /**
6324      * Used to override the encoding (formEnctype attribute) specified on the form element.
6325      */
6326     formEnctype: string;
6327     /**
6328      * Overrides the submit method attribute previously specified on a form element.
6329      */
6330     formMethod: string;
6331     /**
6332      * 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.
6333      */
6334     formNoValidate: boolean;
6335     /**
6336      * Overrides the target attribute on a form element.
6337      */
6338     formTarget: string;
6339     readonly labels: NodeListOf<HTMLLabelElement>;
6340     /**
6341      * Sets or retrieves the name of the object.
6342      */
6343     name: string;
6344     /**
6345      * Gets the classification and default behavior of the button.
6346      */
6347     type: string;
6348     /**
6349      * 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.
6350      */
6351     readonly validationMessage: string;
6352     /**
6353      * Returns a  ValidityState object that represents the validity states of an element.
6354      */
6355     readonly validity: ValidityState;
6356     /**
6357      * Sets or retrieves the default or selected value of the control.
6358      */
6359     value: string;
6360     /**
6361      * Returns whether an element will successfully validate based on forms validation rules and constraints.
6362      */
6363     readonly willValidate: boolean;
6364     /**
6365      * Returns whether a form will validate when it is submitted, without having to submit it.
6366      */
6367     checkValidity(): boolean;
6368     reportValidity(): boolean;
6369     /**
6370      * Sets a custom error message that is displayed when a form is submitted.
6371      * @param error Sets a custom error message that is displayed when a form is submitted.
6372      */
6373     setCustomValidity(error: string): void;
6374     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLButtonElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6375     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6376     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLButtonElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6377     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6378 }
6379
6380 declare var HTMLButtonElement: {
6381     prototype: HTMLButtonElement;
6382     new(): HTMLButtonElement;
6383 };
6384
6385 /** 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. */
6386 interface HTMLCanvasElement extends HTMLElement {
6387     /**
6388      * Gets or sets the height of a canvas element on a document.
6389      */
6390     height: number;
6391     /**
6392      * Gets or sets the width of a canvas element on a document.
6393      */
6394     width: number;
6395     /**
6396      * 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.
6397      * @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");
6398      */
6399     getContext(contextId: "2d", options?: CanvasRenderingContext2DSettings): CanvasRenderingContext2D | null;
6400     getContext(contextId: "bitmaprenderer", options?: ImageBitmapRenderingContextSettings): ImageBitmapRenderingContext | null;
6401     getContext(contextId: "webgl", options?: WebGLContextAttributes): WebGLRenderingContext | null;
6402     getContext(contextId: "webgl2", options?: WebGLContextAttributes): WebGL2RenderingContext | null;
6403     getContext(contextId: string, options?: any): RenderingContext | null;
6404     toBlob(callback: BlobCallback, type?: string, quality?: any): void;
6405     /**
6406      * Returns the content of the current canvas as an image that you can use as a source for another canvas or an HTML element.
6407      * @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.
6408      */
6409     toDataURL(type?: string, quality?: any): string;
6410     transferControlToOffscreen(): OffscreenCanvas;
6411     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLCanvasElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6412     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6413     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLCanvasElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6414     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6415 }
6416
6417 declare var HTMLCanvasElement: {
6418     prototype: HTMLCanvasElement;
6419     new(): HTMLCanvasElement;
6420 };
6421
6422 /** A generic collection (array-like object similar to arguments) of elements (in document order) and offers methods and properties for selecting from the list. */
6423 interface HTMLCollectionBase {
6424     /**
6425      * Sets or retrieves the number of objects in a collection.
6426      */
6427     readonly length: number;
6428     /**
6429      * Retrieves an object from various collections.
6430      */
6431     item(index: number): Element | null;
6432     [index: number]: Element;
6433 }
6434
6435 interface HTMLCollection extends HTMLCollectionBase {
6436     /**
6437      * Retrieves a select object or an object from an options collection.
6438      */
6439     namedItem(name: string): Element | null;
6440 }
6441
6442 declare var HTMLCollection: {
6443     prototype: HTMLCollection;
6444     new(): HTMLCollection;
6445 };
6446
6447 interface HTMLCollectionOf<T extends Element> extends HTMLCollectionBase {
6448     item(index: number): T | null;
6449     namedItem(name: string): T | null;
6450     [index: number]: T;
6451 }
6452
6453 /** Provides special properties (beyond those of the regular HTMLElement interface it also has available to it by inheritance) for manipulating definition list (<dl>) elements. */
6454 interface HTMLDListElement extends HTMLElement {
6455     /** @deprecated */
6456     compact: boolean;
6457     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDListElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6458     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6459     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDListElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6460     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6461 }
6462
6463 declare var HTMLDListElement: {
6464     prototype: HTMLDListElement;
6465     new(): HTMLDListElement;
6466 };
6467
6468 /** Provides special properties (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating <data> elements. */
6469 interface HTMLDataElement extends HTMLElement {
6470     value: string;
6471     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDataElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6472     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6473     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDataElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6474     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6475 }
6476
6477 declare var HTMLDataElement: {
6478     prototype: HTMLDataElement;
6479     new(): HTMLDataElement;
6480 };
6481
6482 /** Provides special properties (beyond the HTMLElement object interface it also has available to it by inheritance) to manipulate <datalist> elements and their content. */
6483 interface HTMLDataListElement extends HTMLElement {
6484     readonly options: HTMLCollectionOf<HTMLOptionElement>;
6485     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDataListElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6486     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6487     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDataListElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6488     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6489 }
6490
6491 declare var HTMLDataListElement: {
6492     prototype: HTMLDataListElement;
6493     new(): HTMLDataListElement;
6494 };
6495
6496 interface HTMLDetailsElement extends HTMLElement {
6497     open: boolean;
6498     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDetailsElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6499     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6500     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDetailsElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6501     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6502 }
6503
6504 declare var HTMLDetailsElement: {
6505     prototype: HTMLDetailsElement;
6506     new(): HTMLDetailsElement;
6507 };
6508
6509 interface HTMLDialogElement extends HTMLElement {
6510     open: boolean;
6511     returnValue: string;
6512     close(returnValue?: string): void;
6513     show(): void;
6514     showModal(): void;
6515     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDialogElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6516     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6517     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDialogElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6518     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6519 }
6520
6521 declare var HTMLDialogElement: {
6522     prototype: HTMLDialogElement;
6523     new(): HTMLDialogElement;
6524 };
6525
6526 interface HTMLDirectoryElement extends HTMLElement {
6527     /** @deprecated */
6528     compact: boolean;
6529     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDirectoryElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6530     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6531     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDirectoryElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6532     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6533 }
6534
6535 declare var HTMLDirectoryElement: {
6536     prototype: HTMLDirectoryElement;
6537     new(): HTMLDirectoryElement;
6538 };
6539
6540 /** Provides special properties (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating <div> elements. */
6541 interface HTMLDivElement extends HTMLElement {
6542     /**
6543      * Sets or retrieves how the object is aligned with adjacent text.
6544      */
6545     /** @deprecated */
6546     align: string;
6547     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDivElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6548     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6549     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDivElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6550     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6551 }
6552
6553 declare var HTMLDivElement: {
6554     prototype: HTMLDivElement;
6555     new(): HTMLDivElement;
6556 };
6557
6558 /** The HTMLDocument property of Window objects is an alias that browsers expose for the Document interface object. */
6559 interface HTMLDocument extends Document {
6560     addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: HTMLDocument, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6561     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6562     removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: HTMLDocument, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6563     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6564 }
6565
6566 declare var HTMLDocument: {
6567     prototype: HTMLDocument;
6568     new(): HTMLDocument;
6569 };
6570
6571 interface HTMLElementEventMap extends ElementEventMap, GlobalEventHandlersEventMap, DocumentAndElementEventHandlersEventMap {
6572 }
6573
6574 /** Any HTML element. Some elements directly implement this interface, while others implement it via an interface that inherits it. */
6575 interface HTMLElement extends Element, DocumentAndElementEventHandlers, ElementCSSInlineStyle, ElementCSSInlineStyle, ElementContentEditable, GlobalEventHandlers, HTMLOrSVGElement {
6576     accessKey: string;
6577     readonly accessKeyLabel: string;
6578     autocapitalize: string;
6579     dir: string;
6580     draggable: boolean;
6581     hidden: boolean;
6582     innerText: string;
6583     lang: string;
6584     readonly offsetHeight: number;
6585     readonly offsetLeft: number;
6586     readonly offsetParent: Element | null;
6587     readonly offsetTop: number;
6588     readonly offsetWidth: number;
6589     spellcheck: boolean;
6590     title: string;
6591     translate: boolean;
6592     click(): void;
6593     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6594     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6595     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6596     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6597 }
6598
6599 declare var HTMLElement: {
6600     prototype: HTMLElement;
6601     new(): HTMLElement;
6602 };
6603
6604 /** Provides special properties (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating <embed> elements. */
6605 interface HTMLEmbedElement extends HTMLElement {
6606     /** @deprecated */
6607     align: string;
6608     /**
6609      * Sets or retrieves the height of the object.
6610      */
6611     height: string;
6612     /**
6613      * Sets or retrieves the name of the object.
6614      */
6615     /** @deprecated */
6616     name: string;
6617     /**
6618      * Sets or retrieves a URL to be loaded by the object.
6619      */
6620     src: string;
6621     type: string;
6622     /**
6623      * Sets or retrieves the width of the object.
6624      */
6625     width: string;
6626     getSVGDocument(): Document | null;
6627     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLEmbedElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6628     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6629     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLEmbedElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6630     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6631 }
6632
6633 declare var HTMLEmbedElement: {
6634     prototype: HTMLEmbedElement;
6635     new(): HTMLEmbedElement;
6636 };
6637
6638 /** 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. */
6639 interface HTMLFieldSetElement extends HTMLElement {
6640     disabled: boolean;
6641     readonly elements: HTMLCollection;
6642     /**
6643      * Retrieves a reference to the form that the object is embedded in.
6644      */
6645     readonly form: HTMLFormElement | null;
6646     name: string;
6647     readonly type: string;
6648     /**
6649      * 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.
6650      */
6651     readonly validationMessage: string;
6652     /**
6653      * Returns a  ValidityState object that represents the validity states of an element.
6654      */
6655     readonly validity: ValidityState;
6656     /**
6657      * Returns whether an element will successfully validate based on forms validation rules and constraints.
6658      */
6659     readonly willValidate: boolean;
6660     /**
6661      * Returns whether a form will validate when it is submitted, without having to submit it.
6662      */
6663     checkValidity(): boolean;
6664     reportValidity(): boolean;
6665     /**
6666      * Sets a custom error message that is displayed when a form is submitted.
6667      * @param error Sets a custom error message that is displayed when a form is submitted.
6668      */
6669     setCustomValidity(error: string): void;
6670     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLFieldSetElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6671     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6672     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLFieldSetElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6673     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6674 }
6675
6676 declare var HTMLFieldSetElement: {
6677     prototype: HTMLFieldSetElement;
6678     new(): HTMLFieldSetElement;
6679 };
6680
6681 /** 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. */
6682 interface HTMLFontElement extends HTMLElement {
6683     /** @deprecated */
6684     color: string;
6685     /**
6686      * Sets or retrieves the current typeface family.
6687      */
6688     /** @deprecated */
6689     face: string;
6690     /** @deprecated */
6691     size: string;
6692     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLFontElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6693     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6694     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLFontElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6695     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6696 }
6697
6698 declare var HTMLFontElement: {
6699     prototype: HTMLFontElement;
6700     new(): HTMLFontElement;
6701 };
6702
6703 /** A collection of HTML form control elements.  */
6704 interface HTMLFormControlsCollection extends HTMLCollectionBase {
6705     /**
6706      * Returns the item with ID or name name from the collection.
6707      *
6708      * If there are multiple matching items, then a RadioNodeList object containing all those elements is returned.
6709      */
6710     namedItem(name: string): RadioNodeList | Element | null;
6711 }
6712
6713 declare var HTMLFormControlsCollection: {
6714     prototype: HTMLFormControlsCollection;
6715     new(): HTMLFormControlsCollection;
6716 };
6717
6718 /** 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. */
6719 interface HTMLFormElement extends HTMLElement {
6720     /**
6721      * Sets or retrieves a list of character encodings for input data that must be accepted by the server processing the form.
6722      */
6723     acceptCharset: string;
6724     /**
6725      * Sets or retrieves the URL to which the form content is sent for processing.
6726      */
6727     action: string;
6728     /**
6729      * Specifies whether autocomplete is applied to an editable text field.
6730      */
6731     autocomplete: string;
6732     /**
6733      * Retrieves a collection, in source order, of all controls in a given form.
6734      */
6735     readonly elements: HTMLFormControlsCollection;
6736     /**
6737      * Sets or retrieves the MIME encoding for the form.
6738      */
6739     encoding: string;
6740     /**
6741      * Sets or retrieves the encoding type for the form.
6742      */
6743     enctype: string;
6744     /**
6745      * Sets or retrieves the number of objects in a collection.
6746      */
6747     readonly length: number;
6748     /**
6749      * Sets or retrieves how to send the form data to the server.
6750      */
6751     method: string;
6752     /**
6753      * Sets or retrieves the name of the object.
6754      */
6755     name: string;
6756     /**
6757      * Designates a form that is not validated when submitted.
6758      */
6759     noValidate: boolean;
6760     /**
6761      * Sets or retrieves the window or frame at which to target content.
6762      */
6763     target: string;
6764     /**
6765      * Returns whether a form will validate when it is submitted, without having to submit it.
6766      */
6767     checkValidity(): boolean;
6768     reportValidity(): boolean;
6769     /**
6770      * Fires when the user resets a form.
6771      */
6772     reset(): void;
6773     /**
6774      * Fires when a FORM is about to be submitted.
6775      */
6776     submit(): void;
6777     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLFormElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6778     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6779     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLFormElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6780     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6781     [index: number]: Element;
6782     [name: string]: any;
6783 }
6784
6785 declare var HTMLFormElement: {
6786     prototype: HTMLFormElement;
6787     new(): HTMLFormElement;
6788 };
6789
6790 interface HTMLFrameElement extends HTMLElement {
6791     /**
6792      * Retrieves the document object of the page or frame.
6793      */
6794     /** @deprecated */
6795     readonly contentDocument: Document | null;
6796     /**
6797      * Retrieves the object of the specified.
6798      */
6799     /** @deprecated */
6800     readonly contentWindow: WindowProxy | null;
6801     /**
6802      * Sets or retrieves whether to display a border for the frame.
6803      */
6804     /** @deprecated */
6805     frameBorder: string;
6806     /**
6807      * Sets or retrieves a URI to a long description of the object.
6808      */
6809     /** @deprecated */
6810     longDesc: string;
6811     /**
6812      * Sets or retrieves the top and bottom margin heights before displaying the text in a frame.
6813      */
6814     /** @deprecated */
6815     marginHeight: string;
6816     /**
6817      * Sets or retrieves the left and right margin widths before displaying the text in a frame.
6818      */
6819     /** @deprecated */
6820     marginWidth: string;
6821     /**
6822      * Sets or retrieves the frame name.
6823      */
6824     /** @deprecated */
6825     name: string;
6826     /**
6827      * Sets or retrieves whether the user can resize the frame.
6828      */
6829     /** @deprecated */
6830     noResize: boolean;
6831     /**
6832      * Sets or retrieves whether the frame can be scrolled.
6833      */
6834     /** @deprecated */
6835     scrolling: string;
6836     /**
6837      * Sets or retrieves a URL to be loaded by the object.
6838      */
6839     /** @deprecated */
6840     src: string;
6841     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLFrameElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6842     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6843     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLFrameElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6844     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6845 }
6846
6847 declare var HTMLFrameElement: {
6848     prototype: HTMLFrameElement;
6849     new(): HTMLFrameElement;
6850 };
6851
6852 interface HTMLFrameSetElementEventMap extends HTMLElementEventMap, WindowEventHandlersEventMap {
6853 }
6854
6855 /** Provides special properties (beyond those of the regular HTMLElement interface they also inherit) for manipulating <frameset> elements. */
6856 interface HTMLFrameSetElement extends HTMLElement, WindowEventHandlers {
6857     /**
6858      * Sets or retrieves the frame widths of the object.
6859      */
6860     /** @deprecated */
6861     cols: string;
6862     /**
6863      * Sets or retrieves the frame heights of the object.
6864      */
6865     /** @deprecated */
6866     rows: string;
6867     addEventListener<K extends keyof HTMLFrameSetElementEventMap>(type: K, listener: (this: HTMLFrameSetElement, ev: HTMLFrameSetElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6868     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6869     removeEventListener<K extends keyof HTMLFrameSetElementEventMap>(type: K, listener: (this: HTMLFrameSetElement, ev: HTMLFrameSetElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6870     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6871 }
6872
6873 declare var HTMLFrameSetElement: {
6874     prototype: HTMLFrameSetElement;
6875     new(): HTMLFrameSetElement;
6876 };
6877
6878 /** Provides special properties (beyond those of the HTMLElement interface it also has available to it by inheritance) for manipulating <hr> elements. */
6879 interface HTMLHRElement extends HTMLElement {
6880     /**
6881      * Sets or retrieves how the object is aligned with adjacent text.
6882      */
6883     /** @deprecated */
6884     align: string;
6885     /** @deprecated */
6886     color: string;
6887     /**
6888      * Sets or retrieves whether the horizontal rule is drawn with 3-D shading.
6889      */
6890     /** @deprecated */
6891     noShade: boolean;
6892     /** @deprecated */
6893     size: string;
6894     /**
6895      * Sets or retrieves the width of the object.
6896      */
6897     /** @deprecated */
6898     width: string;
6899     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLHRElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6900     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6901     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLHRElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6902     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6903 }
6904
6905 declare var HTMLHRElement: {
6906     prototype: HTMLHRElement;
6907     new(): HTMLHRElement;
6908 };
6909
6910 /** Contains the descriptive information, or metadata, for a document. This object inherits all of the properties and methods described in the HTMLElement interface. */
6911 interface HTMLHeadElement extends HTMLElement {
6912     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLHeadElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6913     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6914     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLHeadElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6915     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6916 }
6917
6918 declare var HTMLHeadElement: {
6919     prototype: HTMLHeadElement;
6920     new(): HTMLHeadElement;
6921 };
6922
6923 /** The different heading elements. It inherits methods and properties from the HTMLElement interface. */
6924 interface HTMLHeadingElement extends HTMLElement {
6925     /**
6926      * Sets or retrieves a value that indicates the table alignment.
6927      */
6928     /** @deprecated */
6929     align: string;
6930     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLHeadingElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6931     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6932     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLHeadingElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6933     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6934 }
6935
6936 declare var HTMLHeadingElement: {
6937     prototype: HTMLHeadingElement;
6938     new(): HTMLHeadingElement;
6939 };
6940
6941 /** Serves as the root node for a given HTML document. This object inherits the properties and methods described in the HTMLElement interface. */
6942 interface HTMLHtmlElement extends HTMLElement {
6943     /**
6944      * Sets or retrieves the DTD version that governs the current document.
6945      */
6946     /** @deprecated */
6947     version: string;
6948     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLHtmlElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6949     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6950     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLHtmlElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6951     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6952 }
6953
6954 declare var HTMLHtmlElement: {
6955     prototype: HTMLHtmlElement;
6956     new(): HTMLHtmlElement;
6957 };
6958
6959 interface HTMLHyperlinkElementUtils {
6960     hash: string;
6961     host: string;
6962     hostname: string;
6963     href: string;
6964     toString(): string;
6965     readonly origin: string;
6966     password: string;
6967     pathname: string;
6968     port: string;
6969     protocol: string;
6970     search: string;
6971     username: string;
6972 }
6973
6974 /** 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. */
6975 interface HTMLIFrameElement extends HTMLElement {
6976     /**
6977      * Sets or retrieves how the object is aligned with adjacent text.
6978      */
6979     /** @deprecated */
6980     align: string;
6981     allow: string;
6982     allowFullscreen: boolean;
6983     allowPaymentRequest: boolean;
6984     /**
6985      * Retrieves the document object of the page or frame.
6986      */
6987     readonly contentDocument: Document | null;
6988     /**
6989      * Retrieves the object of the specified.
6990      */
6991     readonly contentWindow: WindowProxy | null;
6992     /**
6993      * Sets or retrieves whether to display a border for the frame.
6994      */
6995     /** @deprecated */
6996     frameBorder: string;
6997     /**
6998      * Sets or retrieves the height of the object.
6999      */
7000     height: string;
7001     /**
7002      * Sets or retrieves a URI to a long description of the object.
7003      */
7004     /** @deprecated */
7005     longDesc: string;
7006     /**
7007      * Sets or retrieves the top and bottom margin heights before displaying the text in a frame.
7008      */
7009     /** @deprecated */
7010     marginHeight: string;
7011     /**
7012      * Sets or retrieves the left and right margin widths before displaying the text in a frame.
7013      */
7014     /** @deprecated */
7015     marginWidth: string;
7016     /**
7017      * Sets or retrieves the frame name.
7018      */
7019     name: string;
7020     referrerPolicy: ReferrerPolicy;
7021     readonly sandbox: DOMTokenList;
7022     /**
7023      * Sets or retrieves whether the frame can be scrolled.
7024      */
7025     /** @deprecated */
7026     scrolling: string;
7027     /**
7028      * Sets or retrieves a URL to be loaded by the object.
7029      */
7030     src: string;
7031     /**
7032      * Sets or retrives the content of the page that is to contain.
7033      */
7034     srcdoc: string;
7035     /**
7036      * Sets or retrieves the width of the object.
7037      */
7038     width: string;
7039     getSVGDocument(): Document | null;
7040     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLIFrameElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7041     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7042     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLIFrameElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7043     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7044 }
7045
7046 declare var HTMLIFrameElement: {
7047     prototype: HTMLIFrameElement;
7048     new(): HTMLIFrameElement;
7049 };
7050
7051 /** Provides special properties and methods for manipulating <img> elements. */
7052 interface HTMLImageElement extends HTMLElement {
7053     /**
7054      * Sets or retrieves how the object is aligned with adjacent text.
7055      */
7056     /** @deprecated */
7057     align: string;
7058     /**
7059      * Sets or retrieves a text alternative to the graphic.
7060      */
7061     alt: string;
7062     /**
7063      * Specifies the properties of a border drawn around an object.
7064      */
7065     /** @deprecated */
7066     border: string;
7067     /**
7068      * Retrieves whether the object is fully loaded.
7069      */
7070     readonly complete: boolean;
7071     crossOrigin: string | null;
7072     readonly currentSrc: string;
7073     decoding: "async" | "sync" | "auto";
7074     /**
7075      * Sets or retrieves the height of the object.
7076      */
7077     height: number;
7078     /**
7079      * Sets or retrieves the width of the border to draw around the object.
7080      */
7081     /** @deprecated */
7082     hspace: number;
7083     /**
7084      * Sets or retrieves whether the image is a server-side image map.
7085      */
7086     isMap: boolean;
7087     /**
7088      * Sets or retrieves a Uniform Resource Identifier (URI) to a long description of the object.
7089      */
7090     /** @deprecated */
7091     longDesc: string;
7092     /** @deprecated */
7093     lowsrc: string;
7094     /**
7095      * Sets or retrieves the name of the object.
7096      */
7097     /** @deprecated */
7098     name: string;
7099     /**
7100      * The original height of the image resource before sizing.
7101      */
7102     readonly naturalHeight: number;
7103     /**
7104      * The original width of the image resource before sizing.
7105      */
7106     readonly naturalWidth: number;
7107     referrerPolicy: string;
7108     sizes: string;
7109     /**
7110      * The address or URL of the a media resource that is to be considered.
7111      */
7112     src: string;
7113     srcset: string;
7114     /**
7115      * Sets or retrieves the URL, often with a bookmark extension (#name), to use as a client-side image map.
7116      */
7117     useMap: string;
7118     /**
7119      * Sets or retrieves the vertical margin for the object.
7120      */
7121     /** @deprecated */
7122     vspace: number;
7123     /**
7124      * Sets or retrieves the width of the object.
7125      */
7126     width: number;
7127     readonly x: number;
7128     readonly y: number;
7129     decode(): Promise<void>;
7130     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLImageElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7131     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7132     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLImageElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7133     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7134 }
7135
7136 declare var HTMLImageElement: {
7137     prototype: HTMLImageElement;
7138     new(): HTMLImageElement;
7139 };
7140
7141 /** Provides special properties and methods for manipulating the options, layout, and presentation of <input> elements. */
7142 interface HTMLInputElement extends HTMLElement {
7143     /**
7144      * Sets or retrieves a comma-separated list of content types.
7145      */
7146     accept: string;
7147     /**
7148      * Sets or retrieves how the object is aligned with adjacent text.
7149      */
7150     /** @deprecated */
7151     align: string;
7152     /**
7153      * Sets or retrieves a text alternative to the graphic.
7154      */
7155     alt: string;
7156     /**
7157      * Specifies whether autocomplete is applied to an editable text field.
7158      */
7159     autocomplete: string;
7160     /**
7161      * Sets or retrieves the state of the check box or radio button.
7162      */
7163     checked: boolean;
7164     /**
7165      * Sets or retrieves the state of the check box or radio button.
7166      */
7167     defaultChecked: boolean;
7168     /**
7169      * Sets or retrieves the initial contents of the object.
7170      */
7171     defaultValue: string;
7172     dirName: string;
7173     disabled: boolean;
7174     /**
7175      * Returns a FileList object on a file type input object.
7176      */
7177     files: FileList | null;
7178     /**
7179      * Retrieves a reference to the form that the object is embedded in.
7180      */
7181     readonly form: HTMLFormElement | null;
7182     /**
7183      * Overrides the action attribute (where the data on a form is sent) on the parent form element.
7184      */
7185     formAction: string;
7186     /**
7187      * Used to override the encoding (formEnctype attribute) specified on the form element.
7188      */
7189     formEnctype: string;
7190     /**
7191      * Overrides the submit method attribute previously specified on a form element.
7192      */
7193     formMethod: string;
7194     /**
7195      * 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.
7196      */
7197     formNoValidate: boolean;
7198     /**
7199      * Overrides the target attribute on a form element.
7200      */
7201     formTarget: string;
7202     /**
7203      * Sets or retrieves the height of the object.
7204      */
7205     height: number;
7206     indeterminate: boolean;
7207     readonly labels: NodeListOf<HTMLLabelElement> | null;
7208     /**
7209      * Specifies the ID of a pre-defined datalist of options for an input element.
7210      */
7211     readonly list: HTMLElement | null;
7212     /**
7213      * 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.
7214      */
7215     max: string;
7216     /**
7217      * Sets or retrieves the maximum number of characters that the user can enter in a text control.
7218      */
7219     maxLength: number;
7220     /**
7221      * 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.
7222      */
7223     min: string;
7224     minLength: number;
7225     /**
7226      * Sets or retrieves the Boolean value indicating whether multiple items can be selected from a list.
7227      */
7228     multiple: boolean;
7229     /**
7230      * Sets or retrieves the name of the object.
7231      */
7232     name: string;
7233     /**
7234      * Gets or sets a string containing a regular expression that the user's input must match.
7235      */
7236     pattern: string;
7237     /**
7238      * 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.
7239      */
7240     placeholder: string;
7241     readOnly: boolean;
7242     /**
7243      * When present, marks an element that can't be submitted without a value.
7244      */
7245     required: boolean;
7246     selectionDirection: "forward" | "backward" | "none" | null;
7247     /**
7248      * Gets or sets the end position or offset of a text selection.
7249      */
7250     selectionEnd: number | null;
7251     /**
7252      * Gets or sets the starting position or offset of a text selection.
7253      */
7254     selectionStart: number | null;
7255     size: number;
7256     /**
7257      * The address or URL of the a media resource that is to be considered.
7258      */
7259     src: string;
7260     /**
7261      * 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.
7262      */
7263     step: string;
7264     /**
7265      * Returns the content type of the object.
7266      */
7267     type: string;
7268     /**
7269      * Sets or retrieves the URL, often with a bookmark extension (#name), to use as a client-side image map.
7270      */
7271     /** @deprecated */
7272     useMap: string;
7273     /**
7274      * 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.
7275      */
7276     readonly validationMessage: string;
7277     /**
7278      * Returns a  ValidityState object that represents the validity states of an element.
7279      */
7280     readonly validity: ValidityState;
7281     /**
7282      * Returns the value of the data at the cursor's current position.
7283      */
7284     value: string;
7285     /**
7286      * 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.
7287      */
7288     valueAsDate: Date | null;
7289     /**
7290      * Returns the input field value as a number.
7291      */
7292     valueAsNumber: number;
7293     /**
7294      * Sets or retrieves the width of the object.
7295      */
7296     width: number;
7297     /**
7298      * Returns whether an element will successfully validate based on forms validation rules and constraints.
7299      */
7300     readonly willValidate: boolean;
7301     /**
7302      * Returns whether a form will validate when it is submitted, without having to submit it.
7303      */
7304     checkValidity(): boolean;
7305     reportValidity(): boolean;
7306     /**
7307      * Makes the selection equal to the current object.
7308      */
7309     select(): void;
7310     /**
7311      * Sets a custom error message that is displayed when a form is submitted.
7312      * @param error Sets a custom error message that is displayed when a form is submitted.
7313      */
7314     setCustomValidity(error: string): void;
7315     setRangeText(replacement: string): void;
7316     setRangeText(replacement: string, start: number, end: number, selectionMode?: SelectionMode): void;
7317     /**
7318      * Sets the start and end positions of a selection in a text field.
7319      * @param start The offset into the text field for the start of the selection.
7320      * @param end The offset into the text field for the end of the selection.
7321      * @param direction The direction in which the selection is performed.
7322      */
7323     setSelectionRange(start: number, end: number, direction?: "forward" | "backward" | "none"): void;
7324     /**
7325      * 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.
7326      * @param n Value to decrement the value by.
7327      */
7328     stepDown(n?: number): void;
7329     /**
7330      * 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.
7331      * @param n Value to increment the value by.
7332      */
7333     stepUp(n?: number): void;
7334     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLInputElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7335     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7336     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLInputElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7337     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7338 }
7339
7340 declare var HTMLInputElement: {
7341     prototype: HTMLInputElement;
7342     new(): HTMLInputElement;
7343 };
7344
7345 /** Exposes specific properties and methods (beyond those defined by regular HTMLElement interface it also has available to it by inheritance) for manipulating list elements. */
7346 interface HTMLLIElement extends HTMLElement {
7347     /** @deprecated */
7348     type: string;
7349     /**
7350      * Sets or retrieves the value of a list item.
7351      */
7352     value: number;
7353     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLLIElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7354     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7355     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLLIElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7356     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7357 }
7358
7359 declare var HTMLLIElement: {
7360     prototype: HTMLLIElement;
7361     new(): HTMLLIElement;
7362 };
7363
7364 /** Gives access to properties specific to <label> elements. It inherits methods and properties from the base HTMLElement interface. */
7365 interface HTMLLabelElement extends HTMLElement {
7366     readonly control: HTMLElement | null;
7367     /**
7368      * Retrieves a reference to the form that the object is embedded in.
7369      */
7370     readonly form: HTMLFormElement | null;
7371     /**
7372      * Sets or retrieves the object to which the given label object is assigned.
7373      */
7374     htmlFor: string;
7375     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLLabelElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7376     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7377     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLLabelElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7378     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7379 }
7380
7381 declare var HTMLLabelElement: {
7382     prototype: HTMLLabelElement;
7383     new(): HTMLLabelElement;
7384 };
7385
7386 /** The HTMLLegendElement is an interface allowing to access properties of the <legend> elements. It inherits properties and methods from the HTMLElement interface. */
7387 interface HTMLLegendElement extends HTMLElement {
7388     /** @deprecated */
7389     align: string;
7390     /**
7391      * Retrieves a reference to the form that the object is embedded in.
7392      */
7393     readonly form: HTMLFormElement | null;
7394     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLLegendElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7395     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7396     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLLegendElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7397     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7398 }
7399
7400 declare var HTMLLegendElement: {
7401     prototype: HTMLLegendElement;
7402     new(): HTMLLegendElement;
7403 };
7404
7405 /** 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. */
7406 interface HTMLLinkElement extends HTMLElement, LinkStyle {
7407     as: string;
7408     /**
7409      * Sets or retrieves the character set used to encode the object.
7410      */
7411     /** @deprecated */
7412     charset: string;
7413     crossOrigin: string | null;
7414     disabled: boolean;
7415     /**
7416      * Sets or retrieves a destination URL or an anchor point.
7417      */
7418     href: string;
7419     /**
7420      * Sets or retrieves the language code of the object.
7421      */
7422     hreflang: string;
7423     imageSizes: string;
7424     imageSrcset: string;
7425     integrity: string;
7426     /**
7427      * Sets or retrieves the media type.
7428      */
7429     media: string;
7430     referrerPolicy: string;
7431     /**
7432      * Sets or retrieves the relationship between the object and the destination of the link.
7433      */
7434     rel: string;
7435     readonly relList: DOMTokenList;
7436     /**
7437      * Sets or retrieves the relationship between the object and the destination of the link.
7438      */
7439     /** @deprecated */
7440     rev: string;
7441     readonly sizes: DOMTokenList;
7442     /**
7443      * Sets or retrieves the window or frame at which to target content.
7444      */
7445     /** @deprecated */
7446     target: string;
7447     /**
7448      * Sets or retrieves the MIME type of the object.
7449      */
7450     type: string;
7451     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLLinkElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7452     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7453     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLLinkElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7454     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7455 }
7456
7457 declare var HTMLLinkElement: {
7458     prototype: HTMLLinkElement;
7459     new(): HTMLLinkElement;
7460 };
7461
7462 /** 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. */
7463 interface HTMLMapElement extends HTMLElement {
7464     /**
7465      * Retrieves a collection of the area objects defined for the given map object.
7466      */
7467     readonly areas: HTMLCollection;
7468     /**
7469      * Sets or retrieves the name of the object.
7470      */
7471     name: string;
7472     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLMapElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7473     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7474     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLMapElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7475     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7476 }
7477
7478 declare var HTMLMapElement: {
7479     prototype: HTMLMapElement;
7480     new(): HTMLMapElement;
7481 };
7482
7483 interface HTMLMarqueeElementEventMap extends HTMLElementEventMap {
7484     "bounce": Event;
7485     "finish": Event;
7486     "start": Event;
7487 }
7488
7489 /** Provides methods to manipulate <marquee> elements. */
7490 interface HTMLMarqueeElement extends HTMLElement {
7491     /** @deprecated */
7492     behavior: string;
7493     /** @deprecated */
7494     bgColor: string;
7495     /** @deprecated */
7496     direction: string;
7497     /** @deprecated */
7498     height: string;
7499     /** @deprecated */
7500     hspace: number;
7501     /** @deprecated */
7502     loop: number;
7503     /** @deprecated */
7504     onbounce: ((this: HTMLMarqueeElement, ev: Event) => any) | null;
7505     /** @deprecated */
7506     onfinish: ((this: HTMLMarqueeElement, ev: Event) => any) | null;
7507     /** @deprecated */
7508     onstart: ((this: HTMLMarqueeElement, ev: Event) => any) | null;
7509     /** @deprecated */
7510     scrollAmount: number;
7511     /** @deprecated */
7512     scrollDelay: number;
7513     /** @deprecated */
7514     trueSpeed: boolean;
7515     /** @deprecated */
7516     vspace: number;
7517     /** @deprecated */
7518     width: string;
7519     /** @deprecated */
7520     start(): void;
7521     /** @deprecated */
7522     stop(): void;
7523     addEventListener<K extends keyof HTMLMarqueeElementEventMap>(type: K, listener: (this: HTMLMarqueeElement, ev: HTMLMarqueeElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7524     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7525     removeEventListener<K extends keyof HTMLMarqueeElementEventMap>(type: K, listener: (this: HTMLMarqueeElement, ev: HTMLMarqueeElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7526     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7527 }
7528
7529 declare var HTMLMarqueeElement: {
7530     prototype: HTMLMarqueeElement;
7531     new(): HTMLMarqueeElement;
7532 };
7533
7534 interface HTMLMediaElementEventMap extends HTMLElementEventMap {
7535     "encrypted": MediaEncryptedEvent;
7536     "waitingforkey": Event;
7537 }
7538
7539 /** Adds to HTMLElement the properties and methods needed to support basic media-related capabilities that are common to audio and video. */
7540 interface HTMLMediaElement extends HTMLElement {
7541     /**
7542      * Gets or sets a value that indicates whether to start playing the media automatically.
7543      */
7544     autoplay: boolean;
7545     /**
7546      * Gets a collection of buffered time ranges.
7547      */
7548     readonly buffered: TimeRanges;
7549     /**
7550      * 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).
7551      */
7552     controls: boolean;
7553     crossOrigin: string | null;
7554     /**
7555      * Gets the address or URL of the current media resource that is selected by IHTMLMediaElement.
7556      */
7557     readonly currentSrc: string;
7558     /**
7559      * Gets or sets the current playback position, in seconds.
7560      */
7561     currentTime: number;
7562     defaultMuted: boolean;
7563     /**
7564      * Gets or sets the default playback rate when the user is not using fast forward or reverse for a video or audio resource.
7565      */
7566     defaultPlaybackRate: number;
7567     /**
7568      * 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.
7569      */
7570     readonly duration: number;
7571     /**
7572      * Gets information about whether the playback has ended or not.
7573      */
7574     readonly ended: boolean;
7575     /**
7576      * Returns an object representing the current error state of the audio or video element.
7577      */
7578     readonly error: MediaError | null;
7579     /**
7580      * Gets or sets a flag to specify whether playback should restart after it completes.
7581      */
7582     loop: boolean;
7583     readonly mediaKeys: MediaKeys | null;
7584     /**
7585      * Gets or sets a flag that indicates whether the audio (either audio or the audio track on video media) is muted.
7586      */
7587     muted: boolean;
7588     /**
7589      * Gets the current network activity for the element.
7590      */
7591     readonly networkState: number;
7592     onencrypted: ((this: HTMLMediaElement, ev: MediaEncryptedEvent) => any) | null;
7593     onwaitingforkey: ((this: HTMLMediaElement, ev: Event) => any) | null;
7594     /**
7595      * Gets a flag that specifies whether playback is paused.
7596      */
7597     readonly paused: boolean;
7598     /**
7599      * 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.
7600      */
7601     playbackRate: number;
7602     /**
7603      * Gets TimeRanges for the current media resource that has been played.
7604      */
7605     readonly played: TimeRanges;
7606     /**
7607      * Gets or sets the current playback position, in seconds.
7608      */
7609     preload: string;
7610     readonly readyState: number;
7611     /**
7612      * Returns a TimeRanges object that represents the ranges of the current media resource that can be seeked.
7613      */
7614     readonly seekable: TimeRanges;
7615     /**
7616      * Gets a flag that indicates whether the client is currently moving to a new playback position in the media resource.
7617      */
7618     readonly seeking: boolean;
7619     /**
7620      * The address or URL of the a media resource that is to be considered.
7621      */
7622     src: string;
7623     srcObject: MediaProvider | null;
7624     readonly textTracks: TextTrackList;
7625     /**
7626      * Gets or sets the volume level for audio portions of the media element.
7627      */
7628     volume: number;
7629     addTextTrack(kind: TextTrackKind, label?: string, language?: string): TextTrack;
7630     /**
7631      * Returns a string that specifies whether the client can play a given media resource type.
7632      */
7633     canPlayType(type: string): CanPlayTypeResult;
7634     fastSeek(time: number): void;
7635     /**
7636      * Resets the audio or video object and loads a new media resource.
7637      */
7638     load(): void;
7639     /**
7640      * 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.
7641      */
7642     pause(): void;
7643     /**
7644      * Loads and starts playback of a media resource.
7645      */
7646     play(): Promise<void>;
7647     setMediaKeys(mediaKeys: MediaKeys | null): Promise<void>;
7648     readonly HAVE_CURRENT_DATA: number;
7649     readonly HAVE_ENOUGH_DATA: number;
7650     readonly HAVE_FUTURE_DATA: number;
7651     readonly HAVE_METADATA: number;
7652     readonly HAVE_NOTHING: number;
7653     readonly NETWORK_EMPTY: number;
7654     readonly NETWORK_IDLE: number;
7655     readonly NETWORK_LOADING: number;
7656     readonly NETWORK_NO_SOURCE: number;
7657     addEventListener<K extends keyof HTMLMediaElementEventMap>(type: K, listener: (this: HTMLMediaElement, ev: HTMLMediaElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7658     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7659     removeEventListener<K extends keyof HTMLMediaElementEventMap>(type: K, listener: (this: HTMLMediaElement, ev: HTMLMediaElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7660     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7661 }
7662
7663 declare var HTMLMediaElement: {
7664     prototype: HTMLMediaElement;
7665     new(): HTMLMediaElement;
7666     readonly HAVE_CURRENT_DATA: number;
7667     readonly HAVE_ENOUGH_DATA: number;
7668     readonly HAVE_FUTURE_DATA: number;
7669     readonly HAVE_METADATA: number;
7670     readonly HAVE_NOTHING: number;
7671     readonly NETWORK_EMPTY: number;
7672     readonly NETWORK_IDLE: number;
7673     readonly NETWORK_LOADING: number;
7674     readonly NETWORK_NO_SOURCE: number;
7675 };
7676
7677 interface HTMLMenuElement extends HTMLElement {
7678     /** @deprecated */
7679     compact: boolean;
7680     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLMenuElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7681     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7682     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLMenuElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7683     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7684 }
7685
7686 declare var HTMLMenuElement: {
7687     prototype: HTMLMenuElement;
7688     new(): HTMLMenuElement;
7689 };
7690
7691 /** Contains descriptive metadata about a document. It inherits all of the properties and methods described in the HTMLElement interface. */
7692 interface HTMLMetaElement extends HTMLElement {
7693     /**
7694      * Gets or sets meta-information to associate with httpEquiv or name.
7695      */
7696     content: string;
7697     /**
7698      * Gets or sets information used to bind the value of a content attribute of a meta element to an HTTP response header.
7699      */
7700     httpEquiv: string;
7701     /**
7702      * Sets or retrieves the value specified in the content attribute of the meta object.
7703      */
7704     name: string;
7705     /**
7706      * Sets or retrieves a scheme to be used in interpreting the value of a property specified for the object.
7707      */
7708     /** @deprecated */
7709     scheme: string;
7710     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLMetaElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7711     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7712     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLMetaElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7713     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7714 }
7715
7716 declare var HTMLMetaElement: {
7717     prototype: HTMLMetaElement;
7718     new(): HTMLMetaElement;
7719 };
7720
7721 /** 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. */
7722 interface HTMLMeterElement extends HTMLElement {
7723     high: number;
7724     readonly labels: NodeListOf<HTMLLabelElement>;
7725     low: number;
7726     max: number;
7727     min: number;
7728     optimum: number;
7729     value: number;
7730     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLMeterElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7731     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7732     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLMeterElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7733     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7734 }
7735
7736 declare var HTMLMeterElement: {
7737     prototype: HTMLMeterElement;
7738     new(): HTMLMeterElement;
7739 };
7740
7741 /** 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>. */
7742 interface HTMLModElement extends HTMLElement {
7743     /**
7744      * Sets or retrieves reference information about the object.
7745      */
7746     cite: string;
7747     /**
7748      * Sets or retrieves the date and time of a modification to the object.
7749      */
7750     dateTime: string;
7751     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLModElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7752     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7753     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLModElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7754     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7755 }
7756
7757 declare var HTMLModElement: {
7758     prototype: HTMLModElement;
7759     new(): HTMLModElement;
7760 };
7761
7762 /** Provides special properties (beyond those defined on the regular HTMLElement interface it also has available to it by inheritance) for manipulating ordered list elements. */
7763 interface HTMLOListElement extends HTMLElement {
7764     /** @deprecated */
7765     compact: boolean;
7766     reversed: boolean;
7767     /**
7768      * The starting number.
7769      */
7770     start: number;
7771     type: string;
7772     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLOListElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7773     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7774     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLOListElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7775     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7776 }
7777
7778 declare var HTMLOListElement: {
7779     prototype: HTMLOListElement;
7780     new(): HTMLOListElement;
7781 };
7782
7783 /** 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. */
7784 interface HTMLObjectElement extends HTMLElement {
7785     /** @deprecated */
7786     align: string;
7787     /**
7788      * Sets or retrieves a character string that can be used to implement your own archive functionality for the object.
7789      */
7790     /** @deprecated */
7791     archive: string;
7792     /** @deprecated */
7793     border: string;
7794     /**
7795      * Sets or retrieves the URL of the file containing the compiled Java class.
7796      */
7797     /** @deprecated */
7798     code: string;
7799     /**
7800      * Sets or retrieves the URL of the component.
7801      */
7802     /** @deprecated */
7803     codeBase: string;
7804     /**
7805      * Sets or retrieves the Internet media type for the code associated with the object.
7806      */
7807     /** @deprecated */
7808     codeType: string;
7809     /**
7810      * Retrieves the document object of the page or frame.
7811      */
7812     readonly contentDocument: Document | null;
7813     readonly contentWindow: WindowProxy | null;
7814     /**
7815      * Sets or retrieves the URL that references the data of the object.
7816      */
7817     data: string;
7818     /** @deprecated */
7819     declare: boolean;
7820     /**
7821      * Retrieves a reference to the form that the object is embedded in.
7822      */
7823     readonly form: HTMLFormElement | null;
7824     /**
7825      * Sets or retrieves the height of the object.
7826      */
7827     height: string;
7828     /** @deprecated */
7829     hspace: number;
7830     /**
7831      * Sets or retrieves the name of the object.
7832      */
7833     name: string;
7834     /**
7835      * Sets or retrieves a message to be displayed while an object is loading.
7836      */
7837     /** @deprecated */
7838     standby: string;
7839     /**
7840      * Sets or retrieves the MIME type of the object.
7841      */
7842     type: string;
7843     /**
7844      * Sets or retrieves the URL, often with a bookmark extension (#name), to use as a client-side image map.
7845      */
7846     useMap: string;
7847     /**
7848      * 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.
7849      */
7850     readonly validationMessage: string;
7851     /**
7852      * Returns a  ValidityState object that represents the validity states of an element.
7853      */
7854     readonly validity: ValidityState;
7855     /** @deprecated */
7856     vspace: number;
7857     /**
7858      * Sets or retrieves the width of the object.
7859      */
7860     width: string;
7861     /**
7862      * Returns whether an element will successfully validate based on forms validation rules and constraints.
7863      */
7864     readonly willValidate: boolean;
7865     /**
7866      * Returns whether a form will validate when it is submitted, without having to submit it.
7867      */
7868     checkValidity(): boolean;
7869     getSVGDocument(): Document | null;
7870     reportValidity(): boolean;
7871     /**
7872      * Sets a custom error message that is displayed when a form is submitted.
7873      * @param error Sets a custom error message that is displayed when a form is submitted.
7874      */
7875     setCustomValidity(error: string): void;
7876     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLObjectElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7877     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7878     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLObjectElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7879     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7880 }
7881
7882 declare var HTMLObjectElement: {
7883     prototype: HTMLObjectElement;
7884     new(): HTMLObjectElement;
7885 };
7886
7887 /** 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. */
7888 interface HTMLOptGroupElement extends HTMLElement {
7889     disabled: boolean;
7890     /**
7891      * Retrieves a reference to the form that the object is embedded in.
7892      */
7893     readonly form: HTMLFormElement | null;
7894     /**
7895      * Sets or retrieves a value that you can use to implement your own label functionality for the object.
7896      */
7897     label: string;
7898     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLOptGroupElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7899     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7900     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLOptGroupElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7901     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7902 }
7903
7904 declare var HTMLOptGroupElement: {
7905     prototype: HTMLOptGroupElement;
7906     new(): HTMLOptGroupElement;
7907 };
7908
7909 /** <option> elements and inherits all classes and methods of the HTMLElement interface. */
7910 interface HTMLOptionElement extends HTMLElement {
7911     /**
7912      * Sets or retrieves the status of an option.
7913      */
7914     defaultSelected: boolean;
7915     disabled: boolean;
7916     /**
7917      * Retrieves a reference to the form that the object is embedded in.
7918      */
7919     readonly form: HTMLFormElement | null;
7920     /**
7921      * Sets or retrieves the ordinal position of an option in a list box.
7922      */
7923     readonly index: number;
7924     /**
7925      * Sets or retrieves a value that you can use to implement your own label functionality for the object.
7926      */
7927     label: string;
7928     /**
7929      * Sets or retrieves whether the option in the list box is the default item.
7930      */
7931     selected: boolean;
7932     /**
7933      * Sets or retrieves the text string specified by the option tag.
7934      */
7935     text: string;
7936     /**
7937      * Sets or retrieves the value which is returned to the server when the form control is submitted.
7938      */
7939     value: string;
7940     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLOptionElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7941     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7942     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLOptionElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7943     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7944 }
7945
7946 declare var HTMLOptionElement: {
7947     prototype: HTMLOptionElement;
7948     new(): HTMLOptionElement;
7949 };
7950
7951 /** 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. */
7952 interface HTMLOptionsCollection extends HTMLCollectionOf<HTMLOptionElement> {
7953     /**
7954      * Returns the number of elements in the collection.
7955      *
7956      * When set to a smaller number, truncates the number of option elements in the corresponding container.
7957      *
7958      * When set to a greater number, adds new blank option elements to that container.
7959      */
7960     length: number;
7961     /**
7962      * Returns the index of the first selected item, if any, or −1 if there is no selected item.
7963      *
7964      * Can be set, to change the selection.
7965      */
7966     selectedIndex: number;
7967     /**
7968      * Inserts element before the node given by before.
7969      *
7970      * 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.
7971      *
7972      * If before is omitted, null, or a number out of range, then element will be added at the end of the list.
7973      *
7974      * This method will throw a "HierarchyRequestError" DOMException if element is an ancestor of the element into which it is to be inserted.
7975      */
7976     add(element: HTMLOptionElement | HTMLOptGroupElement, before?: HTMLElement | number | null): void;
7977     /**
7978      * Removes the item with index index from the collection.
7979      */
7980     remove(index: number): void;
7981 }
7982
7983 declare var HTMLOptionsCollection: {
7984     prototype: HTMLOptionsCollection;
7985     new(): HTMLOptionsCollection;
7986 };
7987
7988 interface HTMLOrSVGElement {
7989     autofocus: boolean;
7990     readonly dataset: DOMStringMap;
7991     nonce?: string;
7992     tabIndex: number;
7993     blur(): void;
7994     focus(options?: FocusOptions): void;
7995 }
7996
7997 /** Provides properties and methods (beyond those inherited from HTMLElement) for manipulating the layout and presentation of <output> elements. */
7998 interface HTMLOutputElement extends HTMLElement {
7999     defaultValue: string;
8000     readonly form: HTMLFormElement | null;
8001     readonly htmlFor: DOMTokenList;
8002     readonly labels: NodeListOf<HTMLLabelElement>;
8003     name: string;
8004     readonly type: string;
8005     readonly validationMessage: string;
8006     readonly validity: ValidityState;
8007     value: string;
8008     readonly willValidate: boolean;
8009     checkValidity(): boolean;
8010     reportValidity(): boolean;
8011     setCustomValidity(error: string): void;
8012     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLOutputElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8013     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8014     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLOutputElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8015     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8016 }
8017
8018 declare var HTMLOutputElement: {
8019     prototype: HTMLOutputElement;
8020     new(): HTMLOutputElement;
8021 };
8022
8023 /** Provides special properties (beyond those of the regular HTMLElement object interface it inherits) for manipulating <p> elements. */
8024 interface HTMLParagraphElement extends HTMLElement {
8025     /**
8026      * Sets or retrieves how the object is aligned with adjacent text.
8027      */
8028     /** @deprecated */
8029     align: string;
8030     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLParagraphElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8031     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8032     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLParagraphElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8033     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8034 }
8035
8036 declare var HTMLParagraphElement: {
8037     prototype: HTMLParagraphElement;
8038     new(): HTMLParagraphElement;
8039 };
8040
8041 /** 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. */
8042 interface HTMLParamElement extends HTMLElement {
8043     /**
8044      * Sets or retrieves the name of an input parameter for an element.
8045      */
8046     name: string;
8047     /**
8048      * Sets or retrieves the content type of the resource designated by the value attribute.
8049      */
8050     /** @deprecated */
8051     type: string;
8052     /**
8053      * Sets or retrieves the value of an input parameter for an element.
8054      */
8055     value: string;
8056     /**
8057      * Sets or retrieves the data type of the value attribute.
8058      */
8059     /** @deprecated */
8060     valueType: string;
8061     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLParamElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8062     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8063     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLParamElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8064     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8065 }
8066
8067 declare var HTMLParamElement: {
8068     prototype: HTMLParamElement;
8069     new(): HTMLParamElement;
8070 };
8071
8072 /** A <picture> HTML element. It doesn't implement specific properties or methods. */
8073 interface HTMLPictureElement extends HTMLElement {
8074     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLPictureElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8075     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8076     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLPictureElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8077     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8078 }
8079
8080 declare var HTMLPictureElement: {
8081     prototype: HTMLPictureElement;
8082     new(): HTMLPictureElement;
8083 };
8084
8085 /** 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>). */
8086 interface HTMLPreElement extends HTMLElement {
8087     /**
8088      * Sets or gets a value that you can use to implement your own width functionality for the object.
8089      */
8090     /** @deprecated */
8091     width: number;
8092     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLPreElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8093     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8094     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLPreElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8095     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8096 }
8097
8098 declare var HTMLPreElement: {
8099     prototype: HTMLPreElement;
8100     new(): HTMLPreElement;
8101 };
8102
8103 /** 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. */
8104 interface HTMLProgressElement extends HTMLElement {
8105     readonly labels: NodeListOf<HTMLLabelElement>;
8106     /**
8107      * Defines the maximum, or "done" value for a progress element.
8108      */
8109     max: number;
8110     /**
8111      * 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).
8112      */
8113     readonly position: number;
8114     /**
8115      * Sets or gets the current value of a progress element. The value must be a non-negative number between 0 and the max value.
8116      */
8117     value: number;
8118     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLProgressElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8119     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8120     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLProgressElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8121     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8122 }
8123
8124 declare var HTMLProgressElement: {
8125     prototype: HTMLProgressElement;
8126     new(): HTMLProgressElement;
8127 };
8128
8129 /** 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. */
8130 interface HTMLQuoteElement extends HTMLElement {
8131     /**
8132      * Sets or retrieves reference information about the object.
8133      */
8134     cite: string;
8135     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLQuoteElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8136     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8137     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLQuoteElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8138     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8139 }
8140
8141 declare var HTMLQuoteElement: {
8142     prototype: HTMLQuoteElement;
8143     new(): HTMLQuoteElement;
8144 };
8145
8146 /** 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). */
8147 interface HTMLScriptElement extends HTMLElement {
8148     async: boolean;
8149     /**
8150      * Sets or retrieves the character set used to encode the object.
8151      */
8152     /** @deprecated */
8153     charset: string;
8154     crossOrigin: string | null;
8155     /**
8156      * Sets or retrieves the status of the script.
8157      */
8158     defer: boolean;
8159     /**
8160      * Sets or retrieves the event for which the script is written.
8161      */
8162     /** @deprecated */
8163     event: string;
8164     /**
8165      * Sets or retrieves the object that is bound to the event script.
8166      */
8167     /** @deprecated */
8168     htmlFor: string;
8169     integrity: string;
8170     noModule: boolean;
8171     referrerPolicy: string;
8172     /**
8173      * Retrieves the URL to an external file that contains the source code or data.
8174      */
8175     src: string;
8176     /**
8177      * Retrieves or sets the text of the object as a string.
8178      */
8179     text: string;
8180     /**
8181      * Sets or retrieves the MIME type for the associated scripting engine.
8182      */
8183     type: string;
8184     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLScriptElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8185     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8186     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLScriptElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8187     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8188 }
8189
8190 declare var HTMLScriptElement: {
8191     prototype: HTMLScriptElement;
8192     new(): HTMLScriptElement;
8193 };
8194
8195 /** A <select> HTML Element. These elements also share all of the properties and methods of other HTML elements via the HTMLElement interface. */
8196 interface HTMLSelectElement extends HTMLElement {
8197     autocomplete: string;
8198     disabled: boolean;
8199     /**
8200      * Retrieves a reference to the form that the object is embedded in.
8201      */
8202     readonly form: HTMLFormElement | null;
8203     readonly labels: NodeListOf<HTMLLabelElement>;
8204     /**
8205      * Sets or retrieves the number of objects in a collection.
8206      */
8207     length: number;
8208     /**
8209      * Sets or retrieves the Boolean value indicating whether multiple items can be selected from a list.
8210      */
8211     multiple: boolean;
8212     /**
8213      * Sets or retrieves the name of the object.
8214      */
8215     name: string;
8216     readonly options: HTMLOptionsCollection;
8217     /**
8218      * When present, marks an element that can't be submitted without a value.
8219      */
8220     required: boolean;
8221     /**
8222      * Sets or retrieves the index of the selected option in a select object.
8223      */
8224     selectedIndex: number;
8225     readonly selectedOptions: HTMLCollectionOf<HTMLOptionElement>;
8226     /**
8227      * Sets or retrieves the number of rows in the list box.
8228      */
8229     size: number;
8230     /**
8231      * Retrieves the type of select control based on the value of the MULTIPLE attribute.
8232      */
8233     readonly type: string;
8234     /**
8235      * 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.
8236      */
8237     readonly validationMessage: string;
8238     /**
8239      * Returns a  ValidityState object that represents the validity states of an element.
8240      */
8241     readonly validity: ValidityState;
8242     /**
8243      * Sets or retrieves the value which is returned to the server when the form control is submitted.
8244      */
8245     value: string;
8246     /**
8247      * Returns whether an element will successfully validate based on forms validation rules and constraints.
8248      */
8249     readonly willValidate: boolean;
8250     /**
8251      * Adds an element to the areas, controlRange, or options collection.
8252      * @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.
8253      * @param before Variant of type Object that specifies an element to insert before, or null to append the object to the collection.
8254      */
8255     add(element: HTMLOptionElement | HTMLOptGroupElement, before?: HTMLElement | number | null): void;
8256     /**
8257      * Returns whether a form will validate when it is submitted, without having to submit it.
8258      */
8259     checkValidity(): boolean;
8260     /**
8261      * Retrieves a select object or an object from an options collection.
8262      * @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.
8263      * @param index Variant of type Number that specifies the zero-based index of the object to retrieve when a collection is returned.
8264      */
8265     item(index: number): Element | null;
8266     /**
8267      * Retrieves a select object or an object from an options collection.
8268      * @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.
8269      */
8270     namedItem(name: string): HTMLOptionElement | null;
8271     /**
8272      * Removes an element from the collection.
8273      * @param index Number that specifies the zero-based index of the element to remove from the collection.
8274      */
8275     remove(): void;
8276     remove(index: number): void;
8277     reportValidity(): boolean;
8278     /**
8279      * Sets a custom error message that is displayed when a form is submitted.
8280      * @param error Sets a custom error message that is displayed when a form is submitted.
8281      */
8282     setCustomValidity(error: string): void;
8283     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLSelectElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8284     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8285     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLSelectElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8286     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8287     [name: number]: HTMLOptionElement | HTMLOptGroupElement;
8288 }
8289
8290 declare var HTMLSelectElement: {
8291     prototype: HTMLSelectElement;
8292     new(): HTMLSelectElement;
8293 };
8294
8295 interface HTMLSlotElement extends HTMLElement {
8296     name: string;
8297     assignedElements(options?: AssignedNodesOptions): Element[];
8298     assignedNodes(options?: AssignedNodesOptions): Node[];
8299     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLSlotElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8300     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8301     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLSlotElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8302     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8303 }
8304
8305 declare var HTMLSlotElement: {
8306     prototype: HTMLSlotElement;
8307     new(): HTMLSlotElement;
8308 };
8309
8310 /** Provides special properties (beyond the regular HTMLElement object interface it also has available to it by inheritance) for manipulating <source> elements. */
8311 interface HTMLSourceElement extends HTMLElement {
8312     /**
8313      * Gets or sets the intended media type of the media source.
8314      */
8315     media: string;
8316     sizes: string;
8317     /**
8318      * The address or URL of the a media resource that is to be considered.
8319      */
8320     src: string;
8321     srcset: string;
8322     /**
8323      * Gets or sets the MIME type of a media resource.
8324      */
8325     type: string;
8326     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLSourceElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8327     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8328     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLSourceElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8329     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8330 }
8331
8332 declare var HTMLSourceElement: {
8333     prototype: HTMLSourceElement;
8334     new(): HTMLSourceElement;
8335 };
8336
8337 /** A <span> element and derives from the HTMLElement interface, but without implementing any additional properties or methods. */
8338 interface HTMLSpanElement extends HTMLElement {
8339     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLSpanElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8340     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8341     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLSpanElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8342     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8343 }
8344
8345 declare var HTMLSpanElement: {
8346     prototype: HTMLSpanElement;
8347     new(): HTMLSpanElement;
8348 };
8349
8350 /** A <style> element. It inherits properties and methods from its parent, HTMLElement, and from LinkStyle. */
8351 interface HTMLStyleElement extends HTMLElement, LinkStyle {
8352     /**
8353      * Sets or retrieves the media type.
8354      */
8355     media: string;
8356     /**
8357      * Retrieves the CSS language in which the style sheet is written.
8358      */
8359     /** @deprecated */
8360     type: string;
8361     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLStyleElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8362     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8363     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLStyleElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8364     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8365 }
8366
8367 declare var HTMLStyleElement: {
8368     prototype: HTMLStyleElement;
8369     new(): HTMLStyleElement;
8370 };
8371
8372 /** Special properties (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating table caption elements. */
8373 interface HTMLTableCaptionElement extends HTMLElement {
8374     /**
8375      * Sets or retrieves the alignment of the caption or legend.
8376      */
8377     /** @deprecated */
8378     align: string;
8379     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableCaptionElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8380     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8381     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableCaptionElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8382     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8383 }
8384
8385 declare var HTMLTableCaptionElement: {
8386     prototype: HTMLTableCaptionElement;
8387     new(): HTMLTableCaptionElement;
8388 };
8389
8390 /** 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. */
8391 interface HTMLTableCellElement extends HTMLElement {
8392     /**
8393      * Sets or retrieves abbreviated text for the object.
8394      */
8395     abbr: string;
8396     /**
8397      * Sets or retrieves how the object is aligned with adjacent text.
8398      */
8399     /** @deprecated */
8400     align: string;
8401     /**
8402      * Sets or retrieves a comma-delimited list of conceptual categories associated with the object.
8403      */
8404     /** @deprecated */
8405     axis: string;
8406     /** @deprecated */
8407     bgColor: string;
8408     /**
8409      * Retrieves the position of the object in the cells collection of a row.
8410      */
8411     readonly cellIndex: number;
8412     /** @deprecated */
8413     ch: string;
8414     /** @deprecated */
8415     chOff: string;
8416     /**
8417      * Sets or retrieves the number columns in the table that the object should span.
8418      */
8419     colSpan: number;
8420     /**
8421      * Sets or retrieves a list of header cells that provide information for the object.
8422      */
8423     headers: string;
8424     /**
8425      * Sets or retrieves the height of the object.
8426      */
8427     /** @deprecated */
8428     height: string;
8429     /**
8430      * Sets or retrieves whether the browser automatically performs wordwrap.
8431      */
8432     /** @deprecated */
8433     noWrap: boolean;
8434     /**
8435      * Sets or retrieves how many rows in a table the cell should span.
8436      */
8437     rowSpan: number;
8438     /**
8439      * Sets or retrieves the group of cells in a table to which the object's information applies.
8440      */
8441     scope: string;
8442     /** @deprecated */
8443     vAlign: string;
8444     /**
8445      * Sets or retrieves the width of the object.
8446      */
8447     /** @deprecated */
8448     width: string;
8449     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableCellElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8450     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8451     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableCellElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8452     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8453 }
8454
8455 declare var HTMLTableCellElement: {
8456     prototype: HTMLTableCellElement;
8457     new(): HTMLTableCellElement;
8458 };
8459
8460 /** Provides special properties (beyond the HTMLElement interface it also has available to it inheritance) for manipulating single or grouped table column elements. */
8461 interface HTMLTableColElement extends HTMLElement {
8462     /**
8463      * Sets or retrieves the alignment of the object relative to the display or table.
8464      */
8465     /** @deprecated */
8466     align: string;
8467     /** @deprecated */
8468     ch: string;
8469     /** @deprecated */
8470     chOff: string;
8471     /**
8472      * Sets or retrieves the number of columns in the group.
8473      */
8474     span: number;
8475     /** @deprecated */
8476     vAlign: string;
8477     /**
8478      * Sets or retrieves the width of the object.
8479      */
8480     /** @deprecated */
8481     width: string;
8482     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableColElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8483     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8484     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableColElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8485     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8486 }
8487
8488 declare var HTMLTableColElement: {
8489     prototype: HTMLTableColElement;
8490     new(): HTMLTableColElement;
8491 };
8492
8493 interface HTMLTableDataCellElement extends HTMLTableCellElement {
8494     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableDataCellElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8495     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8496     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableDataCellElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8497     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8498 }
8499
8500 declare var HTMLTableDataCellElement: {
8501     prototype: HTMLTableDataCellElement;
8502     new(): HTMLTableDataCellElement;
8503 };
8504
8505 /** 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. */
8506 interface HTMLTableElement extends HTMLElement {
8507     /**
8508      * Sets or retrieves a value that indicates the table alignment.
8509      */
8510     /** @deprecated */
8511     align: string;
8512     /** @deprecated */
8513     bgColor: string;
8514     /**
8515      * Sets or retrieves the width of the border to draw around the object.
8516      */
8517     /** @deprecated */
8518     border: string;
8519     /**
8520      * Retrieves the caption object of a table.
8521      */
8522     caption: HTMLTableCaptionElement | null;
8523     /**
8524      * Sets or retrieves the amount of space between the border of the cell and the content of the cell.
8525      */
8526     /** @deprecated */
8527     cellPadding: string;
8528     /**
8529      * Sets or retrieves the amount of space between cells in a table.
8530      */
8531     /** @deprecated */
8532     cellSpacing: string;
8533     /**
8534      * Sets or retrieves the way the border frame around the table is displayed.
8535      */
8536     /** @deprecated */
8537     frame: string;
8538     /**
8539      * Sets or retrieves the number of horizontal rows contained in the object.
8540      */
8541     readonly rows: HTMLCollectionOf<HTMLTableRowElement>;
8542     /**
8543      * Sets or retrieves which dividing lines (inner borders) are displayed.
8544      */
8545     /** @deprecated */
8546     rules: string;
8547     /**
8548      * Sets or retrieves a description and/or structure of the object.
8549      */
8550     /** @deprecated */
8551     summary: string;
8552     /**
8553      * Retrieves a collection of all tBody objects in the table. Objects in this collection are in source order.
8554      */
8555     readonly tBodies: HTMLCollectionOf<HTMLTableSectionElement>;
8556     /**
8557      * Retrieves the tFoot object of the table.
8558      */
8559     tFoot: HTMLTableSectionElement | null;
8560     /**
8561      * Retrieves the tHead object of the table.
8562      */
8563     tHead: HTMLTableSectionElement | null;
8564     /**
8565      * Sets or retrieves the width of the object.
8566      */
8567     /** @deprecated */
8568     width: string;
8569     /**
8570      * Creates an empty caption element in the table.
8571      */
8572     createCaption(): HTMLTableCaptionElement;
8573     /**
8574      * Creates an empty tBody element in the table.
8575      */
8576     createTBody(): HTMLTableSectionElement;
8577     /**
8578      * Creates an empty tFoot element in the table.
8579      */
8580     createTFoot(): HTMLTableSectionElement;
8581     /**
8582      * Returns the tHead element object if successful, or null otherwise.
8583      */
8584     createTHead(): HTMLTableSectionElement;
8585     /**
8586      * Deletes the caption element and its contents from the table.
8587      */
8588     deleteCaption(): void;
8589     /**
8590      * Removes the specified row (tr) from the element and from the rows collection.
8591      * @param index Number that specifies the zero-based position in the rows collection of the row to remove.
8592      */
8593     deleteRow(index: number): void;
8594     /**
8595      * Deletes the tFoot element and its contents from the table.
8596      */
8597     deleteTFoot(): void;
8598     /**
8599      * Deletes the tHead element and its contents from the table.
8600      */
8601     deleteTHead(): void;
8602     /**
8603      * Creates a new row (tr) in the table, and adds the row to the rows collection.
8604      * @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.
8605      */
8606     insertRow(index?: number): HTMLTableRowElement;
8607     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8608     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8609     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8610     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8611 }
8612
8613 declare var HTMLTableElement: {
8614     prototype: HTMLTableElement;
8615     new(): HTMLTableElement;
8616 };
8617
8618 interface HTMLTableHeaderCellElement extends HTMLTableCellElement {
8619     scope: string;
8620     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableHeaderCellElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8621     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8622     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableHeaderCellElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8623     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8624 }
8625
8626 declare var HTMLTableHeaderCellElement: {
8627     prototype: HTMLTableHeaderCellElement;
8628     new(): HTMLTableHeaderCellElement;
8629 };
8630
8631 /** 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. */
8632 interface HTMLTableRowElement extends HTMLElement {
8633     /**
8634      * Sets or retrieves how the object is aligned with adjacent text.
8635      */
8636     /** @deprecated */
8637     align: string;
8638     /** @deprecated */
8639     bgColor: string;
8640     /**
8641      * Retrieves a collection of all cells in the table row.
8642      */
8643     readonly cells: HTMLCollectionOf<HTMLTableDataCellElement | HTMLTableHeaderCellElement>;
8644     /** @deprecated */
8645     ch: string;
8646     /** @deprecated */
8647     chOff: string;
8648     /**
8649      * Retrieves the position of the object in the rows collection for the table.
8650      */
8651     readonly rowIndex: number;
8652     /**
8653      * Retrieves the position of the object in the collection.
8654      */
8655     readonly sectionRowIndex: number;
8656     /** @deprecated */
8657     vAlign: string;
8658     /**
8659      * Removes the specified cell from the table row, as well as from the cells collection.
8660      * @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.
8661      */
8662     deleteCell(index: number): void;
8663     /**
8664      * Creates a new cell in the table row, and adds the cell to the cells collection.
8665      * @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.
8666      */
8667     insertCell(index?: number): HTMLTableDataCellElement;
8668     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableRowElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8669     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8670     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableRowElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8671     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8672 }
8673
8674 declare var HTMLTableRowElement: {
8675     prototype: HTMLTableRowElement;
8676     new(): HTMLTableRowElement;
8677 };
8678
8679 /** 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. */
8680 interface HTMLTableSectionElement extends HTMLElement {
8681     /**
8682      * Sets or retrieves a value that indicates the table alignment.
8683      */
8684     /** @deprecated */
8685     align: string;
8686     /** @deprecated */
8687     ch: string;
8688     /** @deprecated */
8689     chOff: string;
8690     /**
8691      * Sets or retrieves the number of horizontal rows contained in the object.
8692      */
8693     readonly rows: HTMLCollectionOf<HTMLTableRowElement>;
8694     /** @deprecated */
8695     vAlign: string;
8696     /**
8697      * Removes the specified row (tr) from the element and from the rows collection.
8698      * @param index Number that specifies the zero-based position in the rows collection of the row to remove.
8699      */
8700     deleteRow(index: number): void;
8701     /**
8702      * Creates a new row (tr) in the table, and adds the row to the rows collection.
8703      * @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.
8704      */
8705     insertRow(index?: number): HTMLTableRowElement;
8706     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableSectionElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8707     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8708     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableSectionElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8709     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8710 }
8711
8712 declare var HTMLTableSectionElement: {
8713     prototype: HTMLTableSectionElement;
8714     new(): HTMLTableSectionElement;
8715 };
8716
8717 /** Enables access to the contents of an HTML <template> element. */
8718 interface HTMLTemplateElement extends HTMLElement {
8719     readonly content: DocumentFragment;
8720     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTemplateElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8721     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8722     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTemplateElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8723     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8724 }
8725
8726 declare var HTMLTemplateElement: {
8727     prototype: HTMLTemplateElement;
8728     new(): HTMLTemplateElement;
8729 };
8730
8731 /** Provides special properties and methods for manipulating the layout and presentation of <textarea> elements. */
8732 interface HTMLTextAreaElement extends HTMLElement {
8733     autocomplete: string;
8734     /**
8735      * Sets or retrieves the width of the object.
8736      */
8737     cols: number;
8738     /**
8739      * Sets or retrieves the initial contents of the object.
8740      */
8741     defaultValue: string;
8742     dirName: string;
8743     disabled: boolean;
8744     /**
8745      * Retrieves a reference to the form that the object is embedded in.
8746      */
8747     readonly form: HTMLFormElement | null;
8748     readonly labels: NodeListOf<HTMLLabelElement>;
8749     /**
8750      * Sets or retrieves the maximum number of characters that the user can enter in a text control.
8751      */
8752     maxLength: number;
8753     minLength: number;
8754     /**
8755      * Sets or retrieves the name of the object.
8756      */
8757     name: string;
8758     /**
8759      * 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.
8760      */
8761     placeholder: string;
8762     /**
8763      * Sets or retrieves the value indicated whether the content of the object is read-only.
8764      */
8765     readOnly: boolean;
8766     /**
8767      * When present, marks an element that can't be submitted without a value.
8768      */
8769     required: boolean;
8770     /**
8771      * Sets or retrieves the number of horizontal rows contained in the object.
8772      */
8773     rows: number;
8774     selectionDirection: "forward" | "backward" | "none";
8775     /**
8776      * Gets or sets the end position or offset of a text selection.
8777      */
8778     selectionEnd: number;
8779     /**
8780      * Gets or sets the starting position or offset of a text selection.
8781      */
8782     selectionStart: number;
8783     readonly textLength: number;
8784     /**
8785      * Retrieves the type of control.
8786      */
8787     readonly type: string;
8788     /**
8789      * 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.
8790      */
8791     readonly validationMessage: string;
8792     /**
8793      * Returns a  ValidityState object that represents the validity states of an element.
8794      */
8795     readonly validity: ValidityState;
8796     /**
8797      * Retrieves or sets the text in the entry field of the textArea element.
8798      */
8799     value: string;
8800     /**
8801      * Returns whether an element will successfully validate based on forms validation rules and constraints.
8802      */
8803     readonly willValidate: boolean;
8804     /**
8805      * Sets or retrieves how to handle wordwrapping in the object.
8806      */
8807     wrap: string;
8808     /**
8809      * Returns whether a form will validate when it is submitted, without having to submit it.
8810      */
8811     checkValidity(): boolean;
8812     reportValidity(): boolean;
8813     /**
8814      * Highlights the input area of a form element.
8815      */
8816     select(): void;
8817     /**
8818      * Sets a custom error message that is displayed when a form is submitted.
8819      * @param error Sets a custom error message that is displayed when a form is submitted.
8820      */
8821     setCustomValidity(error: string): void;
8822     setRangeText(replacement: string): void;
8823     setRangeText(replacement: string, start: number, end: number, selectionMode?: SelectionMode): void;
8824     /**
8825      * Sets the start and end positions of a selection in a text field.
8826      * @param start The offset into the text field for the start of the selection.
8827      * @param end The offset into the text field for the end of the selection.
8828      * @param direction The direction in which the selection is performed.
8829      */
8830     setSelectionRange(start: number, end: number, direction?: "forward" | "backward" | "none"): void;
8831     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTextAreaElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8832     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8833     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTextAreaElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8834     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8835 }
8836
8837 declare var HTMLTextAreaElement: {
8838     prototype: HTMLTextAreaElement;
8839     new(): HTMLTextAreaElement;
8840 };
8841
8842 /** Provides special properties (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating <time> elements. */
8843 interface HTMLTimeElement extends HTMLElement {
8844     dateTime: string;
8845     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTimeElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8846     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8847     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTimeElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8848     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8849 }
8850
8851 declare var HTMLTimeElement: {
8852     prototype: HTMLTimeElement;
8853     new(): HTMLTimeElement;
8854 };
8855
8856 /** Contains the title for a document. This element inherits all of the properties and methods of the HTMLElement interface. */
8857 interface HTMLTitleElement extends HTMLElement {
8858     /**
8859      * Retrieves or sets the text of the object as a string.
8860      */
8861     text: string;
8862     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTitleElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8863     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8864     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTitleElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8865     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8866 }
8867
8868 declare var HTMLTitleElement: {
8869     prototype: HTMLTitleElement;
8870     new(): HTMLTitleElement;
8871 };
8872
8873 /** The HTMLTrackElement */
8874 interface HTMLTrackElement extends HTMLElement {
8875     default: boolean;
8876     kind: string;
8877     label: string;
8878     readonly readyState: number;
8879     src: string;
8880     srclang: string;
8881     readonly track: TextTrack;
8882     readonly ERROR: number;
8883     readonly LOADED: number;
8884     readonly LOADING: number;
8885     readonly NONE: number;
8886     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTrackElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8887     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8888     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTrackElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8889     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8890 }
8891
8892 declare var HTMLTrackElement: {
8893     prototype: HTMLTrackElement;
8894     new(): HTMLTrackElement;
8895     readonly ERROR: number;
8896     readonly LOADED: number;
8897     readonly LOADING: number;
8898     readonly NONE: number;
8899 };
8900
8901 /** Provides special properties (beyond those defined on the regular HTMLElement interface it also has available to it by inheritance) for manipulating unordered list elements. */
8902 interface HTMLUListElement extends HTMLElement {
8903     /** @deprecated */
8904     compact: boolean;
8905     /** @deprecated */
8906     type: string;
8907     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLUListElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8908     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8909     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLUListElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8910     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8911 }
8912
8913 declare var HTMLUListElement: {
8914     prototype: HTMLUListElement;
8915     new(): HTMLUListElement;
8916 };
8917
8918 /** An invalid HTML element and derives from the HTMLElement interface, but without implementing any additional properties or methods. */
8919 interface HTMLUnknownElement extends HTMLElement {
8920     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLUnknownElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8921     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8922     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLUnknownElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8923     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8924 }
8925
8926 declare var HTMLUnknownElement: {
8927     prototype: HTMLUnknownElement;
8928     new(): HTMLUnknownElement;
8929 };
8930
8931 /** Provides special properties and methods for manipulating video objects. It also inherits properties and methods of HTMLMediaElement and HTMLElement. */
8932 interface HTMLVideoElement extends HTMLMediaElement {
8933     /**
8934      * Gets or sets the height of the video element.
8935      */
8936     height: number;
8937     /**
8938      * 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.
8939      */
8940     poster: string;
8941     /**
8942      * Gets the intrinsic height of a video in CSS pixels, or zero if the dimensions are not known.
8943      */
8944     readonly videoHeight: number;
8945     /**
8946      * Gets the intrinsic width of a video in CSS pixels, or zero if the dimensions are not known.
8947      */
8948     readonly videoWidth: number;
8949     /**
8950      * Gets or sets the width of the video element.
8951      */
8952     width: number;
8953     getVideoPlaybackQuality(): VideoPlaybackQuality;
8954     addEventListener<K extends keyof HTMLMediaElementEventMap>(type: K, listener: (this: HTMLVideoElement, ev: HTMLMediaElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8955     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8956     removeEventListener<K extends keyof HTMLMediaElementEventMap>(type: K, listener: (this: HTMLVideoElement, ev: HTMLMediaElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8957     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8958 }
8959
8960 declare var HTMLVideoElement: {
8961     prototype: HTMLVideoElement;
8962     new(): HTMLVideoElement;
8963 };
8964
8965 /** Events that fire when the fragment identifier of the URL has changed. */
8966 interface HashChangeEvent extends Event {
8967     /**
8968      * Returns the URL of the session history entry that is now current.
8969      */
8970     readonly newURL: string;
8971     /**
8972      * Returns the URL of the session history entry that was previously current.
8973      */
8974     readonly oldURL: string;
8975 }
8976
8977 declare var HashChangeEvent: {
8978     prototype: HashChangeEvent;
8979     new(type: string, eventInitDict?: HashChangeEventInit): HashChangeEvent;
8980 };
8981
8982 /** 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. */
8983 interface Headers {
8984     append(name: string, value: string): void;
8985     delete(name: string): void;
8986     get(name: string): string | null;
8987     has(name: string): boolean;
8988     set(name: string, value: string): void;
8989     forEach(callbackfn: (value: string, key: string, parent: Headers) => void, thisArg?: any): void;
8990 }
8991
8992 declare var Headers: {
8993     prototype: Headers;
8994     new(init?: HeadersInit): Headers;
8995 };
8996
8997 /** Allows manipulation of the browser session history, that is the pages visited in the tab or frame that the current page is loaded in. */
8998 interface History {
8999     readonly length: number;
9000     scrollRestoration: ScrollRestoration;
9001     readonly state: any;
9002     back(): void;
9003     forward(): void;
9004     go(delta?: number): void;
9005     pushState(data: any, title: string, url?: string | null): void;
9006     replaceState(data: any, title: string, url?: string | null): void;
9007 }
9008
9009 declare var History: {
9010     prototype: History;
9011     new(): History;
9012 };
9013
9014 interface HkdfCtrParams extends Algorithm {
9015     context: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;
9016     hash: string | Algorithm;
9017     label: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;
9018 }
9019
9020 interface IDBArrayKey extends Array<IDBValidKey> {
9021 }
9022
9023 /** This IndexedDB API interface represents a cursor for traversing or iterating over multiple records in a database. */
9024 interface IDBCursor {
9025     /**
9026      * Returns the direction ("next", "nextunique", "prev" or "prevunique") of the cursor.
9027      */
9028     readonly direction: IDBCursorDirection;
9029     /**
9030      * Returns the key of the cursor. Throws a "InvalidStateError" DOMException if the cursor is advancing or is finished.
9031      */
9032     readonly key: IDBValidKey;
9033     /**
9034      * Returns the effective key of the cursor. Throws a "InvalidStateError" DOMException if the cursor is advancing or is finished.
9035      */
9036     readonly primaryKey: IDBValidKey;
9037     /**
9038      * Returns the IDBObjectStore or IDBIndex the cursor was opened from.
9039      */
9040     readonly source: IDBObjectStore | IDBIndex;
9041     /**
9042      * Advances the cursor through the next count records in range.
9043      */
9044     advance(count: number): void;
9045     /**
9046      * Advances the cursor to the next record in range.
9047      */
9048     continue(key?: IDBValidKey): void;
9049     /**
9050      * 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.
9051      */
9052     continuePrimaryKey(key: IDBValidKey, primaryKey: IDBValidKey): void;
9053     /**
9054      * Delete the record pointed at by the cursor with a new value.
9055      *
9056      * If successful, request's result will be undefined.
9057      */
9058     delete(): IDBRequest<undefined>;
9059     /**
9060      * Updated the record pointed at by the cursor with a new value.
9061      *
9062      * Throws a "DataError" DOMException if the effective object store uses in-line keys and the key would have changed.
9063      *
9064      * If successful, request's result will be the record's key.
9065      */
9066     update(value: any): IDBRequest<IDBValidKey>;
9067 }
9068
9069 declare var IDBCursor: {
9070     prototype: IDBCursor;
9071     new(): IDBCursor;
9072 };
9073
9074 /** 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. */
9075 interface IDBCursorWithValue extends IDBCursor {
9076     /**
9077      * Returns the cursor's current value.
9078      */
9079     readonly value: any;
9080 }
9081
9082 declare var IDBCursorWithValue: {
9083     prototype: IDBCursorWithValue;
9084     new(): IDBCursorWithValue;
9085 };
9086
9087 interface IDBDatabaseEventMap {
9088     "abort": Event;
9089     "close": Event;
9090     "error": Event;
9091     "versionchange": IDBVersionChangeEvent;
9092 }
9093
9094 /** 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. */
9095 interface IDBDatabase extends EventTarget {
9096     /**
9097      * Returns the name of the database.
9098      */
9099     readonly name: string;
9100     /**
9101      * Returns a list of the names of object stores in the database.
9102      */
9103     readonly objectStoreNames: DOMStringList;
9104     onabort: ((this: IDBDatabase, ev: Event) => any) | null;
9105     onclose: ((this: IDBDatabase, ev: Event) => any) | null;
9106     onerror: ((this: IDBDatabase, ev: Event) => any) | null;
9107     onversionchange: ((this: IDBDatabase, ev: IDBVersionChangeEvent) => any) | null;
9108     /**
9109      * Returns the version of the database.
9110      */
9111     readonly version: number;
9112     /**
9113      * Closes the connection once all running transactions have finished.
9114      */
9115     close(): void;
9116     /**
9117      * Creates a new object store with the given name and options and returns a new IDBObjectStore.
9118      *
9119      * Throws a "InvalidStateError" DOMException if not called within an upgrade transaction.
9120      */
9121     createObjectStore(name: string, optionalParameters?: IDBObjectStoreParameters): IDBObjectStore;
9122     /**
9123      * Deletes the object store with the given name.
9124      *
9125      * Throws a "InvalidStateError" DOMException if not called within an upgrade transaction.
9126      */
9127     deleteObjectStore(name: string): void;
9128     /**
9129      * 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.
9130      */
9131     transaction(storeNames: string | string[], mode?: IDBTransactionMode): IDBTransaction;
9132     addEventListener<K extends keyof IDBDatabaseEventMap>(type: K, listener: (this: IDBDatabase, ev: IDBDatabaseEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9133     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9134     removeEventListener<K extends keyof IDBDatabaseEventMap>(type: K, listener: (this: IDBDatabase, ev: IDBDatabaseEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9135     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9136 }
9137
9138 declare var IDBDatabase: {
9139     prototype: IDBDatabase;
9140     new(): IDBDatabase;
9141 };
9142
9143 /** 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.) */
9144 interface IDBFactory {
9145     /**
9146      * Compares two values as keys. Returns -1 if key1 precedes key2, 1 if key2 precedes key1, and 0 if the keys are equal.
9147      *
9148      * Throws a "DataError" DOMException if either input is not a valid key.
9149      */
9150     cmp(first: any, second: any): number;
9151     /**
9152      * 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.
9153      */
9154     deleteDatabase(name: string): IDBOpenDBRequest;
9155     /**
9156      * 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.
9157      */
9158     open(name: string, version?: number): IDBOpenDBRequest;
9159 }
9160
9161 declare var IDBFactory: {
9162     prototype: IDBFactory;
9163     new(): IDBFactory;
9164 };
9165
9166 /** 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. */
9167 interface IDBIndex {
9168     readonly keyPath: string | string[];
9169     readonly multiEntry: boolean;
9170     /**
9171      * Returns the name of the index.
9172      */
9173     name: string;
9174     /**
9175      * Returns the IDBObjectStore the index belongs to.
9176      */
9177     readonly objectStore: IDBObjectStore;
9178     readonly unique: boolean;
9179     /**
9180      * Retrieves the number of records matching the given key or key range in query.
9181      *
9182      * If successful, request's result will be the count.
9183      */
9184     count(key?: IDBValidKey | IDBKeyRange): IDBRequest<number>;
9185     /**
9186      * Retrieves the value of the first record matching the given key or key range in query.
9187      *
9188      * If successful, request's result will be the value, or undefined if there was no matching record.
9189      */
9190     get(key: IDBValidKey | IDBKeyRange): IDBRequest<any | undefined>;
9191     /**
9192      * Retrieves the values of the records matching the given key or key range in query (up to count if given).
9193      *
9194      * If successful, request's result will be an Array of the values.
9195      */
9196     getAll(query?: IDBValidKey | IDBKeyRange | null, count?: number): IDBRequest<any[]>;
9197     /**
9198      * Retrieves the keys of records matching the given key or key range in query (up to count if given).
9199      *
9200      * If successful, request's result will be an Array of the keys.
9201      */
9202     getAllKeys(query?: IDBValidKey | IDBKeyRange | null, count?: number): IDBRequest<IDBValidKey[]>;
9203     /**
9204      * Retrieves the key of the first record matching the given key or key range in query.
9205      *
9206      * If successful, request's result will be the key, or undefined if there was no matching record.
9207      */
9208     getKey(key: IDBValidKey | IDBKeyRange): IDBRequest<IDBValidKey | undefined>;
9209     /**
9210      * Opens a cursor over the records matching query, ordered by direction. If query is null, all records in index are matched.
9211      *
9212      * If successful, request's result will be an IDBCursorWithValue, or null if there were no matching records.
9213      */
9214     openCursor(query?: IDBValidKey | IDBKeyRange | null, direction?: IDBCursorDirection): IDBRequest<IDBCursorWithValue | null>;
9215     /**
9216      * 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.
9217      *
9218      * If successful, request's result will be an IDBCursor, or null if there were no matching records.
9219      */
9220     openKeyCursor(query?: IDBValidKey | IDBKeyRange | null, direction?: IDBCursorDirection): IDBRequest<IDBCursor | null>;
9221 }
9222
9223 declare var IDBIndex: {
9224     prototype: IDBIndex;
9225     new(): IDBIndex;
9226 };
9227
9228 /** 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: */
9229 interface IDBKeyRange {
9230     /**
9231      * Returns lower bound, or undefined if none.
9232      */
9233     readonly lower: any;
9234     /**
9235      * Returns true if the lower open flag is set, and false otherwise.
9236      */
9237     readonly lowerOpen: boolean;
9238     /**
9239      * Returns upper bound, or undefined if none.
9240      */
9241     readonly upper: any;
9242     /**
9243      * Returns true if the upper open flag is set, and false otherwise.
9244      */
9245     readonly upperOpen: boolean;
9246     /**
9247      * Returns true if key is included in the range, and false otherwise.
9248      */
9249     includes(key: any): boolean;
9250 }
9251
9252 declare var IDBKeyRange: {
9253     prototype: IDBKeyRange;
9254     new(): IDBKeyRange;
9255     /**
9256      * 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.
9257      */
9258     bound(lower: any, upper: any, lowerOpen?: boolean, upperOpen?: boolean): IDBKeyRange;
9259     /**
9260      * Returns a new IDBKeyRange starting at key with no upper bound. If open is true, key is not included in the range.
9261      */
9262     lowerBound(lower: any, open?: boolean): IDBKeyRange;
9263     /**
9264      * Returns a new IDBKeyRange spanning only key.
9265      */
9266     only(value: any): IDBKeyRange;
9267     /**
9268      * Returns a new IDBKeyRange with no lower bound and ending at key. If open is true, key is not included in the range.
9269      */
9270     upperBound(upper: any, open?: boolean): IDBKeyRange;
9271 };
9272
9273 /** 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.) */
9274 interface IDBObjectStore {
9275     /**
9276      * Returns true if the store has a key generator, and false otherwise.
9277      */
9278     readonly autoIncrement: boolean;
9279     /**
9280      * Returns a list of the names of indexes in the store.
9281      */
9282     readonly indexNames: DOMStringList;
9283     /**
9284      * Returns the key path of the store, or null if none.
9285      */
9286     readonly keyPath: string | string[];
9287     /**
9288      * Returns the name of the store.
9289      */
9290     name: string;
9291     /**
9292      * Returns the associated transaction.
9293      */
9294     readonly transaction: IDBTransaction;
9295     /**
9296      * Adds or updates a record in store with the given value and key.
9297      *
9298      * If the store uses in-line keys and key is specified a "DataError" DOMException will be thrown.
9299      *
9300      * 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.
9301      *
9302      * If successful, request's result will be the record's key.
9303      */
9304     add(value: any, key?: IDBValidKey): IDBRequest<IDBValidKey>;
9305     /**
9306      * Deletes all records in store.
9307      *
9308      * If successful, request's result will be undefined.
9309      */
9310     clear(): IDBRequest<undefined>;
9311     /**
9312      * Retrieves the number of records matching the given key or key range in query.
9313      *
9314      * If successful, request's result will be the count.
9315      */
9316     count(key?: IDBValidKey | IDBKeyRange): IDBRequest<number>;
9317     /**
9318      * 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.
9319      *
9320      * Throws an "InvalidStateError" DOMException if not called within an upgrade transaction.
9321      */
9322     createIndex(name: string, keyPath: string | string[], options?: IDBIndexParameters): IDBIndex;
9323     /**
9324      * Deletes records in store with the given key or in the given key range in query.
9325      *
9326      * If successful, request's result will be undefined.
9327      */
9328     delete(key: IDBValidKey | IDBKeyRange): IDBRequest<undefined>;
9329     /**
9330      * Deletes the index in store with the given name.
9331      *
9332      * Throws an "InvalidStateError" DOMException if not called within an upgrade transaction.
9333      */
9334     deleteIndex(name: string): void;
9335     /**
9336      * Retrieves the value of the first record matching the given key or key range in query.
9337      *
9338      * If successful, request's result will be the value, or undefined if there was no matching record.
9339      */
9340     get(query: IDBValidKey | IDBKeyRange): IDBRequest<any | undefined>;
9341     /**
9342      * Retrieves the values of the records matching the given key or key range in query (up to count if given).
9343      *
9344      * If successful, request's result will be an Array of the values.
9345      */
9346     getAll(query?: IDBValidKey | IDBKeyRange | null, count?: number): IDBRequest<any[]>;
9347     /**
9348      * Retrieves the keys of records matching the given key or key range in query (up to count if given).
9349      *
9350      * If successful, request's result will be an Array of the keys.
9351      */
9352     getAllKeys(query?: IDBValidKey | IDBKeyRange | null, count?: number): IDBRequest<IDBValidKey[]>;
9353     /**
9354      * Retrieves the key of the first record matching the given key or key range in query.
9355      *
9356      * If successful, request's result will be the key, or undefined if there was no matching record.
9357      */
9358     getKey(query: IDBValidKey | IDBKeyRange): IDBRequest<IDBValidKey | undefined>;
9359     index(name: string): IDBIndex;
9360     /**
9361      * Opens a cursor over the records matching query, ordered by direction. If query is null, all records in store are matched.
9362      *
9363      * If successful, request's result will be an IDBCursorWithValue pointing at the first matching record, or null if there were no matching records.
9364      */
9365     openCursor(query?: IDBValidKey | IDBKeyRange | null, direction?: IDBCursorDirection): IDBRequest<IDBCursorWithValue | null>;
9366     /**
9367      * 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.
9368      *
9369      * If successful, request's result will be an IDBCursor pointing at the first matching record, or null if there were no matching records.
9370      */
9371     openKeyCursor(query?: IDBValidKey | IDBKeyRange | null, direction?: IDBCursorDirection): IDBRequest<IDBCursor | null>;
9372     /**
9373      * Adds or updates a record in store with the given value and key.
9374      *
9375      * If the store uses in-line keys and key is specified a "DataError" DOMException will be thrown.
9376      *
9377      * 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.
9378      *
9379      * If successful, request's result will be the record's key.
9380      */
9381     put(value: any, key?: IDBValidKey): IDBRequest<IDBValidKey>;
9382 }
9383
9384 declare var IDBObjectStore: {
9385     prototype: IDBObjectStore;
9386     new(): IDBObjectStore;
9387 };
9388
9389 interface IDBOpenDBRequestEventMap extends IDBRequestEventMap {
9390     "blocked": Event;
9391     "upgradeneeded": IDBVersionChangeEvent;
9392 }
9393
9394 /** Also inherits methods from its parents IDBRequest and EventTarget. */
9395 interface IDBOpenDBRequest extends IDBRequest<IDBDatabase> {
9396     onblocked: ((this: IDBOpenDBRequest, ev: Event) => any) | null;
9397     onupgradeneeded: ((this: IDBOpenDBRequest, ev: IDBVersionChangeEvent) => any) | null;
9398     addEventListener<K extends keyof IDBOpenDBRequestEventMap>(type: K, listener: (this: IDBOpenDBRequest, ev: IDBOpenDBRequestEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9399     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9400     removeEventListener<K extends keyof IDBOpenDBRequestEventMap>(type: K, listener: (this: IDBOpenDBRequest, ev: IDBOpenDBRequestEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9401     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9402 }
9403
9404 declare var IDBOpenDBRequest: {
9405     prototype: IDBOpenDBRequest;
9406     new(): IDBOpenDBRequest;
9407 };
9408
9409 interface IDBRequestEventMap {
9410     "error": Event;
9411     "success": Event;
9412 }
9413
9414 /** 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. */
9415 interface IDBRequest<T = any> extends EventTarget {
9416     /**
9417      * 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.
9418      */
9419     readonly error: DOMException | null;
9420     onerror: ((this: IDBRequest<T>, ev: Event) => any) | null;
9421     onsuccess: ((this: IDBRequest<T>, ev: Event) => any) | null;
9422     /**
9423      * Returns "pending" until a request is complete, then returns "done".
9424      */
9425     readonly readyState: IDBRequestReadyState;
9426     /**
9427      * When a request is completed, returns the result, or undefined if the request failed. Throws a "InvalidStateError" DOMException if the request is still pending.
9428      */
9429     readonly result: T;
9430     /**
9431      * Returns the IDBObjectStore, IDBIndex, or IDBCursor the request was made against, or null if is was an open request.
9432      */
9433     readonly source: IDBObjectStore | IDBIndex | IDBCursor;
9434     /**
9435      * 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.
9436      */
9437     readonly transaction: IDBTransaction | null;
9438     addEventListener<K extends keyof IDBRequestEventMap>(type: K, listener: (this: IDBRequest<T>, ev: IDBRequestEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9439     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9440     removeEventListener<K extends keyof IDBRequestEventMap>(type: K, listener: (this: IDBRequest<T>, ev: IDBRequestEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9441     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9442 }
9443
9444 declare var IDBRequest: {
9445     prototype: IDBRequest;
9446     new(): IDBRequest;
9447 };
9448
9449 interface IDBTransactionEventMap {
9450     "abort": Event;
9451     "complete": Event;
9452     "error": Event;
9453 }
9454
9455 interface IDBTransaction extends EventTarget {
9456     /**
9457      * Returns the transaction's connection.
9458      */
9459     readonly db: IDBDatabase;
9460     /**
9461      * If the transaction was aborted, returns the error (a DOMException) providing the reason.
9462      */
9463     readonly error: DOMException;
9464     /**
9465      * Returns the mode the transaction was created with ("readonly" or "readwrite"), or "versionchange" for an upgrade transaction.
9466      */
9467     readonly mode: IDBTransactionMode;
9468     /**
9469      * 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.
9470      */
9471     readonly objectStoreNames: DOMStringList;
9472     onabort: ((this: IDBTransaction, ev: Event) => any) | null;
9473     oncomplete: ((this: IDBTransaction, ev: Event) => any) | null;
9474     onerror: ((this: IDBTransaction, ev: Event) => any) | null;
9475     /**
9476      * Aborts the transaction. All pending requests will fail with a "AbortError" DOMException and all changes made to the database will be reverted.
9477      */
9478     abort(): void;
9479     /**
9480      * Returns an IDBObjectStore in the transaction's scope.
9481      */
9482     objectStore(name: string): IDBObjectStore;
9483     addEventListener<K extends keyof IDBTransactionEventMap>(type: K, listener: (this: IDBTransaction, ev: IDBTransactionEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9484     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9485     removeEventListener<K extends keyof IDBTransactionEventMap>(type: K, listener: (this: IDBTransaction, ev: IDBTransactionEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9486     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9487 }
9488
9489 declare var IDBTransaction: {
9490     prototype: IDBTransaction;
9491     new(): IDBTransaction;
9492 };
9493
9494 /** This IndexedDB API interface indicates that the version of the database has changed, as the result of an IDBOpenDBRequest.onupgradeneeded event handler function. */
9495 interface IDBVersionChangeEvent extends Event {
9496     readonly newVersion: number | null;
9497     readonly oldVersion: number;
9498 }
9499
9500 declare var IDBVersionChangeEvent: {
9501     prototype: IDBVersionChangeEvent;
9502     new(type: string, eventInitDict?: IDBVersionChangeEventInit): IDBVersionChangeEvent;
9503 };
9504
9505 /** 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. */
9506 interface IIRFilterNode extends AudioNode {
9507     getFrequencyResponse(frequencyHz: Float32Array, magResponse: Float32Array, phaseResponse: Float32Array): void;
9508 }
9509
9510 declare var IIRFilterNode: {
9511     prototype: IIRFilterNode;
9512     new(context: BaseAudioContext, options: IIRFilterOptions): IIRFilterNode;
9513 };
9514
9515 interface ImageBitmap {
9516     /**
9517      * Returns the intrinsic height of the image, in CSS pixels.
9518      */
9519     readonly height: number;
9520     /**
9521      * Returns the intrinsic width of the image, in CSS pixels.
9522      */
9523     readonly width: number;
9524     /**
9525      * Releases imageBitmap's underlying bitmap data.
9526      */
9527     close(): void;
9528 }
9529
9530 declare var ImageBitmap: {
9531     prototype: ImageBitmap;
9532     new(): ImageBitmap;
9533 };
9534
9535 interface ImageBitmapRenderingContext {
9536     /**
9537      * Returns the canvas element that the context is bound to.
9538      */
9539     readonly canvas: HTMLCanvasElement | OffscreenCanvas;
9540     /**
9541      * Transfers the underlying bitmap data from imageBitmap to context, and the bitmap becomes the contents of the canvas element to which context is bound.
9542      */
9543     transferFromImageBitmap(bitmap: ImageBitmap | null): void;
9544 }
9545
9546 declare var ImageBitmapRenderingContext: {
9547     prototype: ImageBitmapRenderingContext;
9548     new(): ImageBitmapRenderingContext;
9549 };
9550
9551 /** 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(). */
9552 interface ImageData {
9553     /**
9554      * Returns the one-dimensional array containing the data in RGBA order, as integers in the range 0 to 255.
9555      */
9556     readonly data: Uint8ClampedArray;
9557     /**
9558      * Returns the actual dimensions of the data in the ImageData object, in pixels.
9559      */
9560     readonly height: number;
9561     /**
9562      * Returns the actual dimensions of the data in the ImageData object, in pixels.
9563      */
9564     readonly width: number;
9565 }
9566
9567 declare var ImageData: {
9568     prototype: ImageData;
9569     new(width: number, height: number): ImageData;
9570     new(array: Uint8ClampedArray, width: number, height?: number): ImageData;
9571 };
9572
9573 interface InnerHTML {
9574     innerHTML: string;
9575 }
9576
9577 interface InputDeviceInfo extends MediaDeviceInfo {
9578     getCapabilities(): MediaTrackCapabilities;
9579 }
9580
9581 declare var InputDeviceInfo: {
9582     prototype: InputDeviceInfo;
9583     new(): InputDeviceInfo;
9584 };
9585
9586 interface InputEvent extends UIEvent {
9587     readonly data: string | null;
9588     readonly inputType: string;
9589     readonly isComposing: boolean;
9590 }
9591
9592 declare var InputEvent: {
9593     prototype: InputEvent;
9594     new(type: string, eventInitDict?: InputEventInit): InputEvent;
9595 };
9596
9597 /** 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. */
9598 interface IntersectionObserver {
9599     readonly root: Element | null;
9600     readonly rootMargin: string;
9601     readonly thresholds: ReadonlyArray<number>;
9602     disconnect(): void;
9603     observe(target: Element): void;
9604     takeRecords(): IntersectionObserverEntry[];
9605     unobserve(target: Element): void;
9606 }
9607
9608 declare var IntersectionObserver: {
9609     prototype: IntersectionObserver;
9610     new(callback: IntersectionObserverCallback, options?: IntersectionObserverInit): IntersectionObserver;
9611 };
9612
9613 /** This Intersection Observer API interface describes the intersection between the target element and its root container at a specific moment of transition. */
9614 interface IntersectionObserverEntry {
9615     readonly boundingClientRect: DOMRectReadOnly;
9616     readonly intersectionRatio: number;
9617     readonly intersectionRect: DOMRectReadOnly;
9618     readonly isIntersecting: boolean;
9619     readonly rootBounds: DOMRectReadOnly | null;
9620     readonly target: Element;
9621     readonly time: number;
9622 }
9623
9624 declare var IntersectionObserverEntry: {
9625     prototype: IntersectionObserverEntry;
9626     new(intersectionObserverEntryInit: IntersectionObserverEntryInit): IntersectionObserverEntry;
9627 };
9628
9629 /** 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. */
9630 interface KeyboardEvent extends UIEvent {
9631     readonly altKey: boolean;
9632     /** @deprecated */
9633     char: string;
9634     /** @deprecated */
9635     readonly charCode: number;
9636     readonly code: string;
9637     readonly ctrlKey: boolean;
9638     readonly isComposing: boolean;
9639     readonly key: string;
9640     /** @deprecated */
9641     readonly keyCode: number;
9642     readonly location: number;
9643     readonly metaKey: boolean;
9644     readonly repeat: boolean;
9645     readonly shiftKey: boolean;
9646     getModifierState(keyArg: string): boolean;
9647     readonly DOM_KEY_LOCATION_LEFT: number;
9648     readonly DOM_KEY_LOCATION_NUMPAD: number;
9649     readonly DOM_KEY_LOCATION_RIGHT: number;
9650     readonly DOM_KEY_LOCATION_STANDARD: number;
9651 }
9652
9653 declare var KeyboardEvent: {
9654     prototype: KeyboardEvent;
9655     new(type: string, eventInitDict?: KeyboardEventInit): KeyboardEvent;
9656     readonly DOM_KEY_LOCATION_LEFT: number;
9657     readonly DOM_KEY_LOCATION_NUMPAD: number;
9658     readonly DOM_KEY_LOCATION_RIGHT: number;
9659     readonly DOM_KEY_LOCATION_STANDARD: number;
9660 };
9661
9662 interface KeyframeEffect extends AnimationEffect {
9663     composite: CompositeOperation;
9664     iterationComposite: IterationCompositeOperation;
9665     target: Element | null;
9666     getKeyframes(): ComputedKeyframe[];
9667     setKeyframes(keyframes: Keyframe[] | PropertyIndexedKeyframes | null): void;
9668 }
9669
9670 declare var KeyframeEffect: {
9671     prototype: KeyframeEffect;
9672     new(target: Element | null, keyframes: Keyframe[] | PropertyIndexedKeyframes | null, options?: number | KeyframeEffectOptions): KeyframeEffect;
9673     new(source: KeyframeEffect): KeyframeEffect;
9674 };
9675
9676 interface LinkStyle {
9677     readonly sheet: CSSStyleSheet | null;
9678 }
9679
9680 interface ListeningStateChangedEvent extends Event {
9681     readonly label: string;
9682     readonly state: ListeningState;
9683 }
9684
9685 declare var ListeningStateChangedEvent: {
9686     prototype: ListeningStateChangedEvent;
9687     new(): ListeningStateChangedEvent;
9688 };
9689
9690 /** 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. */
9691 interface Location {
9692     /**
9693      * Returns a DOMStringList object listing the origins of the ancestor browsing contexts, from the parent browsing context to the top-level browsing context.
9694      */
9695     readonly ancestorOrigins: DOMStringList;
9696     /**
9697      * Returns the Location object's URL's fragment (includes leading "#" if non-empty).
9698      *
9699      * Can be set, to navigate to the same URL with a changed fragment (ignores leading "#").
9700      */
9701     hash: string;
9702     /**
9703      * Returns the Location object's URL's host and port (if different from the default port for the scheme).
9704      *
9705      * Can be set, to navigate to the same URL with a changed host and port.
9706      */
9707     host: string;
9708     /**
9709      * Returns the Location object's URL's host.
9710      *
9711      * Can be set, to navigate to the same URL with a changed host.
9712      */
9713     hostname: string;
9714     /**
9715      * Returns the Location object's URL.
9716      *
9717      * Can be set, to navigate to the given URL.
9718      */
9719     href: string;
9720     toString(): string;
9721     /**
9722      * Returns the Location object's URL's origin.
9723      */
9724     readonly origin: string;
9725     /**
9726      * Returns the Location object's URL's path.
9727      *
9728      * Can be set, to navigate to the same URL with a changed path.
9729      */
9730     pathname: string;
9731     /**
9732      * Returns the Location object's URL's port.
9733      *
9734      * Can be set, to navigate to the same URL with a changed port.
9735      */
9736     port: string;
9737     /**
9738      * Returns the Location object's URL's scheme.
9739      *
9740      * Can be set, to navigate to the same URL with a changed scheme.
9741      */
9742     protocol: string;
9743     /**
9744      * Returns the Location object's URL's query (includes leading "?" if non-empty).
9745      *
9746      * Can be set, to navigate to the same URL with a changed query (ignores leading "?").
9747      */
9748     search: string;
9749     /**
9750      * Navigates to the given URL.
9751      */
9752     assign(url: string): void;
9753     /**
9754      * Reloads the current page.
9755      */
9756     reload(): void;
9757     /** @deprecated */
9758     reload(forcedReload: boolean): void;
9759     /**
9760      * Removes the current page from the session history and navigates to the given URL.
9761      */
9762     replace(url: string): void;
9763 }
9764
9765 declare var Location: {
9766     prototype: Location;
9767     new(): Location;
9768 };
9769
9770 interface MSAssertion {
9771     readonly id: string;
9772     readonly type: MSCredentialType;
9773 }
9774
9775 declare var MSAssertion: {
9776     prototype: MSAssertion;
9777     new(): MSAssertion;
9778 };
9779
9780 interface MSBlobBuilder {
9781     append(data: any, endings?: string): void;
9782     getBlob(contentType?: string): Blob;
9783 }
9784
9785 declare var MSBlobBuilder: {
9786     prototype: MSBlobBuilder;
9787     new(): MSBlobBuilder;
9788 };
9789
9790 interface MSFIDOCredentialAssertion extends MSAssertion {
9791     readonly algorithm: string | Algorithm;
9792     readonly attestation: any;
9793     readonly publicKey: string;
9794     readonly transportHints: MSTransportType[];
9795 }
9796
9797 declare var MSFIDOCredentialAssertion: {
9798     prototype: MSFIDOCredentialAssertion;
9799     new(): MSFIDOCredentialAssertion;
9800 };
9801
9802 interface MSFIDOSignature {
9803     readonly authnrData: string;
9804     readonly clientData: string;
9805     readonly signature: string;
9806 }
9807
9808 declare var MSFIDOSignature: {
9809     prototype: MSFIDOSignature;
9810     new(): MSFIDOSignature;
9811 };
9812
9813 interface MSFIDOSignatureAssertion extends MSAssertion {
9814     readonly signature: MSFIDOSignature;
9815 }
9816
9817 declare var MSFIDOSignatureAssertion: {
9818     prototype: MSFIDOSignatureAssertion;
9819     new(): MSFIDOSignatureAssertion;
9820 };
9821
9822 interface MSFileSaver {
9823     msSaveBlob(blob: any, defaultName?: string): boolean;
9824     msSaveOrOpenBlob(blob: any, defaultName?: string): boolean;
9825 }
9826
9827 interface MSGesture {
9828     target: Element;
9829     addPointer(pointerId: number): void;
9830     stop(): void;
9831 }
9832
9833 declare var MSGesture: {
9834     prototype: MSGesture;
9835     new(): MSGesture;
9836 };
9837
9838 /** The MSGestureEvent is a proprietary interface specific to Internet Explorer and Microsoft Edge which represents events that occur due to touch gestures. Events using this interface include MSGestureStart, MSGestureEnd, MSGestureTap, MSGestureHold, MSGestureChange, and MSInertiaStart. */
9839 interface MSGestureEvent extends UIEvent {
9840     readonly clientX: number;
9841     readonly clientY: number;
9842     readonly expansion: number;
9843     readonly gestureObject: any;
9844     readonly hwTimestamp: number;
9845     readonly offsetX: number;
9846     readonly offsetY: number;
9847     readonly rotation: number;
9848     readonly scale: number;
9849     readonly screenX: number;
9850     readonly screenY: number;
9851     readonly translationX: number;
9852     readonly translationY: number;
9853     readonly velocityAngular: number;
9854     readonly velocityExpansion: number;
9855     readonly velocityX: number;
9856     readonly velocityY: number;
9857     initGestureEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, viewArg: Window, detailArg: number, screenXArg: number, screenYArg: number, clientXArg: number, clientYArg: number, offsetXArg: number, offsetYArg: number, translationXArg: number, translationYArg: number, scaleArg: number, expansionArg: number, rotationArg: number, velocityXArg: number, velocityYArg: number, velocityExpansionArg: number, velocityAngularArg: number, hwTimestampArg: number): void;
9858     readonly MSGESTURE_FLAG_BEGIN: number;
9859     readonly MSGESTURE_FLAG_CANCEL: number;
9860     readonly MSGESTURE_FLAG_END: number;
9861     readonly MSGESTURE_FLAG_INERTIA: number;
9862     readonly MSGESTURE_FLAG_NONE: number;
9863 }
9864
9865 declare var MSGestureEvent: {
9866     prototype: MSGestureEvent;
9867     new(): MSGestureEvent;
9868     readonly MSGESTURE_FLAG_BEGIN: number;
9869     readonly MSGESTURE_FLAG_CANCEL: number;
9870     readonly MSGESTURE_FLAG_END: number;
9871     readonly MSGESTURE_FLAG_INERTIA: number;
9872     readonly MSGESTURE_FLAG_NONE: number;
9873 };
9874
9875 /** The msGraphicsTrust() constructor returns an object that provides properties for info on protected video playback. */
9876 interface MSGraphicsTrust {
9877     readonly constrictionActive: boolean;
9878     readonly status: string;
9879 }
9880
9881 declare var MSGraphicsTrust: {
9882     prototype: MSGraphicsTrust;
9883     new(): MSGraphicsTrust;
9884 };
9885
9886 interface MSInputMethodContextEventMap {
9887     "MSCandidateWindowHide": Event;
9888     "MSCandidateWindowShow": Event;
9889     "MSCandidateWindowUpdate": Event;
9890 }
9891
9892 interface MSInputMethodContext extends EventTarget {
9893     readonly compositionEndOffset: number;
9894     readonly compositionStartOffset: number;
9895     oncandidatewindowhide: ((this: MSInputMethodContext, ev: Event) => any) | null;
9896     oncandidatewindowshow: ((this: MSInputMethodContext, ev: Event) => any) | null;
9897     oncandidatewindowupdate: ((this: MSInputMethodContext, ev: Event) => any) | null;
9898     readonly target: HTMLElement;
9899     getCandidateWindowClientRect(): ClientRect;
9900     getCompositionAlternatives(): string[];
9901     hasComposition(): boolean;
9902     isCandidateWindowVisible(): boolean;
9903     addEventListener<K extends keyof MSInputMethodContextEventMap>(type: K, listener: (this: MSInputMethodContext, ev: MSInputMethodContextEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9904     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9905     removeEventListener<K extends keyof MSInputMethodContextEventMap>(type: K, listener: (this: MSInputMethodContext, ev: MSInputMethodContextEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9906     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9907 }
9908
9909 declare var MSInputMethodContext: {
9910     prototype: MSInputMethodContext;
9911     new(): MSInputMethodContext;
9912 };
9913
9914 interface MSMediaKeyError {
9915     readonly code: number;
9916     readonly systemCode: number;
9917     readonly MS_MEDIA_KEYERR_CLIENT: number;
9918     readonly MS_MEDIA_KEYERR_DOMAIN: number;
9919     readonly MS_MEDIA_KEYERR_HARDWARECHANGE: number;
9920     readonly MS_MEDIA_KEYERR_OUTPUT: number;
9921     readonly MS_MEDIA_KEYERR_SERVICE: number;
9922     readonly MS_MEDIA_KEYERR_UNKNOWN: number;
9923 }
9924
9925 declare var MSMediaKeyError: {
9926     prototype: MSMediaKeyError;
9927     new(): MSMediaKeyError;
9928     readonly MS_MEDIA_KEYERR_CLIENT: number;
9929     readonly MS_MEDIA_KEYERR_DOMAIN: number;
9930     readonly MS_MEDIA_KEYERR_HARDWARECHANGE: number;
9931     readonly MS_MEDIA_KEYERR_OUTPUT: number;
9932     readonly MS_MEDIA_KEYERR_SERVICE: number;
9933     readonly MS_MEDIA_KEYERR_UNKNOWN: number;
9934 };
9935
9936 interface MSMediaKeyMessageEvent extends Event {
9937     readonly destinationURL: string | null;
9938     readonly message: Uint8Array;
9939 }
9940
9941 declare var MSMediaKeyMessageEvent: {
9942     prototype: MSMediaKeyMessageEvent;
9943     new(): MSMediaKeyMessageEvent;
9944 };
9945
9946 interface MSMediaKeyNeededEvent extends Event {
9947     readonly initData: Uint8Array | null;
9948 }
9949
9950 declare var MSMediaKeyNeededEvent: {
9951     prototype: MSMediaKeyNeededEvent;
9952     new(): MSMediaKeyNeededEvent;
9953 };
9954
9955 interface MSMediaKeySession extends EventTarget {
9956     readonly error: MSMediaKeyError | null;
9957     readonly keySystem: string;
9958     readonly sessionId: string;
9959     close(): void;
9960     update(key: Uint8Array): void;
9961 }
9962
9963 declare var MSMediaKeySession: {
9964     prototype: MSMediaKeySession;
9965     new(): MSMediaKeySession;
9966 };
9967
9968 interface MSMediaKeys {
9969     readonly keySystem: string;
9970     createSession(type: string, initData: Uint8Array, cdmData?: Uint8Array | null): MSMediaKeySession;
9971 }
9972
9973 declare var MSMediaKeys: {
9974     prototype: MSMediaKeys;
9975     new(keySystem: string): MSMediaKeys;
9976     isTypeSupported(keySystem: string, type?: string | null): boolean;
9977     isTypeSupportedWithFeatures(keySystem: string, type?: string | null): string;
9978 };
9979
9980 interface MSNavigatorDoNotTrack {
9981     confirmSiteSpecificTrackingException(args: ConfirmSiteSpecificExceptionsInformation): boolean;
9982     confirmWebWideTrackingException(args: ExceptionInformation): boolean;
9983     removeSiteSpecificTrackingException(args: ExceptionInformation): void;
9984     removeWebWideTrackingException(args: ExceptionInformation): void;
9985     storeSiteSpecificTrackingException(args: StoreSiteSpecificExceptionsInformation): void;
9986     storeWebWideTrackingException(args: StoreExceptionsInformation): void;
9987 }
9988
9989 interface MSPointerEvent extends MouseEvent {
9990     readonly currentPoint: any;
9991     readonly height: number;
9992     readonly hwTimestamp: number;
9993     readonly intermediatePoints: any;
9994     readonly isPrimary: boolean;
9995     readonly pointerId: number;
9996     readonly pointerType: any;
9997     readonly pressure: number;
9998     readonly rotation: number;
9999     readonly tiltX: number;
10000     readonly tiltY: number;
10001     readonly width: number;
10002     getCurrentPoint(element: Element): void;
10003     getIntermediatePoints(element: Element): void;
10004     initPointerEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, viewArg: Window, detailArg: number, screenXArg: number, screenYArg: number, clientXArg: number, clientYArg: number, ctrlKeyArg: boolean, altKeyArg: boolean, shiftKeyArg: boolean, metaKeyArg: boolean, buttonArg: number, relatedTargetArg: EventTarget, offsetXArg: number, offsetYArg: number, widthArg: number, heightArg: number, pressure: number, rotation: number, tiltX: number, tiltY: number, pointerIdArg: number, pointerType: any, hwTimestampArg: number, isPrimary: boolean): void;
10005 }
10006
10007 declare var MSPointerEvent: {
10008     prototype: MSPointerEvent;
10009     new(typeArg: string, eventInitDict?: PointerEventInit): MSPointerEvent;
10010 };
10011
10012 interface MSStream {
10013     readonly type: string;
10014     msClose(): void;
10015     msDetachStream(): any;
10016 }
10017
10018 declare var MSStream: {
10019     prototype: MSStream;
10020     new(): MSStream;
10021 };
10022
10023 /** The MediaDevicesInfo interface contains information that describes a single media input or output device. */
10024 interface MediaDeviceInfo {
10025     readonly deviceId: string;
10026     readonly groupId: string;
10027     readonly kind: MediaDeviceKind;
10028     readonly label: string;
10029     toJSON(): any;
10030 }
10031
10032 declare var MediaDeviceInfo: {
10033     prototype: MediaDeviceInfo;
10034     new(): MediaDeviceInfo;
10035 };
10036
10037 interface MediaDevicesEventMap {
10038     "devicechange": Event;
10039 }
10040
10041 /** 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. */
10042 interface MediaDevices extends EventTarget {
10043     ondevicechange: ((this: MediaDevices, ev: Event) => any) | null;
10044     enumerateDevices(): Promise<MediaDeviceInfo[]>;
10045     getSupportedConstraints(): MediaTrackSupportedConstraints;
10046     getUserMedia(constraints?: MediaStreamConstraints): Promise<MediaStream>;
10047     addEventListener<K extends keyof MediaDevicesEventMap>(type: K, listener: (this: MediaDevices, ev: MediaDevicesEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10048     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10049     removeEventListener<K extends keyof MediaDevicesEventMap>(type: K, listener: (this: MediaDevices, ev: MediaDevicesEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10050     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10051 }
10052
10053 declare var MediaDevices: {
10054     prototype: MediaDevices;
10055     new(): MediaDevices;
10056 };
10057
10058 /** 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. */
10059 interface MediaElementAudioSourceNode extends AudioNode {
10060     readonly mediaElement: HTMLMediaElement;
10061 }
10062
10063 declare var MediaElementAudioSourceNode: {
10064     prototype: MediaElementAudioSourceNode;
10065     new(context: AudioContext, options: MediaElementAudioSourceOptions): MediaElementAudioSourceNode;
10066 };
10067
10068 interface MediaEncryptedEvent extends Event {
10069     readonly initData: ArrayBuffer | null;
10070     readonly initDataType: string;
10071 }
10072
10073 declare var MediaEncryptedEvent: {
10074     prototype: MediaEncryptedEvent;
10075     new(type: string, eventInitDict?: MediaEncryptedEventInit): MediaEncryptedEvent;
10076 };
10077
10078 /** An error which occurred while handling media in an HTML media element based on HTMLMediaElement, such as <audio> or <video>. */
10079 interface MediaError {
10080     readonly code: number;
10081     readonly message: string;
10082     readonly MEDIA_ERR_ABORTED: number;
10083     readonly MEDIA_ERR_DECODE: number;
10084     readonly MEDIA_ERR_NETWORK: number;
10085     readonly MEDIA_ERR_SRC_NOT_SUPPORTED: number;
10086 }
10087
10088 declare var MediaError: {
10089     prototype: MediaError;
10090     new(): MediaError;
10091     readonly MEDIA_ERR_ABORTED: number;
10092     readonly MEDIA_ERR_DECODE: number;
10093     readonly MEDIA_ERR_NETWORK: number;
10094     readonly MEDIA_ERR_SRC_NOT_SUPPORTED: number;
10095 };
10096
10097 /** This EncryptedMediaExtensions API interface contains the content and related data when the content decryption module generates a message for the session. */
10098 interface MediaKeyMessageEvent extends Event {
10099     readonly message: ArrayBuffer;
10100     readonly messageType: MediaKeyMessageType;
10101 }
10102
10103 declare var MediaKeyMessageEvent: {
10104     prototype: MediaKeyMessageEvent;
10105     new(type: string, eventInitDict: MediaKeyMessageEventInit): MediaKeyMessageEvent;
10106 };
10107
10108 interface MediaKeySessionEventMap {
10109     "keystatuseschange": Event;
10110     "message": MediaKeyMessageEvent;
10111 }
10112
10113 /** This EncryptedMediaExtensions API interface represents a context for message exchange with a content decryption module (CDM). */
10114 interface MediaKeySession extends EventTarget {
10115     readonly closed: Promise<void>;
10116     readonly expiration: number;
10117     readonly keyStatuses: MediaKeyStatusMap;
10118     onkeystatuseschange: ((this: MediaKeySession, ev: Event) => any) | null;
10119     onmessage: ((this: MediaKeySession, ev: MediaKeyMessageEvent) => any) | null;
10120     readonly sessionId: string;
10121     close(): Promise<void>;
10122     generateRequest(initDataType: string, initData: BufferSource): Promise<void>;
10123     load(sessionId: string): Promise<boolean>;
10124     remove(): Promise<void>;
10125     update(response: BufferSource): Promise<void>;
10126     addEventListener<K extends keyof MediaKeySessionEventMap>(type: K, listener: (this: MediaKeySession, ev: MediaKeySessionEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10127     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10128     removeEventListener<K extends keyof MediaKeySessionEventMap>(type: K, listener: (this: MediaKeySession, ev: MediaKeySessionEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10129     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10130 }
10131
10132 declare var MediaKeySession: {
10133     prototype: MediaKeySession;
10134     new(): MediaKeySession;
10135 };
10136
10137 /** This EncryptedMediaExtensions API interface is a read-only map of media key statuses by key IDs. */
10138 interface MediaKeyStatusMap {
10139     readonly size: number;
10140     get(keyId: BufferSource): MediaKeyStatus | undefined;
10141     has(keyId: BufferSource): boolean;
10142     forEach(callbackfn: (value: MediaKeyStatus, key: BufferSource, parent: MediaKeyStatusMap) => void, thisArg?: any): void;
10143 }
10144
10145 declare var MediaKeyStatusMap: {
10146     prototype: MediaKeyStatusMap;
10147     new(): MediaKeyStatusMap;
10148 };
10149
10150 /** 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. */
10151 interface MediaKeySystemAccess {
10152     readonly keySystem: string;
10153     createMediaKeys(): Promise<MediaKeys>;
10154     getConfiguration(): MediaKeySystemConfiguration;
10155 }
10156
10157 declare var MediaKeySystemAccess: {
10158     prototype: MediaKeySystemAccess;
10159     new(): MediaKeySystemAccess;
10160 };
10161
10162 /** This EncryptedMediaExtensions API interface the represents a set of keys that an associated HTMLMediaElement can use for decryption of media data during playback. */
10163 interface MediaKeys {
10164     createSession(sessionType?: MediaKeySessionType): MediaKeySession;
10165     setServerCertificate(serverCertificate: BufferSource): Promise<boolean>;
10166 }
10167
10168 declare var MediaKeys: {
10169     prototype: MediaKeys;
10170     new(): MediaKeys;
10171 };
10172
10173 interface MediaList {
10174     readonly length: number;
10175     mediaText: string;
10176     toString(): string;
10177     appendMedium(medium: string): void;
10178     deleteMedium(medium: string): void;
10179     item(index: number): string | null;
10180     [index: number]: string;
10181 }
10182
10183 declare var MediaList: {
10184     prototype: MediaList;
10185     new(): MediaList;
10186 };
10187
10188 interface MediaQueryListEventMap {
10189     "change": MediaQueryListEvent;
10190 }
10191
10192 /** 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). */
10193 interface MediaQueryList extends EventTarget {
10194     readonly matches: boolean;
10195     readonly media: string;
10196     onchange: ((this: MediaQueryList, ev: MediaQueryListEvent) => any) | null;
10197     /** @deprecated */
10198     addListener(listener: ((this: MediaQueryList, ev: MediaQueryListEvent) => any) | null): void;
10199     /** @deprecated */
10200     removeListener(listener: ((this: MediaQueryList, ev: MediaQueryListEvent) => any) | null): void;
10201     addEventListener<K extends keyof MediaQueryListEventMap>(type: K, listener: (this: MediaQueryList, ev: MediaQueryListEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10202     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10203     removeEventListener<K extends keyof MediaQueryListEventMap>(type: K, listener: (this: MediaQueryList, ev: MediaQueryListEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10204     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10205 }
10206
10207 declare var MediaQueryList: {
10208     prototype: MediaQueryList;
10209     new(): MediaQueryList;
10210 };
10211
10212 interface MediaQueryListEvent extends Event {
10213     readonly matches: boolean;
10214     readonly media: string;
10215 }
10216
10217 declare var MediaQueryListEvent: {
10218     prototype: MediaQueryListEvent;
10219     new(type: string, eventInitDict?: MediaQueryListEventInit): MediaQueryListEvent;
10220 };
10221
10222 interface MediaSourceEventMap {
10223     "sourceclose": Event;
10224     "sourceended": Event;
10225     "sourceopen": Event;
10226 }
10227
10228 /** 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. */
10229 interface MediaSource extends EventTarget {
10230     readonly activeSourceBuffers: SourceBufferList;
10231     duration: number;
10232     onsourceclose: ((this: MediaSource, ev: Event) => any) | null;
10233     onsourceended: ((this: MediaSource, ev: Event) => any) | null;
10234     onsourceopen: ((this: MediaSource, ev: Event) => any) | null;
10235     readonly readyState: ReadyState;
10236     readonly sourceBuffers: SourceBufferList;
10237     addSourceBuffer(type: string): SourceBuffer;
10238     clearLiveSeekableRange(): void;
10239     endOfStream(error?: EndOfStreamError): void;
10240     removeSourceBuffer(sourceBuffer: SourceBuffer): void;
10241     setLiveSeekableRange(start: number, end: number): void;
10242     addEventListener<K extends keyof MediaSourceEventMap>(type: K, listener: (this: MediaSource, ev: MediaSourceEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10243     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10244     removeEventListener<K extends keyof MediaSourceEventMap>(type: K, listener: (this: MediaSource, ev: MediaSourceEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10245     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10246 }
10247
10248 declare var MediaSource: {
10249     prototype: MediaSource;
10250     new(): MediaSource;
10251     isTypeSupported(type: string): boolean;
10252 };
10253
10254 interface MediaStreamEventMap {
10255     "addtrack": MediaStreamTrackEvent;
10256     "removetrack": MediaStreamTrackEvent;
10257 }
10258
10259 /** 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. */
10260 interface MediaStream extends EventTarget {
10261     readonly active: boolean;
10262     readonly id: string;
10263     onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
10264     onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
10265     addTrack(track: MediaStreamTrack): void;
10266     clone(): MediaStream;
10267     getAudioTracks(): MediaStreamTrack[];
10268     getTrackById(trackId: string): MediaStreamTrack | null;
10269     getTracks(): MediaStreamTrack[];
10270     getVideoTracks(): MediaStreamTrack[];
10271     removeTrack(track: MediaStreamTrack): void;
10272     addEventListener<K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10273     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10274     removeEventListener<K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10275     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10276 }
10277
10278 declare var MediaStream: {
10279     prototype: MediaStream;
10280     new(): MediaStream;
10281     new(stream: MediaStream): MediaStream;
10282     new(tracks: MediaStreamTrack[]): MediaStream;
10283 };
10284
10285 interface MediaStreamAudioDestinationNode extends AudioNode {
10286     readonly stream: MediaStream;
10287 }
10288
10289 declare var MediaStreamAudioDestinationNode: {
10290     prototype: MediaStreamAudioDestinationNode;
10291     new(context: AudioContext, options?: AudioNodeOptions): MediaStreamAudioDestinationNode;
10292 };
10293
10294 /** 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. */
10295 interface MediaStreamAudioSourceNode extends AudioNode {
10296     readonly mediaStream: MediaStream;
10297 }
10298
10299 declare var MediaStreamAudioSourceNode: {
10300     prototype: MediaStreamAudioSourceNode;
10301     new(context: AudioContext, options: MediaStreamAudioSourceOptions): MediaStreamAudioSourceNode;
10302 };
10303
10304 interface MediaStreamError {
10305     readonly constraintName: string | null;
10306     readonly message: string | null;
10307     readonly name: string;
10308 }
10309
10310 declare var MediaStreamError: {
10311     prototype: MediaStreamError;
10312     new(): MediaStreamError;
10313 };
10314
10315 interface MediaStreamErrorEvent extends Event {
10316     readonly error: MediaStreamError | null;
10317 }
10318
10319 declare var MediaStreamErrorEvent: {
10320     prototype: MediaStreamErrorEvent;
10321     new(typeArg: string, eventInitDict?: MediaStreamErrorEventInit): MediaStreamErrorEvent;
10322 };
10323
10324 /** Events that occurs in relation to a MediaStream. Two events of this type can be thrown: addstream and removestream. */
10325 interface MediaStreamEvent extends Event {
10326     readonly stream: MediaStream | null;
10327 }
10328
10329 declare var MediaStreamEvent: {
10330     prototype: MediaStreamEvent;
10331     new(type: string, eventInitDict: MediaStreamEventInit): MediaStreamEvent;
10332 };
10333
10334 interface MediaStreamTrackEventMap {
10335     "ended": Event;
10336     "isolationchange": Event;
10337     "mute": Event;
10338     "unmute": Event;
10339 }
10340
10341 /** A single media track within a stream; typically, these are audio or video tracks, but other track types may exist as well. */
10342 interface MediaStreamTrack extends EventTarget {
10343     enabled: boolean;
10344     readonly id: string;
10345     readonly isolated: boolean;
10346     readonly kind: string;
10347     readonly label: string;
10348     readonly muted: boolean;
10349     onended: ((this: MediaStreamTrack, ev: Event) => any) | null;
10350     onisolationchange: ((this: MediaStreamTrack, ev: Event) => any) | null;
10351     onmute: ((this: MediaStreamTrack, ev: Event) => any) | null;
10352     onunmute: ((this: MediaStreamTrack, ev: Event) => any) | null;
10353     readonly readyState: MediaStreamTrackState;
10354     applyConstraints(constraints?: MediaTrackConstraints): Promise<void>;
10355     clone(): MediaStreamTrack;
10356     getCapabilities(): MediaTrackCapabilities;
10357     getConstraints(): MediaTrackConstraints;
10358     getSettings(): MediaTrackSettings;
10359     stop(): void;
10360     addEventListener<K extends keyof MediaStreamTrackEventMap>(type: K, listener: (this: MediaStreamTrack, ev: MediaStreamTrackEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10361     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10362     removeEventListener<K extends keyof MediaStreamTrackEventMap>(type: K, listener: (this: MediaStreamTrack, ev: MediaStreamTrackEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10363     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10364 }
10365
10366 declare var MediaStreamTrack: {
10367     prototype: MediaStreamTrack;
10368     new(): MediaStreamTrack;
10369 };
10370
10371 interface MediaStreamTrackAudioSourceNode extends AudioNode {
10372 }
10373
10374 declare var MediaStreamTrackAudioSourceNode: {
10375     prototype: MediaStreamTrackAudioSourceNode;
10376     new(context: AudioContext, options: MediaStreamTrackAudioSourceOptions): MediaStreamTrackAudioSourceNode;
10377 };
10378
10379 /** 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. */
10380 interface MediaStreamTrackEvent extends Event {
10381     readonly track: MediaStreamTrack;
10382 }
10383
10384 declare var MediaStreamTrackEvent: {
10385     prototype: MediaStreamTrackEvent;
10386     new(type: string, eventInitDict: MediaStreamTrackEventInit): MediaStreamTrackEvent;
10387 };
10388
10389 /** This Channel Messaging API interface allows us to create a new message channel and send data through it via its two MessagePort properties. */
10390 interface MessageChannel {
10391     /**
10392      * Returns the first MessagePort object.
10393      */
10394     readonly port1: MessagePort;
10395     /**
10396      * Returns the second MessagePort object.
10397      */
10398     readonly port2: MessagePort;
10399 }
10400
10401 declare var MessageChannel: {
10402     prototype: MessageChannel;
10403     new(): MessageChannel;
10404 };
10405
10406 /** A message received by a target object. */
10407 interface MessageEvent extends Event {
10408     /**
10409      * Returns the data of the message.
10410      */
10411     readonly data: any;
10412     /**
10413      * Returns the last event ID string, for server-sent events.
10414      */
10415     readonly lastEventId: string;
10416     /**
10417      * Returns the origin of the message, for server-sent events and cross-document messaging.
10418      */
10419     readonly origin: string;
10420     /**
10421      * Returns the MessagePort array sent with the message, for cross-document messaging and channel messaging.
10422      */
10423     readonly ports: ReadonlyArray<MessagePort>;
10424     /**
10425      * Returns the WindowProxy of the source window, for cross-document messaging, and the MessagePort being attached, in the connect event fired at SharedWorkerGlobalScope objects.
10426      */
10427     readonly source: MessageEventSource | null;
10428 }
10429
10430 declare var MessageEvent: {
10431     prototype: MessageEvent;
10432     new(type: string, eventInitDict?: MessageEventInit): MessageEvent;
10433 };
10434
10435 interface MessagePortEventMap {
10436     "message": MessageEvent;
10437     "messageerror": MessageEvent;
10438 }
10439
10440 /** 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. */
10441 interface MessagePort extends EventTarget {
10442     onmessage: ((this: MessagePort, ev: MessageEvent) => any) | null;
10443     onmessageerror: ((this: MessagePort, ev: MessageEvent) => any) | null;
10444     /**
10445      * Disconnects the port, so that it is no longer active.
10446      */
10447     close(): void;
10448     /**
10449      * 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.
10450      *
10451      * Throws a "DataCloneError" DOMException if transfer contains duplicate objects or port, or if message could not be cloned.
10452      */
10453     postMessage(message: any, transfer: Transferable[]): void;
10454     postMessage(message: any, options?: PostMessageOptions): void;
10455     /**
10456      * Begins dispatching messages received on the port.
10457      */
10458     start(): void;
10459     addEventListener<K extends keyof MessagePortEventMap>(type: K, listener: (this: MessagePort, ev: MessagePortEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10460     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10461     removeEventListener<K extends keyof MessagePortEventMap>(type: K, listener: (this: MessagePort, ev: MessagePortEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10462     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10463 }
10464
10465 declare var MessagePort: {
10466     prototype: MessagePort;
10467     new(): MessagePort;
10468 };
10469
10470 /** Provides contains information about a MIME type associated with a particular plugin. NavigatorPlugins.mimeTypes returns an array of this object. */
10471 interface MimeType {
10472     /**
10473      * Returns the MIME type's description.
10474      */
10475     readonly description: string;
10476     /**
10477      * Returns the Plugin object that implements this MIME type.
10478      */
10479     readonly enabledPlugin: Plugin;
10480     /**
10481      * Returns the MIME type's typical file extensions, in a comma-separated list.
10482      */
10483     readonly suffixes: string;
10484     /**
10485      * Returns the MIME type.
10486      */
10487     readonly type: string;
10488 }
10489
10490 declare var MimeType: {
10491     prototype: MimeType;
10492     new(): MimeType;
10493 };
10494
10495 /** Returns an array of MimeType instances, each of which contains information about a supported browser plugins. This object is returned by NavigatorPlugins.mimeTypes. */
10496 interface MimeTypeArray {
10497     readonly length: number;
10498     item(index: number): MimeType | null;
10499     namedItem(name: string): MimeType | null;
10500     [index: number]: MimeType;
10501 }
10502
10503 declare var MimeTypeArray: {
10504     prototype: MimeTypeArray;
10505     new(): MimeTypeArray;
10506 };
10507
10508 /** 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. */
10509 interface MouseEvent extends UIEvent {
10510     readonly altKey: boolean;
10511     readonly button: number;
10512     readonly buttons: number;
10513     readonly clientX: number;
10514     readonly clientY: number;
10515     readonly ctrlKey: boolean;
10516     readonly metaKey: boolean;
10517     readonly movementX: number;
10518     readonly movementY: number;
10519     readonly offsetX: number;
10520     readonly offsetY: number;
10521     readonly pageX: number;
10522     readonly pageY: number;
10523     readonly relatedTarget: EventTarget | null;
10524     readonly screenX: number;
10525     readonly screenY: number;
10526     readonly shiftKey: boolean;
10527     readonly x: number;
10528     readonly y: number;
10529     getModifierState(keyArg: string): boolean;
10530     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;
10531 }
10532
10533 declare var MouseEvent: {
10534     prototype: MouseEvent;
10535     new(type: string, eventInitDict?: MouseEventInit): MouseEvent;
10536 };
10537
10538 /** Provides event properties that are specific to modifications to the Document Object Model (DOM) hierarchy and nodes. */
10539 interface MutationEvent extends Event {
10540     readonly attrChange: number;
10541     readonly attrName: string;
10542     readonly newValue: string;
10543     readonly prevValue: string;
10544     readonly relatedNode: Node;
10545     initMutationEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, relatedNodeArg: Node, prevValueArg: string, newValueArg: string, attrNameArg: string, attrChangeArg: number): void;
10546     readonly ADDITION: number;
10547     readonly MODIFICATION: number;
10548     readonly REMOVAL: number;
10549 }
10550
10551 declare var MutationEvent: {
10552     prototype: MutationEvent;
10553     new(): MutationEvent;
10554     readonly ADDITION: number;
10555     readonly MODIFICATION: number;
10556     readonly REMOVAL: number;
10557 };
10558
10559 /** 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. */
10560 interface MutationObserver {
10561     /**
10562      * Stops observer from observing any mutations. Until the observe() method is used again, observer's callback will not be invoked.
10563      */
10564     disconnect(): void;
10565     /**
10566      * Instructs the user agent to observe a given target (a node) and report any mutations based on the criteria given by options (an object).
10567      *
10568      * The options argument allows for setting mutation observation options via object members.
10569      */
10570     observe(target: Node, options?: MutationObserverInit): void;
10571     /**
10572      * Empties the record queue and returns what was in there.
10573      */
10574     takeRecords(): MutationRecord[];
10575 }
10576
10577 declare var MutationObserver: {
10578     prototype: MutationObserver;
10579     new(callback: MutationCallback): MutationObserver;
10580 };
10581
10582 /** A MutationRecord represents an individual DOM mutation. It is the object that is passed to MutationObserver's callback. */
10583 interface MutationRecord {
10584     /**
10585      * Return the nodes added and removed respectively.
10586      */
10587     readonly addedNodes: NodeList;
10588     /**
10589      * Returns the local name of the changed attribute, and null otherwise.
10590      */
10591     readonly attributeName: string | null;
10592     /**
10593      * Returns the namespace of the changed attribute, and null otherwise.
10594      */
10595     readonly attributeNamespace: string | null;
10596     /**
10597      * Return the previous and next sibling respectively of the added or removed nodes, and null otherwise.
10598      */
10599     readonly nextSibling: Node | null;
10600     /**
10601      * 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.
10602      */
10603     readonly oldValue: string | null;
10604     /**
10605      * Return the previous and next sibling respectively of the added or removed nodes, and null otherwise.
10606      */
10607     readonly previousSibling: Node | null;
10608     /**
10609      * Return the nodes added and removed respectively.
10610      */
10611     readonly removedNodes: NodeList;
10612     /**
10613      * 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.
10614      */
10615     readonly target: Node;
10616     /**
10617      * 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.
10618      */
10619     readonly type: MutationRecordType;
10620 }
10621
10622 declare var MutationRecord: {
10623     prototype: MutationRecord;
10624     new(): MutationRecord;
10625 };
10626
10627 /** 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. */
10628 interface NamedNodeMap {
10629     readonly length: number;
10630     getNamedItem(qualifiedName: string): Attr | null;
10631     getNamedItemNS(namespace: string | null, localName: string): Attr | null;
10632     item(index: number): Attr | null;
10633     removeNamedItem(qualifiedName: string): Attr;
10634     removeNamedItemNS(namespace: string | null, localName: string): Attr;
10635     setNamedItem(attr: Attr): Attr | null;
10636     setNamedItemNS(attr: Attr): Attr | null;
10637     [index: number]: Attr;
10638 }
10639
10640 declare var NamedNodeMap: {
10641     prototype: NamedNodeMap;
10642     new(): NamedNodeMap;
10643 };
10644
10645 interface NavigationPreloadManager {
10646     disable(): Promise<void>;
10647     enable(): Promise<void>;
10648     getState(): Promise<NavigationPreloadState>;
10649     setHeaderValue(value: string): Promise<void>;
10650 }
10651
10652 declare var NavigationPreloadManager: {
10653     prototype: NavigationPreloadManager;
10654     new(): NavigationPreloadManager;
10655 };
10656
10657 /** The state and the identity of the user agent. It allows scripts to query it and to register themselves to carry on some activities. */
10658 interface Navigator extends MSFileSaver, MSNavigatorDoNotTrack, NavigatorAutomationInformation, NavigatorBeacon, NavigatorConcurrentHardware, NavigatorContentUtils, NavigatorCookies, NavigatorID, NavigatorLanguage, NavigatorOnLine, NavigatorPlugins, NavigatorStorage {
10659     readonly activeVRDisplays: ReadonlyArray<VRDisplay>;
10660     readonly clipboard: Clipboard;
10661     readonly credentials: CredentialsContainer;
10662     readonly doNotTrack: string | null;
10663     readonly geolocation: Geolocation;
10664     readonly maxTouchPoints: number;
10665     readonly mediaDevices: MediaDevices;
10666     readonly msManipulationViewsEnabled: boolean;
10667     readonly msMaxTouchPoints: number;
10668     readonly msPointerEnabled: boolean;
10669     readonly permissions: Permissions;
10670     readonly pointerEnabled: boolean;
10671     readonly serviceWorker: ServiceWorkerContainer;
10672     getGamepads(): (Gamepad | null)[];
10673     getUserMedia(constraints: MediaStreamConstraints, successCallback: NavigatorUserMediaSuccessCallback, errorCallback: NavigatorUserMediaErrorCallback): void;
10674     getVRDisplays(): Promise<VRDisplay[]>;
10675     msLaunchUri(uri: string, successCallback?: MSLaunchUriCallback, noHandlerCallback?: MSLaunchUriCallback): void;
10676     requestMediaKeySystemAccess(keySystem: string, supportedConfigurations: MediaKeySystemConfiguration[]): Promise<MediaKeySystemAccess>;
10677     sendBeacon(url: string, data?: BodyInit | null): boolean;
10678     share(data?: ShareData): Promise<void>;
10679     vibrate(pattern: number | number[]): boolean;
10680 }
10681
10682 declare var Navigator: {
10683     prototype: Navigator;
10684     new(): Navigator;
10685 };
10686
10687 interface NavigatorAutomationInformation {
10688     readonly webdriver: boolean;
10689 }
10690
10691 interface NavigatorBeacon {
10692     sendBeacon(url: string, data?: Blob | Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer | FormData | string | null): boolean;
10693 }
10694
10695 interface NavigatorConcurrentHardware {
10696     readonly hardwareConcurrency: number;
10697 }
10698
10699 interface NavigatorContentUtils {
10700     registerProtocolHandler(scheme: string, url: string, title: string): void;
10701     unregisterProtocolHandler(scheme: string, url: string): void;
10702 }
10703
10704 interface NavigatorCookies {
10705     readonly cookieEnabled: boolean;
10706 }
10707
10708 interface NavigatorID {
10709     readonly appCodeName: string;
10710     readonly appName: string;
10711     readonly appVersion: string;
10712     readonly platform: string;
10713     readonly product: string;
10714     readonly productSub: string;
10715     readonly userAgent: string;
10716     readonly vendor: string;
10717     readonly vendorSub: string;
10718 }
10719
10720 interface NavigatorLanguage {
10721     readonly language: string;
10722     readonly languages: ReadonlyArray<string>;
10723 }
10724
10725 interface NavigatorOnLine {
10726     readonly onLine: boolean;
10727 }
10728
10729 interface NavigatorPlugins {
10730     readonly mimeTypes: MimeTypeArray;
10731     readonly plugins: PluginArray;
10732     javaEnabled(): boolean;
10733 }
10734
10735 interface NavigatorStorage {
10736     readonly storage: StorageManager;
10737 }
10738
10739 /** 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. */
10740 interface Node extends EventTarget {
10741     /**
10742      * Returns node's node document's document base URL.
10743      */
10744     readonly baseURI: string;
10745     /**
10746      * Returns the children.
10747      */
10748     readonly childNodes: NodeListOf<ChildNode>;
10749     /**
10750      * Returns the first child.
10751      */
10752     readonly firstChild: ChildNode | null;
10753     /**
10754      * Returns true if node is connected and false otherwise.
10755      */
10756     readonly isConnected: boolean;
10757     /**
10758      * Returns the last child.
10759      */
10760     readonly lastChild: ChildNode | null;
10761     /** @deprecated */
10762     readonly namespaceURI: string | null;
10763     /**
10764      * Returns the next sibling.
10765      */
10766     readonly nextSibling: ChildNode | null;
10767     /**
10768      * Returns a string appropriate for the type of node.
10769      */
10770     readonly nodeName: string;
10771     /**
10772      * Returns the type of node.
10773      */
10774     readonly nodeType: number;
10775     nodeValue: string | null;
10776     /**
10777      * Returns the node document. Returns null for documents.
10778      */
10779     readonly ownerDocument: Document | null;
10780     /**
10781      * Returns the parent element.
10782      */
10783     readonly parentElement: HTMLElement | null;
10784     /**
10785      * Returns the parent.
10786      */
10787     readonly parentNode: Node & ParentNode | null;
10788     /**
10789      * Returns the previous sibling.
10790      */
10791     readonly previousSibling: ChildNode | null;
10792     textContent: string | null;
10793     appendChild<T extends Node>(newChild: T): T;
10794     /**
10795      * Returns a copy of node. If deep is true, the copy also includes the node's descendants.
10796      */
10797     cloneNode(deep?: boolean): Node;
10798     /**
10799      * Returns a bitmask indicating the position of other relative to node.
10800      */
10801     compareDocumentPosition(other: Node): number;
10802     /**
10803      * Returns true if other is an inclusive descendant of node, and false otherwise.
10804      */
10805     contains(other: Node | null): boolean;
10806     /**
10807      * Returns node's root.
10808      */
10809     getRootNode(options?: GetRootNodeOptions): Node;
10810     /**
10811      * Returns whether node has children.
10812      */
10813     hasChildNodes(): boolean;
10814     insertBefore<T extends Node>(newChild: T, refChild: Node | null): T;
10815     isDefaultNamespace(namespace: string | null): boolean;
10816     /**
10817      * Returns whether node and otherNode have the same properties.
10818      */
10819     isEqualNode(otherNode: Node | null): boolean;
10820     isSameNode(otherNode: Node | null): boolean;
10821     lookupNamespaceURI(prefix: string | null): string | null;
10822     lookupPrefix(namespace: string | null): string | null;
10823     /**
10824      * Removes empty exclusive Text nodes and concatenates the data of remaining contiguous exclusive Text nodes into the first of their nodes.
10825      */
10826     normalize(): void;
10827     removeChild<T extends Node>(oldChild: T): T;
10828     replaceChild<T extends Node>(newChild: Node, oldChild: T): T;
10829     readonly ATTRIBUTE_NODE: number;
10830     /**
10831      * node is a CDATASection node.
10832      */
10833     readonly CDATA_SECTION_NODE: number;
10834     /**
10835      * node is a Comment node.
10836      */
10837     readonly COMMENT_NODE: number;
10838     /**
10839      * node is a DocumentFragment node.
10840      */
10841     readonly DOCUMENT_FRAGMENT_NODE: number;
10842     /**
10843      * node is a document.
10844      */
10845     readonly DOCUMENT_NODE: number;
10846     /**
10847      * Set when other is a descendant of node.
10848      */
10849     readonly DOCUMENT_POSITION_CONTAINED_BY: number;
10850     /**
10851      * Set when other is an ancestor of node.
10852      */
10853     readonly DOCUMENT_POSITION_CONTAINS: number;
10854     /**
10855      * Set when node and other are not in the same tree.
10856      */
10857     readonly DOCUMENT_POSITION_DISCONNECTED: number;
10858     /**
10859      * Set when other is following node.
10860      */
10861     readonly DOCUMENT_POSITION_FOLLOWING: number;
10862     readonly DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC: number;
10863     /**
10864      * Set when other is preceding node.
10865      */
10866     readonly DOCUMENT_POSITION_PRECEDING: number;
10867     /**
10868      * node is a doctype.
10869      */
10870     readonly DOCUMENT_TYPE_NODE: number;
10871     /**
10872      * node is an element.
10873      */
10874     readonly ELEMENT_NODE: number;
10875     readonly ENTITY_NODE: number;
10876     readonly ENTITY_REFERENCE_NODE: number;
10877     readonly NOTATION_NODE: number;
10878     /**
10879      * node is a ProcessingInstruction node.
10880      */
10881     readonly PROCESSING_INSTRUCTION_NODE: number;
10882     /**
10883      * node is a Text node.
10884      */
10885     readonly TEXT_NODE: number;
10886 }
10887
10888 declare var Node: {
10889     prototype: Node;
10890     new(): Node;
10891     readonly ATTRIBUTE_NODE: number;
10892     /**
10893      * node is a CDATASection node.
10894      */
10895     readonly CDATA_SECTION_NODE: number;
10896     /**
10897      * node is a Comment node.
10898      */
10899     readonly COMMENT_NODE: number;
10900     /**
10901      * node is a DocumentFragment node.
10902      */
10903     readonly DOCUMENT_FRAGMENT_NODE: number;
10904     /**
10905      * node is a document.
10906      */
10907     readonly DOCUMENT_NODE: number;
10908     /**
10909      * Set when other is a descendant of node.
10910      */
10911     readonly DOCUMENT_POSITION_CONTAINED_BY: number;
10912     /**
10913      * Set when other is an ancestor of node.
10914      */
10915     readonly DOCUMENT_POSITION_CONTAINS: number;
10916     /**
10917      * Set when node and other are not in the same tree.
10918      */
10919     readonly DOCUMENT_POSITION_DISCONNECTED: number;
10920     /**
10921      * Set when other is following node.
10922      */
10923     readonly DOCUMENT_POSITION_FOLLOWING: number;
10924     readonly DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC: number;
10925     /**
10926      * Set when other is preceding node.
10927      */
10928     readonly DOCUMENT_POSITION_PRECEDING: number;
10929     /**
10930      * node is a doctype.
10931      */
10932     readonly DOCUMENT_TYPE_NODE: number;
10933     /**
10934      * node is an element.
10935      */
10936     readonly ELEMENT_NODE: number;
10937     readonly ENTITY_NODE: number;
10938     readonly ENTITY_REFERENCE_NODE: number;
10939     readonly NOTATION_NODE: number;
10940     /**
10941      * node is a ProcessingInstruction node.
10942      */
10943     readonly PROCESSING_INSTRUCTION_NODE: number;
10944     /**
10945      * node is a Text node.
10946      */
10947     readonly TEXT_NODE: number;
10948 };
10949
10950 /** An object used to filter the nodes in a NodeIterator or TreeWalker. They don't know anything about the DOM or how to traverse nodes; they just know how to evaluate a single node against the provided filter. */
10951 interface NodeFilter {
10952     acceptNode(node: Node): number;
10953 }
10954
10955 declare var NodeFilter: {
10956     readonly FILTER_ACCEPT: number;
10957     readonly FILTER_REJECT: number;
10958     readonly FILTER_SKIP: number;
10959     readonly SHOW_ALL: number;
10960     readonly SHOW_ATTRIBUTE: number;
10961     readonly SHOW_CDATA_SECTION: number;
10962     readonly SHOW_COMMENT: number;
10963     readonly SHOW_DOCUMENT: number;
10964     readonly SHOW_DOCUMENT_FRAGMENT: number;
10965     readonly SHOW_DOCUMENT_TYPE: number;
10966     readonly SHOW_ELEMENT: number;
10967     readonly SHOW_ENTITY: number;
10968     readonly SHOW_ENTITY_REFERENCE: number;
10969     readonly SHOW_NOTATION: number;
10970     readonly SHOW_PROCESSING_INSTRUCTION: number;
10971     readonly SHOW_TEXT: number;
10972 };
10973
10974 /** 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. */
10975 interface NodeIterator {
10976     readonly filter: NodeFilter | null;
10977     readonly pointerBeforeReferenceNode: boolean;
10978     readonly referenceNode: Node;
10979     readonly root: Node;
10980     readonly whatToShow: number;
10981     detach(): void;
10982     nextNode(): Node | null;
10983     previousNode(): Node | null;
10984 }
10985
10986 declare var NodeIterator: {
10987     prototype: NodeIterator;
10988     new(): NodeIterator;
10989 };
10990
10991 /** NodeList objects are collections of nodes, usually returned by properties such as Node.childNodes and methods such as document.querySelectorAll(). */
10992 interface NodeList {
10993     /**
10994      * Returns the number of nodes in the collection.
10995      */
10996     readonly length: number;
10997     /**
10998      * Returns the node with index index from the collection. The nodes are sorted in tree order.
10999      */
11000     item(index: number): Node | null;
11001     /**
11002      * Performs the specified action for each node in an list.
11003      * @param callbackfn  A function that accepts up to three arguments. forEach calls the callbackfn function one time for each element in the list.
11004      * @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.
11005      */
11006     forEach(callbackfn: (value: Node, key: number, parent: NodeList) => void, thisArg?: any): void;
11007     [index: number]: Node;
11008 }
11009
11010 declare var NodeList: {
11011     prototype: NodeList;
11012     new(): NodeList;
11013 };
11014
11015 interface NodeListOf<TNode extends Node> extends NodeList {
11016     length: number;
11017     item(index: number): TNode;
11018     /**
11019      * Performs the specified action for each node in an list.
11020      * @param callbackfn  A function that accepts up to three arguments. forEach calls the callbackfn function one time for each element in the list.
11021      * @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.
11022      */
11023     forEach(callbackfn: (value: TNode, key: number, parent: NodeListOf<TNode>) => void, thisArg?: any): void;
11024     [index: number]: TNode;
11025 }
11026
11027 interface NonDocumentTypeChildNode {
11028     /**
11029      * Returns the first following sibling that is an element, and null otherwise.
11030      */
11031     readonly nextElementSibling: Element | null;
11032     /**
11033      * Returns the first preceding sibling that is an element, and null otherwise.
11034      */
11035     readonly previousElementSibling: Element | null;
11036 }
11037
11038 interface NonElementParentNode {
11039     /**
11040      * Returns the first element within node's descendants whose ID is elementId.
11041      */
11042     getElementById(elementId: string): Element | null;
11043 }
11044
11045 interface NotificationEventMap {
11046     "click": Event;
11047     "close": Event;
11048     "error": Event;
11049     "show": Event;
11050 }
11051
11052 /** This Notifications API interface is used to configure and display desktop notifications to the user. */
11053 interface Notification extends EventTarget {
11054     readonly actions: ReadonlyArray<NotificationAction>;
11055     readonly badge: string;
11056     readonly body: string;
11057     readonly data: any;
11058     readonly dir: NotificationDirection;
11059     readonly icon: string;
11060     readonly image: string;
11061     readonly lang: string;
11062     onclick: ((this: Notification, ev: Event) => any) | null;
11063     onclose: ((this: Notification, ev: Event) => any) | null;
11064     onerror: ((this: Notification, ev: Event) => any) | null;
11065     onshow: ((this: Notification, ev: Event) => any) | null;
11066     readonly renotify: boolean;
11067     readonly requireInteraction: boolean;
11068     readonly silent: boolean;
11069     readonly tag: string;
11070     readonly timestamp: number;
11071     readonly title: string;
11072     readonly vibrate: ReadonlyArray<number>;
11073     close(): void;
11074     addEventListener<K extends keyof NotificationEventMap>(type: K, listener: (this: Notification, ev: NotificationEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11075     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11076     removeEventListener<K extends keyof NotificationEventMap>(type: K, listener: (this: Notification, ev: NotificationEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11077     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11078 }
11079
11080 declare var Notification: {
11081     prototype: Notification;
11082     new(title: string, options?: NotificationOptions): Notification;
11083     readonly maxActions: number;
11084     readonly permission: NotificationPermission;
11085     requestPermission(deprecatedCallback?: NotificationPermissionCallback): Promise<NotificationPermission>;
11086 };
11087
11088 /** The OES_element_index_uint extension is part of the WebGL API and adds support for gl.UNSIGNED_INT types to WebGLRenderingContext.drawElements(). */
11089 interface OES_element_index_uint {
11090 }
11091
11092 /** The OES_standard_derivatives extension is part of the WebGL API and adds the GLSL derivative functions dFdx, dFdy, and fwidth. */
11093 interface OES_standard_derivatives {
11094     readonly FRAGMENT_SHADER_DERIVATIVE_HINT_OES: GLenum;
11095 }
11096
11097 /** The OES_texture_float extension is part of the WebGL API and exposes floating-point pixel types for textures. */
11098 interface OES_texture_float {
11099 }
11100
11101 /** The OES_texture_float_linear extension is part of the WebGL API and allows linear filtering with floating-point pixel types for textures. */
11102 interface OES_texture_float_linear {
11103 }
11104
11105 /** 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. */
11106 interface OES_texture_half_float {
11107     readonly HALF_FLOAT_OES: GLenum;
11108 }
11109
11110 /** 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. */
11111 interface OES_texture_half_float_linear {
11112 }
11113
11114 interface OES_vertex_array_object {
11115     bindVertexArrayOES(arrayObject: WebGLVertexArrayObjectOES | null): void;
11116     createVertexArrayOES(): WebGLVertexArrayObjectOES | null;
11117     deleteVertexArrayOES(arrayObject: WebGLVertexArrayObjectOES | null): void;
11118     isVertexArrayOES(arrayObject: WebGLVertexArrayObjectOES | null): GLboolean;
11119     readonly VERTEX_ARRAY_BINDING_OES: GLenum;
11120 }
11121
11122 /** The Web Audio API OfflineAudioCompletionEvent interface represents events that occur when the processing of an OfflineAudioContext is terminated. The complete event implements this interface. */
11123 interface OfflineAudioCompletionEvent extends Event {
11124     readonly renderedBuffer: AudioBuffer;
11125 }
11126
11127 declare var OfflineAudioCompletionEvent: {
11128     prototype: OfflineAudioCompletionEvent;
11129     new(type: string, eventInitDict: OfflineAudioCompletionEventInit): OfflineAudioCompletionEvent;
11130 };
11131
11132 interface OfflineAudioContextEventMap extends BaseAudioContextEventMap {
11133     "complete": OfflineAudioCompletionEvent;
11134 }
11135
11136 /** 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. */
11137 interface OfflineAudioContext extends BaseAudioContext {
11138     readonly length: number;
11139     oncomplete: ((this: OfflineAudioContext, ev: OfflineAudioCompletionEvent) => any) | null;
11140     resume(): Promise<void>;
11141     startRendering(): Promise<AudioBuffer>;
11142     suspend(suspendTime: number): Promise<void>;
11143     addEventListener<K extends keyof OfflineAudioContextEventMap>(type: K, listener: (this: OfflineAudioContext, ev: OfflineAudioContextEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11144     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11145     removeEventListener<K extends keyof OfflineAudioContextEventMap>(type: K, listener: (this: OfflineAudioContext, ev: OfflineAudioContextEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11146     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11147 }
11148
11149 declare var OfflineAudioContext: {
11150     prototype: OfflineAudioContext;
11151     new(contextOptions: OfflineAudioContextOptions): OfflineAudioContext;
11152     new(numberOfChannels: number, length: number, sampleRate: number): OfflineAudioContext;
11153 };
11154
11155 interface OffscreenCanvas extends EventTarget {
11156     /**
11157      * These attributes return the dimensions of the OffscreenCanvas object's bitmap.
11158      *
11159      * They can be set, to replace the bitmap with a new, transparent black bitmap of the specified dimensions (effectively resizing it).
11160      */
11161     height: number;
11162     /**
11163      * These attributes return the dimensions of the OffscreenCanvas object's bitmap.
11164      *
11165      * They can be set, to replace the bitmap with a new, transparent black bitmap of the specified dimensions (effectively resizing it).
11166      */
11167     width: number;
11168     /**
11169      * Returns a promise that will fulfill with a new Blob object representing a file containing the image in the OffscreenCanvas object.
11170      *
11171      * The argument, if provided, is a dictionary that controls the encoding options of the image file to be created. The type field specifies the file format and has a default value of "image/png"; that type is also used if the requested type isn't supported. If the image format supports variable quality (such as "image/jpeg"), then the quality field is a number in the range 0.0 to 1.0 inclusive indicating the desired quality level for the resulting image.
11172      */
11173     convertToBlob(options?: ImageEncodeOptions): Promise<Blob>;
11174     /**
11175      * Returns an object that exposes an API for drawing on the OffscreenCanvas object. contextId specifies the desired API: "2d", "bitmaprenderer", "webgl", or "webgl2". options is handled by that API.
11176      *
11177      * This specification defines the "2d" context below, which is similar but distinct from the "2d" context that is created from a canvas element. The WebGL specifications define the "webgl" and "webgl2" contexts. [WEBGL]
11178      *
11179      * Returns null if the canvas has already been initialized with another context type (e.g., trying to get a "2d" context after getting a "webgl" context).
11180      */
11181     getContext(contextId: "2d", options?: CanvasRenderingContext2DSettings): OffscreenCanvasRenderingContext2D | null;
11182     getContext(contextId: "bitmaprenderer", options?: ImageBitmapRenderingContextSettings): ImageBitmapRenderingContext | null;
11183     getContext(contextId: "webgl", options?: WebGLContextAttributes): WebGLRenderingContext | null;
11184     getContext(contextId: "webgl2", options?: WebGLContextAttributes): WebGL2RenderingContext | null;
11185     getContext(contextId: OffscreenRenderingContextId, options?: any): OffscreenRenderingContext | null;
11186     /**
11187      * Returns a newly created ImageBitmap object with the image in the OffscreenCanvas object. The image in the OffscreenCanvas object is replaced with a new blank image.
11188      */
11189     transferToImageBitmap(): ImageBitmap;
11190 }
11191
11192 declare var OffscreenCanvas: {
11193     prototype: OffscreenCanvas;
11194     new(width: number, height: number): OffscreenCanvas;
11195 };
11196
11197 interface OffscreenCanvasRenderingContext2D extends CanvasCompositing, CanvasDrawImage, CanvasDrawPath, CanvasFillStrokeStyles, CanvasFilters, CanvasImageData, CanvasImageSmoothing, CanvasPath, CanvasPathDrawingStyles, CanvasRect, CanvasShadowStyles, CanvasState, CanvasText, CanvasTextDrawingStyles, CanvasTransform {
11198     readonly canvas: OffscreenCanvas;
11199     commit(): void;
11200 }
11201
11202 declare var OffscreenCanvasRenderingContext2D: {
11203     prototype: OffscreenCanvasRenderingContext2D;
11204     new(): OffscreenCanvasRenderingContext2D;
11205 };
11206
11207 /** 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. */
11208 interface OscillatorNode extends AudioScheduledSourceNode {
11209     readonly detune: AudioParam;
11210     readonly frequency: AudioParam;
11211     type: OscillatorType;
11212     setPeriodicWave(periodicWave: PeriodicWave): void;
11213     addEventListener<K extends keyof AudioScheduledSourceNodeEventMap>(type: K, listener: (this: OscillatorNode, ev: AudioScheduledSourceNodeEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11214     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11215     removeEventListener<K extends keyof AudioScheduledSourceNodeEventMap>(type: K, listener: (this: OscillatorNode, ev: AudioScheduledSourceNodeEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11216     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11217 }
11218
11219 declare var OscillatorNode: {
11220     prototype: OscillatorNode;
11221     new(context: BaseAudioContext, options?: OscillatorOptions): OscillatorNode;
11222 };
11223
11224 interface OverconstrainedError extends Error {
11225     constraint: string;
11226 }
11227
11228 declare var OverconstrainedError: {
11229     prototype: OverconstrainedError;
11230     new(): OverconstrainedError;
11231 };
11232
11233 interface OverflowEvent extends UIEvent {
11234     readonly horizontalOverflow: boolean;
11235     readonly orient: number;
11236     readonly verticalOverflow: boolean;
11237     readonly BOTH: number;
11238     readonly HORIZONTAL: number;
11239     readonly VERTICAL: number;
11240 }
11241
11242 declare var OverflowEvent: {
11243     prototype: OverflowEvent;
11244     new(): OverflowEvent;
11245     readonly BOTH: number;
11246     readonly HORIZONTAL: number;
11247     readonly VERTICAL: number;
11248 };
11249
11250 /** The PageTransitionEvent is fired when a document is being loaded or unloaded. */
11251 interface PageTransitionEvent extends Event {
11252     /**
11253      * For the pageshow event, returns false if the page is newly being loaded (and the load event will fire). Otherwise, returns true.
11254      *
11255      * 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.
11256      *
11257      * Things that can cause the page to be unsalvageable include:
11258      *
11259      * Listening for beforeunload events
11260      * Listening for unload events
11261      * Having iframes that are not salvageable
11262      * Active WebSocket objects
11263      * Aborting a Document
11264      */
11265     readonly persisted: boolean;
11266 }
11267
11268 declare var PageTransitionEvent: {
11269     prototype: PageTransitionEvent;
11270     new(type: string, eventInitDict?: PageTransitionEventInit): PageTransitionEvent;
11271 };
11272
11273 /** 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! */
11274 interface PannerNode extends AudioNode {
11275     coneInnerAngle: number;
11276     coneOuterAngle: number;
11277     coneOuterGain: number;
11278     distanceModel: DistanceModelType;
11279     maxDistance: number;
11280     readonly orientationX: AudioParam;
11281     readonly orientationY: AudioParam;
11282     readonly orientationZ: AudioParam;
11283     panningModel: PanningModelType;
11284     readonly positionX: AudioParam;
11285     readonly positionY: AudioParam;
11286     readonly positionZ: AudioParam;
11287     refDistance: number;
11288     rolloffFactor: number;
11289     /** @deprecated */
11290     setOrientation(x: number, y: number, z: number): void;
11291     /** @deprecated */
11292     setPosition(x: number, y: number, z: number): void;
11293 }
11294
11295 declare var PannerNode: {
11296     prototype: PannerNode;
11297     new(context: BaseAudioContext, options?: PannerOptions): PannerNode;
11298 };
11299
11300 interface ParentNode {
11301     readonly childElementCount: number;
11302     /**
11303      * Returns the child elements.
11304      */
11305     readonly children: HTMLCollection;
11306     /**
11307      * Returns the first child that is an element, and null otherwise.
11308      */
11309     readonly firstElementChild: Element | null;
11310     /**
11311      * Returns the last child that is an element, and null otherwise.
11312      */
11313     readonly lastElementChild: Element | null;
11314     /**
11315      * Inserts nodes after the last child of node, while replacing strings in nodes with equivalent Text nodes.
11316      *
11317      * Throws a "HierarchyRequestError" DOMException if the constraints of the node tree are violated.
11318      */
11319     append(...nodes: (Node | string)[]): void;
11320     /**
11321      * Inserts nodes before the first child of node, while replacing strings in nodes with equivalent Text nodes.
11322      *
11323      * Throws a "HierarchyRequestError" DOMException if the constraints of the node tree are violated.
11324      */
11325     prepend(...nodes: (Node | string)[]): void;
11326     /**
11327      * Returns the first element that is a descendant of node that matches selectors.
11328      */
11329     querySelector<K extends keyof HTMLElementTagNameMap>(selectors: K): HTMLElementTagNameMap[K] | null;
11330     querySelector<K extends keyof SVGElementTagNameMap>(selectors: K): SVGElementTagNameMap[K] | null;
11331     querySelector<E extends Element = Element>(selectors: string): E | null;
11332     /**
11333      * Returns all element descendants of node that match selectors.
11334      */
11335     querySelectorAll<K extends keyof HTMLElementTagNameMap>(selectors: K): NodeListOf<HTMLElementTagNameMap[K]>;
11336     querySelectorAll<K extends keyof SVGElementTagNameMap>(selectors: K): NodeListOf<SVGElementTagNameMap[K]>;
11337     querySelectorAll<E extends Element = Element>(selectors: string): NodeListOf<E>;
11338 }
11339
11340 /** 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. */
11341 interface Path2D extends CanvasPath {
11342     /**
11343      * Adds to the path the path given by the argument.
11344      */
11345     addPath(path: Path2D, transform?: DOMMatrix2DInit): void;
11346 }
11347
11348 declare var Path2D: {
11349     prototype: Path2D;
11350     new(path?: Path2D | string): Path2D;
11351 };
11352
11353 /** This Payment Request API interface is used to store shipping or payment address information. */
11354 interface PaymentAddress {
11355     readonly addressLine: string[];
11356     readonly city: string;
11357     readonly country: string;
11358     readonly dependentLocality: string;
11359     readonly languageCode: string;
11360     readonly organization: string;
11361     readonly phone: string;
11362     readonly postalCode: string;
11363     readonly recipient: string;
11364     readonly region: string;
11365     readonly sortingCode: string;
11366     toJSON(): any;
11367 }
11368
11369 declare var PaymentAddress: {
11370     prototype: PaymentAddress;
11371     new(): PaymentAddress;
11372 };
11373
11374 interface PaymentRequestEventMap {
11375     "shippingaddresschange": Event;
11376     "shippingoptionchange": Event;
11377 }
11378
11379 /** 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. */
11380 interface PaymentRequest extends EventTarget {
11381     readonly id: string;
11382     onshippingaddresschange: ((this: PaymentRequest, ev: Event) => any) | null;
11383     onshippingoptionchange: ((this: PaymentRequest, ev: Event) => any) | null;
11384     readonly shippingAddress: PaymentAddress | null;
11385     readonly shippingOption: string | null;
11386     readonly shippingType: PaymentShippingType | null;
11387     abort(): Promise<void>;
11388     canMakePayment(): Promise<boolean>;
11389     show(): Promise<PaymentResponse>;
11390     addEventListener<K extends keyof PaymentRequestEventMap>(type: K, listener: (this: PaymentRequest, ev: PaymentRequestEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11391     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11392     removeEventListener<K extends keyof PaymentRequestEventMap>(type: K, listener: (this: PaymentRequest, ev: PaymentRequestEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11393     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11394 }
11395
11396 declare var PaymentRequest: {
11397     prototype: PaymentRequest;
11398     new(methodData: PaymentMethodData[], details: PaymentDetailsInit, options?: PaymentOptions): PaymentRequest;
11399 };
11400
11401 /** This Payment Request API interface enables a web page to update the details of a PaymentRequest in response to a user action. */
11402 interface PaymentRequestUpdateEvent extends Event {
11403     updateWith(detailsPromise: PaymentDetailsUpdate | Promise<PaymentDetailsUpdate>): void;
11404 }
11405
11406 declare var PaymentRequestUpdateEvent: {
11407     prototype: PaymentRequestUpdateEvent;
11408     new(type: string, eventInitDict?: PaymentRequestUpdateEventInit): PaymentRequestUpdateEvent;
11409 };
11410
11411 /** This Payment Request API interface is returned after a user selects a payment method and approves a payment request. */
11412 interface PaymentResponse {
11413     readonly details: any;
11414     readonly methodName: string;
11415     readonly payerEmail: string | null;
11416     readonly payerName: string | null;
11417     readonly payerPhone: string | null;
11418     readonly requestId: string;
11419     readonly shippingAddress: PaymentAddress | null;
11420     readonly shippingOption: string | null;
11421     complete(result?: PaymentComplete): Promise<void>;
11422     toJSON(): any;
11423 }
11424
11425 declare var PaymentResponse: {
11426     prototype: PaymentResponse;
11427     new(): PaymentResponse;
11428 };
11429
11430 interface PerfWidgetExternal {
11431     readonly activeNetworkRequestCount: number;
11432     readonly averageFrameTime: number;
11433     readonly averagePaintTime: number;
11434     readonly extraInformationEnabled: boolean;
11435     readonly independentRenderingEnabled: boolean;
11436     readonly irDisablingContentString: string;
11437     readonly irStatusAvailable: boolean;
11438     readonly maxCpuSpeed: number;
11439     readonly paintRequestsPerSecond: number;
11440     readonly performanceCounter: number;
11441     readonly performanceCounterFrequency: number;
11442     addEventListener(eventType: string, callback: Function): void;
11443     getMemoryUsage(): number;
11444     getProcessCpuUsage(): number;
11445     getRecentCpuUsage(last: number | null): any;
11446     getRecentFrames(last: number | null): any;
11447     getRecentMemoryUsage(last: number | null): any;
11448     getRecentPaintRequests(last: number | null): any;
11449     removeEventListener(eventType: string, callback: Function): void;
11450     repositionWindow(x: number, y: number): void;
11451     resizeWindow(width: number, height: number): void;
11452 }
11453
11454 declare var PerfWidgetExternal: {
11455     prototype: PerfWidgetExternal;
11456     new(): PerfWidgetExternal;
11457 };
11458
11459 interface PerformanceEventMap {
11460     "resourcetimingbufferfull": Event;
11461 }
11462
11463 /** 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. */
11464 interface Performance extends EventTarget {
11465     /** @deprecated */
11466     readonly navigation: PerformanceNavigation;
11467     onresourcetimingbufferfull: ((this: Performance, ev: Event) => any) | null;
11468     readonly timeOrigin: number;
11469     /** @deprecated */
11470     readonly timing: PerformanceTiming;
11471     clearMarks(markName?: string): void;
11472     clearMeasures(measureName?: string): void;
11473     clearResourceTimings(): void;
11474     getEntries(): PerformanceEntryList;
11475     getEntriesByName(name: string, type?: string): PerformanceEntryList;
11476     getEntriesByType(type: string): PerformanceEntryList;
11477     mark(markName: string): void;
11478     measure(measureName: string, startMark?: string, endMark?: string): void;
11479     now(): number;
11480     setResourceTimingBufferSize(maxSize: number): void;
11481     toJSON(): any;
11482     addEventListener<K extends keyof PerformanceEventMap>(type: K, listener: (this: Performance, ev: PerformanceEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11483     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11484     removeEventListener<K extends keyof PerformanceEventMap>(type: K, listener: (this: Performance, ev: PerformanceEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11485     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11486 }
11487
11488 declare var Performance: {
11489     prototype: Performance;
11490     new(): Performance;
11491 };
11492
11493 /** 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). */
11494 interface PerformanceEntry {
11495     readonly duration: number;
11496     readonly entryType: string;
11497     readonly name: string;
11498     readonly startTime: number;
11499     toJSON(): any;
11500 }
11501
11502 declare var PerformanceEntry: {
11503     prototype: PerformanceEntry;
11504     new(): PerformanceEntry;
11505 };
11506
11507 /** 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. */
11508 interface PerformanceMark extends PerformanceEntry {
11509 }
11510
11511 declare var PerformanceMark: {
11512     prototype: PerformanceMark;
11513     new(): PerformanceMark;
11514 };
11515
11516 /** 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. */
11517 interface PerformanceMeasure extends PerformanceEntry {
11518 }
11519
11520 declare var PerformanceMeasure: {
11521     prototype: PerformanceMeasure;
11522     new(): PerformanceMeasure;
11523 };
11524
11525 /** The legacy PerformanceNavigation interface represents information about how the navigation to the current document was done. */
11526 interface PerformanceNavigation {
11527     readonly redirectCount: number;
11528     readonly type: number;
11529     toJSON(): any;
11530     readonly TYPE_BACK_FORWARD: number;
11531     readonly TYPE_NAVIGATE: number;
11532     readonly TYPE_RELOAD: number;
11533     readonly TYPE_RESERVED: number;
11534 }
11535
11536 declare var PerformanceNavigation: {
11537     prototype: PerformanceNavigation;
11538     new(): PerformanceNavigation;
11539     readonly TYPE_BACK_FORWARD: number;
11540     readonly TYPE_NAVIGATE: number;
11541     readonly TYPE_RELOAD: number;
11542     readonly TYPE_RESERVED: number;
11543 };
11544
11545 /** 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. */
11546 interface PerformanceNavigationTiming extends PerformanceResourceTiming {
11547     readonly domComplete: number;
11548     readonly domContentLoadedEventEnd: number;
11549     readonly domContentLoadedEventStart: number;
11550     readonly domInteractive: number;
11551     readonly loadEventEnd: number;
11552     readonly loadEventStart: number;
11553     readonly redirectCount: number;
11554     readonly type: NavigationType;
11555     readonly unloadEventEnd: number;
11556     readonly unloadEventStart: number;
11557     toJSON(): any;
11558 }
11559
11560 declare var PerformanceNavigationTiming: {
11561     prototype: PerformanceNavigationTiming;
11562     new(): PerformanceNavigationTiming;
11563 };
11564
11565 interface PerformanceObserver {
11566     disconnect(): void;
11567     observe(options?: PerformanceObserverInit): void;
11568     takeRecords(): PerformanceEntryList;
11569 }
11570
11571 declare var PerformanceObserver: {
11572     prototype: PerformanceObserver;
11573     new(callback: PerformanceObserverCallback): PerformanceObserver;
11574     readonly supportedEntryTypes: ReadonlyArray<string>;
11575 };
11576
11577 interface PerformanceObserverEntryList {
11578     getEntries(): PerformanceEntryList;
11579     getEntriesByName(name: string, type?: string): PerformanceEntryList;
11580     getEntriesByType(type: string): PerformanceEntryList;
11581 }
11582
11583 declare var PerformanceObserverEntryList: {
11584     prototype: PerformanceObserverEntryList;
11585     new(): PerformanceObserverEntryList;
11586 };
11587
11588 /** 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. */
11589 interface PerformanceResourceTiming extends PerformanceEntry {
11590     readonly connectEnd: number;
11591     readonly connectStart: number;
11592     readonly decodedBodySize: number;
11593     readonly domainLookupEnd: number;
11594     readonly domainLookupStart: number;
11595     readonly encodedBodySize: number;
11596     readonly fetchStart: number;
11597     readonly initiatorType: string;
11598     readonly nextHopProtocol: string;
11599     readonly redirectEnd: number;
11600     readonly redirectStart: number;
11601     readonly requestStart: number;
11602     readonly responseEnd: number;
11603     readonly responseStart: number;
11604     readonly secureConnectionStart: number;
11605     readonly transferSize: number;
11606     readonly workerStart: number;
11607     toJSON(): any;
11608 }
11609
11610 declare var PerformanceResourceTiming: {
11611     prototype: PerformanceResourceTiming;
11612     new(): PerformanceResourceTiming;
11613 };
11614
11615 /** 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. */
11616 interface PerformanceTiming {
11617     readonly connectEnd: number;
11618     readonly connectStart: number;
11619     readonly domComplete: number;
11620     readonly domContentLoadedEventEnd: number;
11621     readonly domContentLoadedEventStart: number;
11622     readonly domInteractive: number;
11623     readonly domLoading: number;
11624     readonly domainLookupEnd: number;
11625     readonly domainLookupStart: number;
11626     readonly fetchStart: number;
11627     readonly loadEventEnd: number;
11628     readonly loadEventStart: number;
11629     readonly navigationStart: number;
11630     readonly redirectEnd: number;
11631     readonly redirectStart: number;
11632     readonly requestStart: number;
11633     readonly responseEnd: number;
11634     readonly responseStart: number;
11635     readonly secureConnectionStart: number;
11636     readonly unloadEventEnd: number;
11637     readonly unloadEventStart: number;
11638     toJSON(): any;
11639 }
11640
11641 declare var PerformanceTiming: {
11642     prototype: PerformanceTiming;
11643     new(): PerformanceTiming;
11644 };
11645
11646 /** 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(). */
11647 interface PeriodicWave {
11648 }
11649
11650 declare var PeriodicWave: {
11651     prototype: PeriodicWave;
11652     new(context: BaseAudioContext, options?: PeriodicWaveOptions): PeriodicWave;
11653 };
11654
11655 interface PermissionRequest extends DeferredPermissionRequest {
11656     readonly state: MSWebViewPermissionState;
11657     defer(): void;
11658 }
11659
11660 declare var PermissionRequest: {
11661     prototype: PermissionRequest;
11662     new(): PermissionRequest;
11663 };
11664
11665 interface PermissionRequestedEvent extends Event {
11666     readonly permissionRequest: PermissionRequest;
11667 }
11668
11669 declare var PermissionRequestedEvent: {
11670     prototype: PermissionRequestedEvent;
11671     new(): PermissionRequestedEvent;
11672 };
11673
11674 interface PermissionStatusEventMap {
11675     "change": Event;
11676 }
11677
11678 interface PermissionStatus extends EventTarget {
11679     onchange: ((this: PermissionStatus, ev: Event) => any) | null;
11680     readonly state: PermissionState;
11681     addEventListener<K extends keyof PermissionStatusEventMap>(type: K, listener: (this: PermissionStatus, ev: PermissionStatusEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11682     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11683     removeEventListener<K extends keyof PermissionStatusEventMap>(type: K, listener: (this: PermissionStatus, ev: PermissionStatusEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11684     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11685 }
11686
11687 declare var PermissionStatus: {
11688     prototype: PermissionStatus;
11689     new(): PermissionStatus;
11690 };
11691
11692 interface Permissions {
11693     query(permissionDesc: PermissionDescriptor | DevicePermissionDescriptor | MidiPermissionDescriptor | PushPermissionDescriptor): Promise<PermissionStatus>;
11694 }
11695
11696 declare var Permissions: {
11697     prototype: Permissions;
11698     new(): Permissions;
11699 };
11700
11701 /** Provides information about a browser plugin. */
11702 interface Plugin {
11703     /**
11704      * Returns the plugin's description.
11705      */
11706     readonly description: string;
11707     /**
11708      * Returns the plugin library's filename, if applicable on the current platform.
11709      */
11710     readonly filename: string;
11711     /**
11712      * Returns the number of MIME types, represented by MimeType objects, supported by the plugin.
11713      */
11714     readonly length: number;
11715     /**
11716      * Returns the plugin's name.
11717      */
11718     readonly name: string;
11719     /**
11720      * Returns the specified MimeType object.
11721      */
11722     item(index: number): MimeType | null;
11723     namedItem(name: string): MimeType | null;
11724     [index: number]: MimeType;
11725 }
11726
11727 declare var Plugin: {
11728     prototype: Plugin;
11729     new(): Plugin;
11730 };
11731
11732 /** 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. */
11733 interface PluginArray {
11734     readonly length: number;
11735     item(index: number): Plugin | null;
11736     namedItem(name: string): Plugin | null;
11737     refresh(reload?: boolean): void;
11738     [index: number]: Plugin;
11739 }
11740
11741 declare var PluginArray: {
11742     prototype: PluginArray;
11743     new(): PluginArray;
11744 };
11745
11746 /** 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. */
11747 interface PointerEvent extends MouseEvent {
11748     readonly height: number;
11749     readonly isPrimary: boolean;
11750     readonly pointerId: number;
11751     readonly pointerType: string;
11752     readonly pressure: number;
11753     readonly tangentialPressure: number;
11754     readonly tiltX: number;
11755     readonly tiltY: number;
11756     readonly twist: number;
11757     readonly width: number;
11758 }
11759
11760 declare var PointerEvent: {
11761     prototype: PointerEvent;
11762     new(type: string, eventInitDict?: PointerEventInit): PointerEvent;
11763 };
11764
11765 /** PopStateEvent is an event handler for the popstate event on the window. */
11766 interface PopStateEvent extends Event {
11767     /**
11768      * Returns a copy of the information that was provided to pushState() or replaceState().
11769      */
11770     readonly state: any;
11771 }
11772
11773 declare var PopStateEvent: {
11774     prototype: PopStateEvent;
11775     new(type: string, eventInitDict?: PopStateEventInit): PopStateEvent;
11776 };
11777
11778 /** The position of the concerned device at a given time. The position, represented by a Coordinates object, comprehends the 2D position of the device, on a spheroid representing the Earth, but also its altitude and its speed. */
11779 interface Position {
11780     readonly coords: Coordinates;
11781     readonly timestamp: number;
11782 }
11783
11784 /** The reason of an error occurring when using the geolocating device. */
11785 interface PositionError {
11786     readonly code: number;
11787     readonly message: string;
11788     readonly PERMISSION_DENIED: number;
11789     readonly POSITION_UNAVAILABLE: number;
11790     readonly TIMEOUT: number;
11791 }
11792
11793 /** A processing instruction embeds application-specific instructions in XML which can be ignored by other applications that don't recognize them. */
11794 interface ProcessingInstruction extends CharacterData, LinkStyle {
11795     readonly ownerDocument: Document;
11796     readonly target: string;
11797 }
11798
11799 declare var ProcessingInstruction: {
11800     prototype: ProcessingInstruction;
11801     new(): ProcessingInstruction;
11802 };
11803
11804 /** 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>). */
11805 interface ProgressEvent<T extends EventTarget = EventTarget> extends Event {
11806     readonly lengthComputable: boolean;
11807     readonly loaded: number;
11808     readonly target: T | null;
11809     readonly total: number;
11810 }
11811
11812 declare var ProgressEvent: {
11813     prototype: ProgressEvent;
11814     new(type: string, eventInitDict?: ProgressEventInit): ProgressEvent;
11815 };
11816
11817 interface PromiseRejectionEvent extends Event {
11818     readonly promise: Promise<any>;
11819     readonly reason: any;
11820 }
11821
11822 declare var PromiseRejectionEvent: {
11823     prototype: PromiseRejectionEvent;
11824     new(type: string, eventInitDict: PromiseRejectionEventInit): PromiseRejectionEvent;
11825 };
11826
11827 interface PublicKeyCredential extends Credential {
11828     readonly rawId: ArrayBuffer;
11829     readonly response: AuthenticatorResponse;
11830     getClientExtensionResults(): AuthenticationExtensionsClientOutputs;
11831 }
11832
11833 declare var PublicKeyCredential: {
11834     prototype: PublicKeyCredential;
11835     new(): PublicKeyCredential;
11836     isUserVerifyingPlatformAuthenticatorAvailable(): Promise<boolean>;
11837 };
11838
11839 /** This Push API interface provides a way to receive notifications from third-party servers as well as request URLs for push notifications. */
11840 interface PushManager {
11841     getSubscription(): Promise<PushSubscription | null>;
11842     permissionState(options?: PushSubscriptionOptionsInit): Promise<PushPermissionState>;
11843     subscribe(options?: PushSubscriptionOptionsInit): Promise<PushSubscription>;
11844 }
11845
11846 declare var PushManager: {
11847     prototype: PushManager;
11848     new(): PushManager;
11849     readonly supportedContentEncodings: ReadonlyArray<string>;
11850 };
11851
11852 /** This Push API interface provides a subcription's URL endpoint and allows unsubscription from a push service. */
11853 interface PushSubscription {
11854     readonly endpoint: string;
11855     readonly expirationTime: number | null;
11856     readonly options: PushSubscriptionOptions;
11857     getKey(name: PushEncryptionKeyName): ArrayBuffer | null;
11858     toJSON(): PushSubscriptionJSON;
11859     unsubscribe(): Promise<boolean>;
11860 }
11861
11862 declare var PushSubscription: {
11863     prototype: PushSubscription;
11864     new(): PushSubscription;
11865 };
11866
11867 interface PushSubscriptionOptions {
11868     readonly applicationServerKey: ArrayBuffer | null;
11869     readonly userVisibleOnly: boolean;
11870 }
11871
11872 declare var PushSubscriptionOptions: {
11873     prototype: PushSubscriptionOptions;
11874     new(): PushSubscriptionOptions;
11875 };
11876
11877 interface RTCCertificate {
11878     readonly expires: number;
11879     getFingerprints(): RTCDtlsFingerprint[];
11880 }
11881
11882 declare var RTCCertificate: {
11883     prototype: RTCCertificate;
11884     new(): RTCCertificate;
11885     getSupportedAlgorithms(): AlgorithmIdentifier[];
11886 };
11887
11888 interface RTCDTMFSenderEventMap {
11889     "tonechange": RTCDTMFToneChangeEvent;
11890 }
11891
11892 interface RTCDTMFSender extends EventTarget {
11893     readonly canInsertDTMF: boolean;
11894     ontonechange: ((this: RTCDTMFSender, ev: RTCDTMFToneChangeEvent) => any) | null;
11895     readonly toneBuffer: string;
11896     insertDTMF(tones: string, duration?: number, interToneGap?: number): void;
11897     addEventListener<K extends keyof RTCDTMFSenderEventMap>(type: K, listener: (this: RTCDTMFSender, ev: RTCDTMFSenderEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11898     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11899     removeEventListener<K extends keyof RTCDTMFSenderEventMap>(type: K, listener: (this: RTCDTMFSender, ev: RTCDTMFSenderEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11900     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11901 }
11902
11903 declare var RTCDTMFSender: {
11904     prototype: RTCDTMFSender;
11905     new(): RTCDTMFSender;
11906 };
11907
11908 /** Events sent to indicate that DTMF tones have started or finished playing. This interface is used by the tonechange event. */
11909 interface RTCDTMFToneChangeEvent extends Event {
11910     readonly tone: string;
11911 }
11912
11913 declare var RTCDTMFToneChangeEvent: {
11914     prototype: RTCDTMFToneChangeEvent;
11915     new(type: string, eventInitDict: RTCDTMFToneChangeEventInit): RTCDTMFToneChangeEvent;
11916 };
11917
11918 interface RTCDataChannelEventMap {
11919     "bufferedamountlow": Event;
11920     "close": Event;
11921     "error": RTCErrorEvent;
11922     "message": MessageEvent;
11923     "open": Event;
11924 }
11925
11926 interface RTCDataChannel extends EventTarget {
11927     binaryType: string;
11928     readonly bufferedAmount: number;
11929     bufferedAmountLowThreshold: number;
11930     readonly id: number | null;
11931     readonly label: string;
11932     readonly maxPacketLifeTime: number | null;
11933     readonly maxRetransmits: number | null;
11934     readonly negotiated: boolean;
11935     onbufferedamountlow: ((this: RTCDataChannel, ev: Event) => any) | null;
11936     onclose: ((this: RTCDataChannel, ev: Event) => any) | null;
11937     onerror: ((this: RTCDataChannel, ev: RTCErrorEvent) => any) | null;
11938     onmessage: ((this: RTCDataChannel, ev: MessageEvent) => any) | null;
11939     onopen: ((this: RTCDataChannel, ev: Event) => any) | null;
11940     readonly ordered: boolean;
11941     readonly priority: RTCPriorityType;
11942     readonly protocol: string;
11943     readonly readyState: RTCDataChannelState;
11944     close(): void;
11945     send(data: string): void;
11946     send(data: Blob): void;
11947     send(data: ArrayBuffer): void;
11948     send(data: ArrayBufferView): void;
11949     addEventListener<K extends keyof RTCDataChannelEventMap>(type: K, listener: (this: RTCDataChannel, ev: RTCDataChannelEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11950     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11951     removeEventListener<K extends keyof RTCDataChannelEventMap>(type: K, listener: (this: RTCDataChannel, ev: RTCDataChannelEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11952     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11953 }
11954
11955 declare var RTCDataChannel: {
11956     prototype: RTCDataChannel;
11957     new(): RTCDataChannel;
11958 };
11959
11960 interface RTCDataChannelEvent extends Event {
11961     readonly channel: RTCDataChannel;
11962 }
11963
11964 declare var RTCDataChannelEvent: {
11965     prototype: RTCDataChannelEvent;
11966     new(type: string, eventInitDict: RTCDataChannelEventInit): RTCDataChannelEvent;
11967 };
11968
11969 interface RTCDtlsTransportEventMap {
11970     "error": RTCErrorEvent;
11971     "statechange": Event;
11972 }
11973
11974 interface RTCDtlsTransport extends EventTarget {
11975     readonly iceTransport: RTCIceTransport;
11976     onerror: ((this: RTCDtlsTransport, ev: RTCErrorEvent) => any) | null;
11977     onstatechange: ((this: RTCDtlsTransport, ev: Event) => any) | null;
11978     readonly state: RTCDtlsTransportState;
11979     getRemoteCertificates(): ArrayBuffer[];
11980     addEventListener<K extends keyof RTCDtlsTransportEventMap>(type: K, listener: (this: RTCDtlsTransport, ev: RTCDtlsTransportEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11981     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11982     removeEventListener<K extends keyof RTCDtlsTransportEventMap>(type: K, listener: (this: RTCDtlsTransport, ev: RTCDtlsTransportEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11983     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11984 }
11985
11986 declare var RTCDtlsTransport: {
11987     prototype: RTCDtlsTransport;
11988     new(): RTCDtlsTransport;
11989 };
11990
11991 interface RTCDtlsTransportStateChangedEvent extends Event {
11992     readonly state: RTCDtlsTransportState;
11993 }
11994
11995 declare var RTCDtlsTransportStateChangedEvent: {
11996     prototype: RTCDtlsTransportStateChangedEvent;
11997     new(): RTCDtlsTransportStateChangedEvent;
11998 };
11999
12000 interface RTCDtmfSenderEventMap {
12001     "tonechange": RTCDTMFToneChangeEvent;
12002 }
12003
12004 interface RTCDtmfSender extends EventTarget {
12005     readonly canInsertDTMF: boolean;
12006     readonly duration: number;
12007     readonly interToneGap: number;
12008     ontonechange: ((this: RTCDtmfSender, ev: RTCDTMFToneChangeEvent) => any) | null;
12009     readonly sender: RTCRtpSender;
12010     readonly toneBuffer: string;
12011     insertDTMF(tones: string, duration?: number, interToneGap?: number): void;
12012     addEventListener<K extends keyof RTCDtmfSenderEventMap>(type: K, listener: (this: RTCDtmfSender, ev: RTCDtmfSenderEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12013     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12014     removeEventListener<K extends keyof RTCDtmfSenderEventMap>(type: K, listener: (this: RTCDtmfSender, ev: RTCDtmfSenderEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12015     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12016 }
12017
12018 declare var RTCDtmfSender: {
12019     prototype: RTCDtmfSender;
12020     new(sender: RTCRtpSender): RTCDtmfSender;
12021 };
12022
12023 interface RTCError extends DOMException {
12024     readonly errorDetail: RTCErrorDetailType;
12025     readonly httpRequestStatusCode: number | null;
12026     readonly receivedAlert: number | null;
12027     readonly sctpCauseCode: number | null;
12028     readonly sdpLineNumber: number | null;
12029     readonly sentAlert: number | null;
12030 }
12031
12032 declare var RTCError: {
12033     prototype: RTCError;
12034     new(init: RTCErrorInit, message?: string): RTCError;
12035 };
12036
12037 interface RTCErrorEvent extends Event {
12038     readonly error: RTCError;
12039 }
12040
12041 declare var RTCErrorEvent: {
12042     prototype: RTCErrorEvent;
12043     new(type: string, eventInitDict: RTCErrorEventInit): RTCErrorEvent;
12044 };
12045
12046 /** The RTCIceCandidate interface—part of the WebRTC API—represents a candidate Internet Connectivity Establishment (ICE) configuration which may be used to establish an RTCPeerConnection. */
12047 interface RTCIceCandidate {
12048     readonly candidate: string;
12049     readonly component: RTCIceComponent | null;
12050     readonly foundation: string | null;
12051     readonly port: number | null;
12052     readonly priority: number | null;
12053     readonly protocol: RTCIceProtocol | null;
12054     readonly relatedAddress: string | null;
12055     readonly relatedPort: number | null;
12056     readonly sdpMLineIndex: number | null;
12057     readonly sdpMid: string | null;
12058     readonly tcpType: RTCIceTcpCandidateType | null;
12059     readonly type: RTCIceCandidateType | null;
12060     readonly usernameFragment: string | null;
12061     toJSON(): RTCIceCandidateInit;
12062 }
12063
12064 declare var RTCIceCandidate: {
12065     prototype: RTCIceCandidate;
12066     new(candidateInitDict?: RTCIceCandidateInit): RTCIceCandidate;
12067 };
12068
12069 interface RTCIceCandidatePairChangedEvent extends Event {
12070     readonly pair: RTCIceCandidatePair;
12071 }
12072
12073 declare var RTCIceCandidatePairChangedEvent: {
12074     prototype: RTCIceCandidatePairChangedEvent;
12075     new(): RTCIceCandidatePairChangedEvent;
12076 };
12077
12078 interface RTCIceGathererEventMap {
12079     "error": Event;
12080     "localcandidate": RTCIceGathererEvent;
12081 }
12082
12083 interface RTCIceGatherer extends RTCStatsProvider {
12084     readonly component: RTCIceComponent;
12085     onerror: ((this: RTCIceGatherer, ev: Event) => any) | null;
12086     onlocalcandidate: ((this: RTCIceGatherer, ev: RTCIceGathererEvent) => any) | null;
12087     createAssociatedGatherer(): RTCIceGatherer;
12088     getLocalCandidates(): RTCIceCandidateDictionary[];
12089     getLocalParameters(): RTCIceParameters;
12090     addEventListener<K extends keyof RTCIceGathererEventMap>(type: K, listener: (this: RTCIceGatherer, ev: RTCIceGathererEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12091     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12092     removeEventListener<K extends keyof RTCIceGathererEventMap>(type: K, listener: (this: RTCIceGatherer, ev: RTCIceGathererEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12093     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12094 }
12095
12096 declare var RTCIceGatherer: {
12097     prototype: RTCIceGatherer;
12098     new(options: RTCIceGatherOptions): RTCIceGatherer;
12099 };
12100
12101 interface RTCIceGathererEvent extends Event {
12102     readonly candidate: RTCIceCandidateDictionary | RTCIceCandidateComplete;
12103 }
12104
12105 declare var RTCIceGathererEvent: {
12106     prototype: RTCIceGathererEvent;
12107     new(): RTCIceGathererEvent;
12108 };
12109
12110 interface RTCIceTransportEventMap {
12111     "gatheringstatechange": Event;
12112     "selectedcandidatepairchange": Event;
12113     "statechange": Event;
12114 }
12115
12116 /** Provides access to information about the ICE transport layer over which the data is being sent and received. */
12117 interface RTCIceTransport extends EventTarget {
12118     readonly component: RTCIceComponent;
12119     readonly gatheringState: RTCIceGathererState;
12120     ongatheringstatechange: ((this: RTCIceTransport, ev: Event) => any) | null;
12121     onselectedcandidatepairchange: ((this: RTCIceTransport, ev: Event) => any) | null;
12122     onstatechange: ((this: RTCIceTransport, ev: Event) => any) | null;
12123     readonly role: RTCIceRole;
12124     readonly state: RTCIceTransportState;
12125     getLocalCandidates(): RTCIceCandidate[];
12126     getLocalParameters(): RTCIceParameters | null;
12127     getRemoteCandidates(): RTCIceCandidate[];
12128     getRemoteParameters(): RTCIceParameters | null;
12129     getSelectedCandidatePair(): RTCIceCandidatePair | null;
12130     addEventListener<K extends keyof RTCIceTransportEventMap>(type: K, listener: (this: RTCIceTransport, ev: RTCIceTransportEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12131     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12132     removeEventListener<K extends keyof RTCIceTransportEventMap>(type: K, listener: (this: RTCIceTransport, ev: RTCIceTransportEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12133     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12134 }
12135
12136 declare var RTCIceTransport: {
12137     prototype: RTCIceTransport;
12138     new(): RTCIceTransport;
12139 };
12140
12141 interface RTCIceTransportStateChangedEvent extends Event {
12142     readonly state: RTCIceTransportState;
12143 }
12144
12145 declare var RTCIceTransportStateChangedEvent: {
12146     prototype: RTCIceTransportStateChangedEvent;
12147     new(): RTCIceTransportStateChangedEvent;
12148 };
12149
12150 interface RTCIdentityAssertion {
12151     idp: string;
12152     name: string;
12153 }
12154
12155 declare var RTCIdentityAssertion: {
12156     prototype: RTCIdentityAssertion;
12157     new(idp: string, name: string): RTCIdentityAssertion;
12158 };
12159
12160 interface RTCPeerConnectionEventMap {
12161     "connectionstatechange": Event;
12162     "datachannel": RTCDataChannelEvent;
12163     "icecandidate": RTCPeerConnectionIceEvent;
12164     "icecandidateerror": RTCPeerConnectionIceErrorEvent;
12165     "iceconnectionstatechange": Event;
12166     "icegatheringstatechange": Event;
12167     "negotiationneeded": Event;
12168     "signalingstatechange": Event;
12169     "statsended": RTCStatsEvent;
12170     "track": RTCTrackEvent;
12171 }
12172
12173 /** 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. */
12174 interface RTCPeerConnection extends EventTarget {
12175     readonly canTrickleIceCandidates: boolean | null;
12176     readonly connectionState: RTCPeerConnectionState;
12177     readonly currentLocalDescription: RTCSessionDescription | null;
12178     readonly currentRemoteDescription: RTCSessionDescription | null;
12179     readonly iceConnectionState: RTCIceConnectionState;
12180     readonly iceGatheringState: RTCIceGatheringState;
12181     readonly idpErrorInfo: string | null;
12182     readonly idpLoginUrl: string | null;
12183     readonly localDescription: RTCSessionDescription | null;
12184     onconnectionstatechange: ((this: RTCPeerConnection, ev: Event) => any) | null;
12185     ondatachannel: ((this: RTCPeerConnection, ev: RTCDataChannelEvent) => any) | null;
12186     onicecandidate: ((this: RTCPeerConnection, ev: RTCPeerConnectionIceEvent) => any) | null;
12187     onicecandidateerror: ((this: RTCPeerConnection, ev: RTCPeerConnectionIceErrorEvent) => any) | null;
12188     oniceconnectionstatechange: ((this: RTCPeerConnection, ev: Event) => any) | null;
12189     onicegatheringstatechange: ((this: RTCPeerConnection, ev: Event) => any) | null;
12190     onnegotiationneeded: ((this: RTCPeerConnection, ev: Event) => any) | null;
12191     onsignalingstatechange: ((this: RTCPeerConnection, ev: Event) => any) | null;
12192     onstatsended: ((this: RTCPeerConnection, ev: RTCStatsEvent) => any) | null;
12193     ontrack: ((this: RTCPeerConnection, ev: RTCTrackEvent) => any) | null;
12194     readonly peerIdentity: Promise<RTCIdentityAssertion>;
12195     readonly pendingLocalDescription: RTCSessionDescription | null;
12196     readonly pendingRemoteDescription: RTCSessionDescription | null;
12197     readonly remoteDescription: RTCSessionDescription | null;
12198     readonly sctp: RTCSctpTransport | null;
12199     readonly signalingState: RTCSignalingState;
12200     addIceCandidate(candidate: RTCIceCandidateInit | RTCIceCandidate): Promise<void>;
12201     addTrack(track: MediaStreamTrack, ...streams: MediaStream[]): RTCRtpSender;
12202     addTransceiver(trackOrKind: MediaStreamTrack | string, init?: RTCRtpTransceiverInit): RTCRtpTransceiver;
12203     close(): void;
12204     createAnswer(options?: RTCOfferOptions): Promise<RTCSessionDescriptionInit>;
12205     createDataChannel(label: string, dataChannelDict?: RTCDataChannelInit): RTCDataChannel;
12206     createOffer(options?: RTCOfferOptions): Promise<RTCSessionDescriptionInit>;
12207     getConfiguration(): RTCConfiguration;
12208     getIdentityAssertion(): Promise<string>;
12209     getReceivers(): RTCRtpReceiver[];
12210     getSenders(): RTCRtpSender[];
12211     getStats(selector?: MediaStreamTrack | null): Promise<RTCStatsReport>;
12212     getTransceivers(): RTCRtpTransceiver[];
12213     removeTrack(sender: RTCRtpSender): void;
12214     setConfiguration(configuration: RTCConfiguration): void;
12215     setIdentityProvider(provider: string, options?: RTCIdentityProviderOptions): void;
12216     setLocalDescription(description: RTCSessionDescriptionInit): Promise<void>;
12217     setRemoteDescription(description: RTCSessionDescriptionInit): Promise<void>;
12218     addEventListener<K extends keyof RTCPeerConnectionEventMap>(type: K, listener: (this: RTCPeerConnection, ev: RTCPeerConnectionEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12219     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12220     removeEventListener<K extends keyof RTCPeerConnectionEventMap>(type: K, listener: (this: RTCPeerConnection, ev: RTCPeerConnectionEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12221     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12222 }
12223
12224 declare var RTCPeerConnection: {
12225     prototype: RTCPeerConnection;
12226     new(configuration?: RTCConfiguration): RTCPeerConnection;
12227     generateCertificate(keygenAlgorithm: AlgorithmIdentifier): Promise<RTCCertificate>;
12228     getDefaultIceServers(): RTCIceServer[];
12229 };
12230
12231 interface RTCPeerConnectionIceErrorEvent extends Event {
12232     readonly errorCode: number;
12233     readonly errorText: string;
12234     readonly hostCandidate: string;
12235     readonly url: string;
12236 }
12237
12238 declare var RTCPeerConnectionIceErrorEvent: {
12239     prototype: RTCPeerConnectionIceErrorEvent;
12240     new(type: string, eventInitDict: RTCPeerConnectionIceErrorEventInit): RTCPeerConnectionIceErrorEvent;
12241 };
12242
12243 /** Events that occurs in relation to ICE candidates with the target, usually an RTCPeerConnection. Only one event is of this type: icecandidate. */
12244 interface RTCPeerConnectionIceEvent extends Event {
12245     readonly candidate: RTCIceCandidate | null;
12246     readonly url: string | null;
12247 }
12248
12249 declare var RTCPeerConnectionIceEvent: {
12250     prototype: RTCPeerConnectionIceEvent;
12251     new(type: string, eventInitDict?: RTCPeerConnectionIceEventInit): RTCPeerConnectionIceEvent;
12252 };
12253
12254 /** This WebRTC API interface manages the reception and decoding of data for a MediaStreamTrack on an RTCPeerConnection. */
12255 interface RTCRtpReceiver {
12256     readonly rtcpTransport: RTCDtlsTransport | null;
12257     readonly track: MediaStreamTrack;
12258     readonly transport: RTCDtlsTransport | null;
12259     getContributingSources(): RTCRtpContributingSource[];
12260     getParameters(): RTCRtpReceiveParameters;
12261     getStats(): Promise<RTCStatsReport>;
12262     getSynchronizationSources(): RTCRtpSynchronizationSource[];
12263 }
12264
12265 declare var RTCRtpReceiver: {
12266     prototype: RTCRtpReceiver;
12267     new(): RTCRtpReceiver;
12268     getCapabilities(kind: string): RTCRtpCapabilities | null;
12269 };
12270
12271 /** Provides the ability to control and obtain details about how a particular MediaStreamTrack is encoded and sent to a remote peer. */
12272 interface RTCRtpSender {
12273     readonly dtmf: RTCDTMFSender | null;
12274     readonly rtcpTransport: RTCDtlsTransport | null;
12275     readonly track: MediaStreamTrack | null;
12276     readonly transport: RTCDtlsTransport | null;
12277     getParameters(): RTCRtpSendParameters;
12278     getStats(): Promise<RTCStatsReport>;
12279     replaceTrack(withTrack: MediaStreamTrack | null): Promise<void>;
12280     setParameters(parameters: RTCRtpSendParameters): Promise<void>;
12281     setStreams(...streams: MediaStream[]): void;
12282 }
12283
12284 declare var RTCRtpSender: {
12285     prototype: RTCRtpSender;
12286     new(): RTCRtpSender;
12287     getCapabilities(kind: string): RTCRtpCapabilities | null;
12288 };
12289
12290 interface RTCRtpTransceiver {
12291     readonly currentDirection: RTCRtpTransceiverDirection | null;
12292     direction: RTCRtpTransceiverDirection;
12293     readonly mid: string | null;
12294     readonly receiver: RTCRtpReceiver;
12295     readonly sender: RTCRtpSender;
12296     setCodecPreferences(codecs: RTCRtpCodecCapability[]): void;
12297     stop(): void;
12298 }
12299
12300 declare var RTCRtpTransceiver: {
12301     prototype: RTCRtpTransceiver;
12302     new(): RTCRtpTransceiver;
12303 };
12304
12305 interface RTCSctpTransportEventMap {
12306     "statechange": Event;
12307 }
12308
12309 interface RTCSctpTransport extends EventTarget {
12310     readonly maxChannels: number | null;
12311     readonly maxMessageSize: number;
12312     onstatechange: ((this: RTCSctpTransport, ev: Event) => any) | null;
12313     readonly state: RTCSctpTransportState;
12314     readonly transport: RTCDtlsTransport;
12315     addEventListener<K extends keyof RTCSctpTransportEventMap>(type: K, listener: (this: RTCSctpTransport, ev: RTCSctpTransportEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12316     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12317     removeEventListener<K extends keyof RTCSctpTransportEventMap>(type: K, listener: (this: RTCSctpTransport, ev: RTCSctpTransportEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12318     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12319 }
12320
12321 declare var RTCSctpTransport: {
12322     prototype: RTCSctpTransport;
12323     new(): RTCSctpTransport;
12324 };
12325
12326 /** 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. */
12327 interface RTCSessionDescription {
12328     readonly sdp: string;
12329     readonly type: RTCSdpType;
12330     toJSON(): any;
12331 }
12332
12333 declare var RTCSessionDescription: {
12334     prototype: RTCSessionDescription;
12335     new(descriptionInitDict?: RTCSessionDescriptionInit): RTCSessionDescription;
12336 };
12337
12338 interface RTCSrtpSdesTransportEventMap {
12339     "error": Event;
12340 }
12341
12342 interface RTCSrtpSdesTransport extends EventTarget {
12343     onerror: ((this: RTCSrtpSdesTransport, ev: Event) => any) | null;
12344     readonly transport: RTCIceTransport;
12345     addEventListener<K extends keyof RTCSrtpSdesTransportEventMap>(type: K, listener: (this: RTCSrtpSdesTransport, ev: RTCSrtpSdesTransportEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12346     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12347     removeEventListener<K extends keyof RTCSrtpSdesTransportEventMap>(type: K, listener: (this: RTCSrtpSdesTransport, ev: RTCSrtpSdesTransportEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12348     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12349 }
12350
12351 declare var RTCSrtpSdesTransport: {
12352     prototype: RTCSrtpSdesTransport;
12353     new(transport: RTCIceTransport, encryptParameters: RTCSrtpSdesParameters, decryptParameters: RTCSrtpSdesParameters): RTCSrtpSdesTransport;
12354     getLocalParameters(): RTCSrtpSdesParameters[];
12355 };
12356
12357 interface RTCSsrcConflictEvent extends Event {
12358     readonly ssrc: number;
12359 }
12360
12361 declare var RTCSsrcConflictEvent: {
12362     prototype: RTCSsrcConflictEvent;
12363     new(): RTCSsrcConflictEvent;
12364 };
12365
12366 interface RTCStatsEvent extends Event {
12367     readonly report: RTCStatsReport;
12368 }
12369
12370 declare var RTCStatsEvent: {
12371     prototype: RTCStatsEvent;
12372     new(type: string, eventInitDict: RTCStatsEventInit): RTCStatsEvent;
12373 };
12374
12375 interface RTCStatsProvider extends EventTarget {
12376     getStats(): Promise<RTCStatsReport>;
12377     msGetStats(): Promise<RTCStatsReport>;
12378 }
12379
12380 declare var RTCStatsProvider: {
12381     prototype: RTCStatsProvider;
12382     new(): RTCStatsProvider;
12383 };
12384
12385 interface RTCStatsReport {
12386     forEach(callbackfn: (value: any, key: string, parent: RTCStatsReport) => void, thisArg?: any): void;
12387 }
12388
12389 declare var RTCStatsReport: {
12390     prototype: RTCStatsReport;
12391     new(): RTCStatsReport;
12392 };
12393
12394 interface RTCTrackEvent extends Event {
12395     readonly receiver: RTCRtpReceiver;
12396     readonly streams: ReadonlyArray<MediaStream>;
12397     readonly track: MediaStreamTrack;
12398     readonly transceiver: RTCRtpTransceiver;
12399 }
12400
12401 declare var RTCTrackEvent: {
12402     prototype: RTCTrackEvent;
12403     new(type: string, eventInitDict: RTCTrackEventInit): RTCTrackEvent;
12404 };
12405
12406 interface RadioNodeList extends NodeList {
12407     value: string;
12408 }
12409
12410 declare var RadioNodeList: {
12411     prototype: RadioNodeList;
12412     new(): RadioNodeList;
12413 };
12414
12415 interface RandomSource {
12416     getRandomValues<T extends Int8Array | Uint8ClampedArray | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array>(array: T): T;
12417 }
12418
12419 declare var RandomSource: {
12420     prototype: RandomSource;
12421     new(): RandomSource;
12422 };
12423
12424 /** A fragment of a document that can contain nodes and parts of text nodes. */
12425 interface Range extends AbstractRange {
12426     /**
12427      * Returns the node, furthest away from the document, that is an ancestor of both range's start node and end node.
12428      */
12429     readonly commonAncestorContainer: Node;
12430     cloneContents(): DocumentFragment;
12431     cloneRange(): Range;
12432     collapse(toStart?: boolean): void;
12433     compareBoundaryPoints(how: number, sourceRange: Range): number;
12434     /**
12435      * 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.
12436      */
12437     comparePoint(node: Node, offset: number): number;
12438     createContextualFragment(fragment: string): DocumentFragment;
12439     deleteContents(): void;
12440     detach(): void;
12441     extractContents(): DocumentFragment;
12442     getBoundingClientRect(): DOMRect;
12443     getClientRects(): DOMRectList;
12444     insertNode(node: Node): void;
12445     /**
12446      * Returns whether range intersects node.
12447      */
12448     intersectsNode(node: Node): boolean;
12449     isPointInRange(node: Node, offset: number): boolean;
12450     selectNode(node: Node): void;
12451     selectNodeContents(node: Node): void;
12452     setEnd(node: Node, offset: number): void;
12453     setEndAfter(node: Node): void;
12454     setEndBefore(node: Node): void;
12455     setStart(node: Node, offset: number): void;
12456     setStartAfter(node: Node): void;
12457     setStartBefore(node: Node): void;
12458     surroundContents(newParent: Node): void;
12459     toString(): string;
12460     readonly END_TO_END: number;
12461     readonly END_TO_START: number;
12462     readonly START_TO_END: number;
12463     readonly START_TO_START: number;
12464 }
12465
12466 declare var Range: {
12467     prototype: Range;
12468     new(): Range;
12469     readonly END_TO_END: number;
12470     readonly END_TO_START: number;
12471     readonly START_TO_END: number;
12472     readonly START_TO_START: number;
12473     toString(): string;
12474 };
12475
12476 interface ReadableByteStreamController {
12477     readonly byobRequest: ReadableStreamBYOBRequest | undefined;
12478     readonly desiredSize: number | null;
12479     close(): void;
12480     enqueue(chunk: ArrayBufferView): void;
12481     error(error?: any): void;
12482 }
12483
12484 /** 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. */
12485 interface ReadableStream<R = any> {
12486     readonly locked: boolean;
12487     cancel(reason?: any): Promise<void>;
12488     getReader(options: { mode: "byob" }): ReadableStreamBYOBReader;
12489     getReader(): ReadableStreamDefaultReader<R>;
12490     pipeThrough<T>({ writable, readable }: { writable: WritableStream<R>, readable: ReadableStream<T> }, options?: PipeOptions): ReadableStream<T>;
12491     pipeTo(dest: WritableStream<R>, options?: PipeOptions): Promise<void>;
12492     tee(): [ReadableStream<R>, ReadableStream<R>];
12493 }
12494
12495 declare var ReadableStream: {
12496     prototype: ReadableStream;
12497     new(underlyingSource: UnderlyingByteSource, strategy?: { highWaterMark?: number, size?: undefined }): ReadableStream<Uint8Array>;
12498     new<R = any>(underlyingSource?: UnderlyingSource<R>, strategy?: QueuingStrategy<R>): ReadableStream<R>;
12499 };
12500
12501 interface ReadableStreamBYOBReader {
12502     readonly closed: Promise<void>;
12503     cancel(reason?: any): Promise<void>;
12504     read<T extends ArrayBufferView>(view: T): Promise<ReadableStreamReadResult<T>>;
12505     releaseLock(): void;
12506 }
12507
12508 interface ReadableStreamBYOBRequest {
12509     readonly view: ArrayBufferView;
12510     respond(bytesWritten: number): void;
12511     respondWithNewView(view: ArrayBufferView): void;
12512 }
12513
12514 interface ReadableStreamDefaultController<R = any> {
12515     readonly desiredSize: number | null;
12516     close(): void;
12517     enqueue(chunk: R): void;
12518     error(error?: any): void;
12519 }
12520
12521 interface ReadableStreamDefaultReader<R = any> {
12522     readonly closed: Promise<void>;
12523     cancel(reason?: any): Promise<void>;
12524     read(): Promise<ReadableStreamReadResult<R>>;
12525     releaseLock(): void;
12526 }
12527
12528 interface ReadableStreamReader<R = any> {
12529     cancel(): Promise<void>;
12530     read(): Promise<ReadableStreamReadResult<R>>;
12531     releaseLock(): void;
12532 }
12533
12534 declare var ReadableStreamReader: {
12535     prototype: ReadableStreamReader;
12536     new(): ReadableStreamReader;
12537 };
12538
12539 /** This Fetch API interface represents a resource request. */
12540 interface Request extends Body {
12541     /**
12542      * Returns the cache mode associated with request, which is a string indicating how the request will interact with the browser's cache when fetching.
12543      */
12544     readonly cache: RequestCache;
12545     /**
12546      * 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.
12547      */
12548     readonly credentials: RequestCredentials;
12549     /**
12550      * Returns the kind of resource requested by request, e.g., "document" or "script".
12551      */
12552     readonly destination: RequestDestination;
12553     /**
12554      * 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.
12555      */
12556     readonly headers: Headers;
12557     /**
12558      * 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]
12559      */
12560     readonly integrity: string;
12561     /**
12562      * Returns a boolean indicating whether or not request is for a history navigation (a.k.a. back-foward navigation).
12563      */
12564     readonly isHistoryNavigation: boolean;
12565     /**
12566      * Returns a boolean indicating whether or not request is for a reload navigation.
12567      */
12568     readonly isReloadNavigation: boolean;
12569     /**
12570      * Returns a boolean indicating whether or not request can outlive the global in which it was created.
12571      */
12572     readonly keepalive: boolean;
12573     /**
12574      * Returns request's HTTP method, which is "GET" by default.
12575      */
12576     readonly method: string;
12577     /**
12578      * 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.
12579      */
12580     readonly mode: RequestMode;
12581     /**
12582      * 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.
12583      */
12584     readonly redirect: RequestRedirect;
12585     /**
12586      * 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.
12587      */
12588     readonly referrer: string;
12589     /**
12590      * Returns the referrer policy associated with request. This is used during fetching to compute the value of the request's referrer.
12591      */
12592     readonly referrerPolicy: ReferrerPolicy;
12593     /**
12594      * Returns the signal associated with request, which is an AbortSignal object indicating whether or not request has been aborted, and its abort event handler.
12595      */
12596     readonly signal: AbortSignal;
12597     /**
12598      * Returns the URL of request as a string.
12599      */
12600     readonly url: string;
12601     clone(): Request;
12602 }
12603
12604 declare var Request: {
12605     prototype: Request;
12606     new(input: RequestInfo, init?: RequestInit): Request;
12607 };
12608
12609 /** This Fetch API interface represents the response to a request. */
12610 interface Response extends Body {
12611     readonly headers: Headers;
12612     readonly ok: boolean;
12613     readonly redirected: boolean;
12614     readonly status: number;
12615     readonly statusText: string;
12616     readonly trailer: Promise<Headers>;
12617     readonly type: ResponseType;
12618     readonly url: string;
12619     clone(): Response;
12620 }
12621
12622 declare var Response: {
12623     prototype: Response;
12624     new(body?: BodyInit | null, init?: ResponseInit): Response;
12625     error(): Response;
12626     redirect(url: string, status?: number): Response;
12627 };
12628
12629 /** Provides access to the properties of <a> element, as well as methods to manipulate them. */
12630 interface SVGAElement extends SVGGraphicsElement, SVGURIReference {
12631     readonly target: SVGAnimatedString;
12632     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGAElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12633     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12634     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGAElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12635     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12636 }
12637
12638 declare var SVGAElement: {
12639     prototype: SVGAElement;
12640     new(): SVGAElement;
12641 };
12642
12643 /** Used to represent a value that can be an <angle> or <number> value. An SVGAngle reflected through the animVal attribute is always read only. */
12644 interface SVGAngle {
12645     readonly unitType: number;
12646     value: number;
12647     valueAsString: string;
12648     valueInSpecifiedUnits: number;
12649     convertToSpecifiedUnits(unitType: number): void;
12650     newValueSpecifiedUnits(unitType: number, valueInSpecifiedUnits: number): void;
12651     readonly SVG_ANGLETYPE_DEG: number;
12652     readonly SVG_ANGLETYPE_GRAD: number;
12653     readonly SVG_ANGLETYPE_RAD: number;
12654     readonly SVG_ANGLETYPE_UNKNOWN: number;
12655     readonly SVG_ANGLETYPE_UNSPECIFIED: number;
12656 }
12657
12658 declare var SVGAngle: {
12659     prototype: SVGAngle;
12660     new(): SVGAngle;
12661     readonly SVG_ANGLETYPE_DEG: number;
12662     readonly SVG_ANGLETYPE_GRAD: number;
12663     readonly SVG_ANGLETYPE_RAD: number;
12664     readonly SVG_ANGLETYPE_UNKNOWN: number;
12665     readonly SVG_ANGLETYPE_UNSPECIFIED: number;
12666 };
12667
12668 interface SVGAnimateElement extends SVGAnimationElement {
12669     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGAnimateElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12670     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12671     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGAnimateElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12672     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12673 }
12674
12675 declare var SVGAnimateElement: {
12676     prototype: SVGAnimateElement;
12677     new(): SVGAnimateElement;
12678 };
12679
12680 interface SVGAnimateMotionElement extends SVGAnimationElement {
12681     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGAnimateMotionElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12682     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12683     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGAnimateMotionElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12684     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12685 }
12686
12687 declare var SVGAnimateMotionElement: {
12688     prototype: SVGAnimateMotionElement;
12689     new(): SVGAnimateMotionElement;
12690 };
12691
12692 interface SVGAnimateTransformElement extends SVGAnimationElement {
12693     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGAnimateTransformElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12694     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12695     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGAnimateTransformElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12696     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12697 }
12698
12699 declare var SVGAnimateTransformElement: {
12700     prototype: SVGAnimateTransformElement;
12701     new(): SVGAnimateTransformElement;
12702 };
12703
12704 /** Used for attributes of basic type <angle> which can be animated. */
12705 interface SVGAnimatedAngle {
12706     readonly animVal: SVGAngle;
12707     readonly baseVal: SVGAngle;
12708 }
12709
12710 declare var SVGAnimatedAngle: {
12711     prototype: SVGAnimatedAngle;
12712     new(): SVGAnimatedAngle;
12713 };
12714
12715 /** Used for attributes of type boolean which can be animated. */
12716 interface SVGAnimatedBoolean {
12717     readonly animVal: boolean;
12718     baseVal: boolean;
12719 }
12720
12721 declare var SVGAnimatedBoolean: {
12722     prototype: SVGAnimatedBoolean;
12723     new(): SVGAnimatedBoolean;
12724 };
12725
12726 /** Used for attributes whose value must be a constant from a particular enumeration and which can be animated. */
12727 interface SVGAnimatedEnumeration {
12728     readonly animVal: number;
12729     baseVal: number;
12730 }
12731
12732 declare var SVGAnimatedEnumeration: {
12733     prototype: SVGAnimatedEnumeration;
12734     new(): SVGAnimatedEnumeration;
12735 };
12736
12737 /** Used for attributes of basic type <integer> which can be animated. */
12738 interface SVGAnimatedInteger {
12739     readonly animVal: number;
12740     baseVal: number;
12741 }
12742
12743 declare var SVGAnimatedInteger: {
12744     prototype: SVGAnimatedInteger;
12745     new(): SVGAnimatedInteger;
12746 };
12747
12748 /** Used for attributes of basic type <length> which can be animated. */
12749 interface SVGAnimatedLength {
12750     readonly animVal: SVGLength;
12751     readonly baseVal: SVGLength;
12752 }
12753
12754 declare var SVGAnimatedLength: {
12755     prototype: SVGAnimatedLength;
12756     new(): SVGAnimatedLength;
12757 };
12758
12759 /** Used for attributes of type SVGLengthList which can be animated. */
12760 interface SVGAnimatedLengthList {
12761     readonly animVal: SVGLengthList;
12762     readonly baseVal: SVGLengthList;
12763 }
12764
12765 declare var SVGAnimatedLengthList: {
12766     prototype: SVGAnimatedLengthList;
12767     new(): SVGAnimatedLengthList;
12768 };
12769
12770 /** Used for attributes of basic type <Number> which can be animated. */
12771 interface SVGAnimatedNumber {
12772     readonly animVal: number;
12773     baseVal: number;
12774 }
12775
12776 declare var SVGAnimatedNumber: {
12777     prototype: SVGAnimatedNumber;
12778     new(): SVGAnimatedNumber;
12779 };
12780
12781 /** The SVGAnimatedNumber interface is used for attributes which take a list of numbers and which can be animated. */
12782 interface SVGAnimatedNumberList {
12783     readonly animVal: SVGNumberList;
12784     readonly baseVal: SVGNumberList;
12785 }
12786
12787 declare var SVGAnimatedNumberList: {
12788     prototype: SVGAnimatedNumberList;
12789     new(): SVGAnimatedNumberList;
12790 };
12791
12792 interface SVGAnimatedPoints {
12793     readonly animatedPoints: SVGPointList;
12794     readonly points: SVGPointList;
12795 }
12796
12797 /** Used for attributes of type SVGPreserveAspectRatio which can be animated. */
12798 interface SVGAnimatedPreserveAspectRatio {
12799     readonly animVal: SVGPreserveAspectRatio;
12800     readonly baseVal: SVGPreserveAspectRatio;
12801 }
12802
12803 declare var SVGAnimatedPreserveAspectRatio: {
12804     prototype: SVGAnimatedPreserveAspectRatio;
12805     new(): SVGAnimatedPreserveAspectRatio;
12806 };
12807
12808 /** Used for attributes of basic SVGRect which can be animated. */
12809 interface SVGAnimatedRect {
12810     readonly animVal: DOMRectReadOnly;
12811     readonly baseVal: DOMRect;
12812 }
12813
12814 declare var SVGAnimatedRect: {
12815     prototype: SVGAnimatedRect;
12816     new(): SVGAnimatedRect;
12817 };
12818
12819 /** 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. */
12820 interface SVGAnimatedString {
12821     readonly animVal: string;
12822     baseVal: string;
12823 }
12824
12825 declare var SVGAnimatedString: {
12826     prototype: SVGAnimatedString;
12827     new(): SVGAnimatedString;
12828 };
12829
12830 /** Used for attributes which take a list of numbers and which can be animated. */
12831 interface SVGAnimatedTransformList {
12832     readonly animVal: SVGTransformList;
12833     readonly baseVal: SVGTransformList;
12834 }
12835
12836 declare var SVGAnimatedTransformList: {
12837     prototype: SVGAnimatedTransformList;
12838     new(): SVGAnimatedTransformList;
12839 };
12840
12841 interface SVGAnimationElement extends SVGElement {
12842     readonly targetElement: SVGElement;
12843     getCurrentTime(): number;
12844     getSimpleDuration(): number;
12845     getStartTime(): number;
12846     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGAnimationElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12847     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12848     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGAnimationElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12849     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12850 }
12851
12852 declare var SVGAnimationElement: {
12853     prototype: SVGAnimationElement;
12854     new(): SVGAnimationElement;
12855 };
12856
12857 /** 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. */
12858 interface SVGCircleElement extends SVGGeometryElement {
12859     readonly cx: SVGAnimatedLength;
12860     readonly cy: SVGAnimatedLength;
12861     readonly r: SVGAnimatedLength;
12862     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGCircleElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12863     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12864     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGCircleElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12865     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12866 }
12867
12868 declare var SVGCircleElement: {
12869     prototype: SVGCircleElement;
12870     new(): SVGCircleElement;
12871 };
12872
12873 /** Provides access to the properties of <clipPath> elements, as well as methods to manipulate them. */
12874 interface SVGClipPathElement extends SVGElement {
12875     readonly clipPathUnits: SVGAnimatedEnumeration;
12876     readonly transform: SVGAnimatedTransformList;
12877     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGClipPathElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12878     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12879     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGClipPathElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12880     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12881 }
12882
12883 declare var SVGClipPathElement: {
12884     prototype: SVGClipPathElement;
12885     new(): SVGClipPathElement;
12886 };
12887
12888 /** A base interface used by the component transfer function interfaces. */
12889 interface SVGComponentTransferFunctionElement extends SVGElement {
12890     readonly amplitude: SVGAnimatedNumber;
12891     readonly exponent: SVGAnimatedNumber;
12892     readonly intercept: SVGAnimatedNumber;
12893     readonly offset: SVGAnimatedNumber;
12894     readonly slope: SVGAnimatedNumber;
12895     readonly tableValues: SVGAnimatedNumberList;
12896     readonly type: SVGAnimatedEnumeration;
12897     readonly SVG_FECOMPONENTTRANSFER_TYPE_DISCRETE: number;
12898     readonly SVG_FECOMPONENTTRANSFER_TYPE_GAMMA: number;
12899     readonly SVG_FECOMPONENTTRANSFER_TYPE_IDENTITY: number;
12900     readonly SVG_FECOMPONENTTRANSFER_TYPE_LINEAR: number;
12901     readonly SVG_FECOMPONENTTRANSFER_TYPE_TABLE: number;
12902     readonly SVG_FECOMPONENTTRANSFER_TYPE_UNKNOWN: number;
12903     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGComponentTransferFunctionElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12904     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12905     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGComponentTransferFunctionElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12906     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12907 }
12908
12909 declare var SVGComponentTransferFunctionElement: {
12910     prototype: SVGComponentTransferFunctionElement;
12911     new(): SVGComponentTransferFunctionElement;
12912     readonly SVG_FECOMPONENTTRANSFER_TYPE_DISCRETE: number;
12913     readonly SVG_FECOMPONENTTRANSFER_TYPE_GAMMA: number;
12914     readonly SVG_FECOMPONENTTRANSFER_TYPE_IDENTITY: number;
12915     readonly SVG_FECOMPONENTTRANSFER_TYPE_LINEAR: number;
12916     readonly SVG_FECOMPONENTTRANSFER_TYPE_TABLE: number;
12917     readonly SVG_FECOMPONENTTRANSFER_TYPE_UNKNOWN: number;
12918 };
12919
12920 interface SVGCursorElement extends SVGElement {
12921     readonly x: SVGAnimatedLength;
12922     readonly y: SVGAnimatedLength;
12923     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGCursorElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12924     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12925     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGCursorElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12926     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12927 }
12928
12929 declare var SVGCursorElement: {
12930     prototype: SVGCursorElement;
12931     new(): SVGCursorElement;
12932 };
12933
12934 /** Corresponds to the <defs> element. */
12935 interface SVGDefsElement extends SVGGraphicsElement {
12936     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGDefsElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12937     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12938     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGDefsElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12939     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12940 }
12941
12942 declare var SVGDefsElement: {
12943     prototype: SVGDefsElement;
12944     new(): SVGDefsElement;
12945 };
12946
12947 /** Corresponds to the <desc> element. */
12948 interface SVGDescElement extends SVGElement {
12949     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGDescElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12950     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12951     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGDescElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12952     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12953 }
12954
12955 declare var SVGDescElement: {
12956     prototype: SVGDescElement;
12957     new(): SVGDescElement;
12958 };
12959
12960 interface SVGElementEventMap extends ElementEventMap, GlobalEventHandlersEventMap, DocumentAndElementEventHandlersEventMap {
12961 }
12962
12963 /** All of the SVG DOM interfaces that correspond directly to elements in the SVG language derive from the SVGElement interface. */
12964 interface SVGElement extends Element, DocumentAndElementEventHandlers, DocumentAndElementEventHandlers, ElementCSSInlineStyle, GlobalEventHandlers, GlobalEventHandlers, HTMLOrSVGElement, SVGElementInstance {
12965     /** @deprecated */
12966     readonly className: any;
12967     readonly ownerSVGElement: SVGSVGElement | null;
12968     readonly viewportElement: SVGElement | null;
12969     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12970     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12971     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12972     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12973 }
12974
12975 declare var SVGElement: {
12976     prototype: SVGElement;
12977     new(): SVGElement;
12978 };
12979
12980 interface SVGElementInstance extends EventTarget {
12981     readonly correspondingElement: SVGElement;
12982     readonly correspondingUseElement: SVGUseElement;
12983 }
12984
12985 declare var SVGElementInstance: {
12986     prototype: SVGElementInstance;
12987     new(): SVGElementInstance;
12988 };
12989
12990 interface SVGElementInstanceList {
12991     /** @deprecated */
12992     readonly length: number;
12993     /** @deprecated */
12994     item(index: number): SVGElementInstance;
12995 }
12996
12997 declare var SVGElementInstanceList: {
12998     prototype: SVGElementInstanceList;
12999     new(): SVGElementInstanceList;
13000 };
13001
13002 /** Provides access to the properties of <ellipse> elements. */
13003 interface SVGEllipseElement extends SVGGeometryElement {
13004     readonly cx: SVGAnimatedLength;
13005     readonly cy: SVGAnimatedLength;
13006     readonly rx: SVGAnimatedLength;
13007     readonly ry: SVGAnimatedLength;
13008     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGEllipseElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13009     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13010     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGEllipseElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13011     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13012 }
13013
13014 declare var SVGEllipseElement: {
13015     prototype: SVGEllipseElement;
13016     new(): SVGEllipseElement;
13017 };
13018
13019 /** Corresponds to the <feBlend> element. */
13020 interface SVGFEBlendElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13021     readonly in1: SVGAnimatedString;
13022     readonly in2: SVGAnimatedString;
13023     readonly mode: SVGAnimatedEnumeration;
13024     readonly SVG_FEBLEND_MODE_COLOR: number;
13025     readonly SVG_FEBLEND_MODE_COLOR_BURN: number;
13026     readonly SVG_FEBLEND_MODE_COLOR_DODGE: number;
13027     readonly SVG_FEBLEND_MODE_DARKEN: number;
13028     readonly SVG_FEBLEND_MODE_DIFFERENCE: number;
13029     readonly SVG_FEBLEND_MODE_EXCLUSION: number;
13030     readonly SVG_FEBLEND_MODE_HARD_LIGHT: number;
13031     readonly SVG_FEBLEND_MODE_HUE: number;
13032     readonly SVG_FEBLEND_MODE_LIGHTEN: number;
13033     readonly SVG_FEBLEND_MODE_LUMINOSITY: number;
13034     readonly SVG_FEBLEND_MODE_MULTIPLY: number;
13035     readonly SVG_FEBLEND_MODE_NORMAL: number;
13036     readonly SVG_FEBLEND_MODE_OVERLAY: number;
13037     readonly SVG_FEBLEND_MODE_SATURATION: number;
13038     readonly SVG_FEBLEND_MODE_SCREEN: number;
13039     readonly SVG_FEBLEND_MODE_SOFT_LIGHT: number;
13040     readonly SVG_FEBLEND_MODE_UNKNOWN: number;
13041     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEBlendElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13042     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13043     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEBlendElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13044     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13045 }
13046
13047 declare var SVGFEBlendElement: {
13048     prototype: SVGFEBlendElement;
13049     new(): SVGFEBlendElement;
13050     readonly SVG_FEBLEND_MODE_COLOR: number;
13051     readonly SVG_FEBLEND_MODE_COLOR_BURN: number;
13052     readonly SVG_FEBLEND_MODE_COLOR_DODGE: number;
13053     readonly SVG_FEBLEND_MODE_DARKEN: number;
13054     readonly SVG_FEBLEND_MODE_DIFFERENCE: number;
13055     readonly SVG_FEBLEND_MODE_EXCLUSION: number;
13056     readonly SVG_FEBLEND_MODE_HARD_LIGHT: number;
13057     readonly SVG_FEBLEND_MODE_HUE: number;
13058     readonly SVG_FEBLEND_MODE_LIGHTEN: number;
13059     readonly SVG_FEBLEND_MODE_LUMINOSITY: number;
13060     readonly SVG_FEBLEND_MODE_MULTIPLY: number;
13061     readonly SVG_FEBLEND_MODE_NORMAL: number;
13062     readonly SVG_FEBLEND_MODE_OVERLAY: number;
13063     readonly SVG_FEBLEND_MODE_SATURATION: number;
13064     readonly SVG_FEBLEND_MODE_SCREEN: number;
13065     readonly SVG_FEBLEND_MODE_SOFT_LIGHT: number;
13066     readonly SVG_FEBLEND_MODE_UNKNOWN: number;
13067 };
13068
13069 /** Corresponds to the <feColorMatrix> element. */
13070 interface SVGFEColorMatrixElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13071     readonly in1: SVGAnimatedString;
13072     readonly type: SVGAnimatedEnumeration;
13073     readonly values: SVGAnimatedNumberList;
13074     readonly SVG_FECOLORMATRIX_TYPE_HUEROTATE: number;
13075     readonly SVG_FECOLORMATRIX_TYPE_LUMINANCETOALPHA: number;
13076     readonly SVG_FECOLORMATRIX_TYPE_MATRIX: number;
13077     readonly SVG_FECOLORMATRIX_TYPE_SATURATE: number;
13078     readonly SVG_FECOLORMATRIX_TYPE_UNKNOWN: number;
13079     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEColorMatrixElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13080     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13081     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEColorMatrixElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13082     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13083 }
13084
13085 declare var SVGFEColorMatrixElement: {
13086     prototype: SVGFEColorMatrixElement;
13087     new(): SVGFEColorMatrixElement;
13088     readonly SVG_FECOLORMATRIX_TYPE_HUEROTATE: number;
13089     readonly SVG_FECOLORMATRIX_TYPE_LUMINANCETOALPHA: number;
13090     readonly SVG_FECOLORMATRIX_TYPE_MATRIX: number;
13091     readonly SVG_FECOLORMATRIX_TYPE_SATURATE: number;
13092     readonly SVG_FECOLORMATRIX_TYPE_UNKNOWN: number;
13093 };
13094
13095 /** Corresponds to the <feComponentTransfer> element. */
13096 interface SVGFEComponentTransferElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13097     readonly in1: SVGAnimatedString;
13098     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEComponentTransferElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13099     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13100     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEComponentTransferElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13101     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13102 }
13103
13104 declare var SVGFEComponentTransferElement: {
13105     prototype: SVGFEComponentTransferElement;
13106     new(): SVGFEComponentTransferElement;
13107 };
13108
13109 /** Corresponds to the <feComposite> element. */
13110 interface SVGFECompositeElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13111     readonly in1: SVGAnimatedString;
13112     readonly in2: SVGAnimatedString;
13113     readonly k1: SVGAnimatedNumber;
13114     readonly k2: SVGAnimatedNumber;
13115     readonly k3: SVGAnimatedNumber;
13116     readonly k4: SVGAnimatedNumber;
13117     readonly operator: SVGAnimatedEnumeration;
13118     readonly SVG_FECOMPOSITE_OPERATOR_ARITHMETIC: number;
13119     readonly SVG_FECOMPOSITE_OPERATOR_ATOP: number;
13120     readonly SVG_FECOMPOSITE_OPERATOR_IN: number;
13121     readonly SVG_FECOMPOSITE_OPERATOR_OUT: number;
13122     readonly SVG_FECOMPOSITE_OPERATOR_OVER: number;
13123     readonly SVG_FECOMPOSITE_OPERATOR_UNKNOWN: number;
13124     readonly SVG_FECOMPOSITE_OPERATOR_XOR: number;
13125     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFECompositeElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13126     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13127     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFECompositeElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13128     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13129 }
13130
13131 declare var SVGFECompositeElement: {
13132     prototype: SVGFECompositeElement;
13133     new(): SVGFECompositeElement;
13134     readonly SVG_FECOMPOSITE_OPERATOR_ARITHMETIC: number;
13135     readonly SVG_FECOMPOSITE_OPERATOR_ATOP: number;
13136     readonly SVG_FECOMPOSITE_OPERATOR_IN: number;
13137     readonly SVG_FECOMPOSITE_OPERATOR_OUT: number;
13138     readonly SVG_FECOMPOSITE_OPERATOR_OVER: number;
13139     readonly SVG_FECOMPOSITE_OPERATOR_UNKNOWN: number;
13140     readonly SVG_FECOMPOSITE_OPERATOR_XOR: number;
13141 };
13142
13143 /** Corresponds to the <feConvolveMatrix> element. */
13144 interface SVGFEConvolveMatrixElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13145     readonly bias: SVGAnimatedNumber;
13146     readonly divisor: SVGAnimatedNumber;
13147     readonly edgeMode: SVGAnimatedEnumeration;
13148     readonly in1: SVGAnimatedString;
13149     readonly kernelMatrix: SVGAnimatedNumberList;
13150     readonly kernelUnitLengthX: SVGAnimatedNumber;
13151     readonly kernelUnitLengthY: SVGAnimatedNumber;
13152     readonly orderX: SVGAnimatedInteger;
13153     readonly orderY: SVGAnimatedInteger;
13154     readonly preserveAlpha: SVGAnimatedBoolean;
13155     readonly targetX: SVGAnimatedInteger;
13156     readonly targetY: SVGAnimatedInteger;
13157     readonly SVG_EDGEMODE_DUPLICATE: number;
13158     readonly SVG_EDGEMODE_NONE: number;
13159     readonly SVG_EDGEMODE_UNKNOWN: number;
13160     readonly SVG_EDGEMODE_WRAP: number;
13161     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEConvolveMatrixElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13162     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13163     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEConvolveMatrixElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13164     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13165 }
13166
13167 declare var SVGFEConvolveMatrixElement: {
13168     prototype: SVGFEConvolveMatrixElement;
13169     new(): SVGFEConvolveMatrixElement;
13170     readonly SVG_EDGEMODE_DUPLICATE: number;
13171     readonly SVG_EDGEMODE_NONE: number;
13172     readonly SVG_EDGEMODE_UNKNOWN: number;
13173     readonly SVG_EDGEMODE_WRAP: number;
13174 };
13175
13176 /** Corresponds to the <feDiffuseLighting> element. */
13177 interface SVGFEDiffuseLightingElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13178     readonly diffuseConstant: SVGAnimatedNumber;
13179     readonly in1: SVGAnimatedString;
13180     readonly kernelUnitLengthX: SVGAnimatedNumber;
13181     readonly kernelUnitLengthY: SVGAnimatedNumber;
13182     readonly surfaceScale: SVGAnimatedNumber;
13183     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEDiffuseLightingElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13184     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13185     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEDiffuseLightingElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13186     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13187 }
13188
13189 declare var SVGFEDiffuseLightingElement: {
13190     prototype: SVGFEDiffuseLightingElement;
13191     new(): SVGFEDiffuseLightingElement;
13192 };
13193
13194 /** Corresponds to the <feDisplacementMap> element. */
13195 interface SVGFEDisplacementMapElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13196     readonly in1: SVGAnimatedString;
13197     readonly in2: SVGAnimatedString;
13198     readonly scale: SVGAnimatedNumber;
13199     readonly xChannelSelector: SVGAnimatedEnumeration;
13200     readonly yChannelSelector: SVGAnimatedEnumeration;
13201     readonly SVG_CHANNEL_A: number;
13202     readonly SVG_CHANNEL_B: number;
13203     readonly SVG_CHANNEL_G: number;
13204     readonly SVG_CHANNEL_R: number;
13205     readonly SVG_CHANNEL_UNKNOWN: number;
13206     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEDisplacementMapElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13207     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13208     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEDisplacementMapElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13209     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13210 }
13211
13212 declare var SVGFEDisplacementMapElement: {
13213     prototype: SVGFEDisplacementMapElement;
13214     new(): SVGFEDisplacementMapElement;
13215     readonly SVG_CHANNEL_A: number;
13216     readonly SVG_CHANNEL_B: number;
13217     readonly SVG_CHANNEL_G: number;
13218     readonly SVG_CHANNEL_R: number;
13219     readonly SVG_CHANNEL_UNKNOWN: number;
13220 };
13221
13222 /** Corresponds to the <feDistantLight> element. */
13223 interface SVGFEDistantLightElement extends SVGElement {
13224     readonly azimuth: SVGAnimatedNumber;
13225     readonly elevation: SVGAnimatedNumber;
13226     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEDistantLightElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13227     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13228     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEDistantLightElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13229     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13230 }
13231
13232 declare var SVGFEDistantLightElement: {
13233     prototype: SVGFEDistantLightElement;
13234     new(): SVGFEDistantLightElement;
13235 };
13236
13237 interface SVGFEDropShadowElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13238     readonly dx: SVGAnimatedNumber;
13239     readonly dy: SVGAnimatedNumber;
13240     readonly in1: SVGAnimatedString;
13241     readonly stdDeviationX: SVGAnimatedNumber;
13242     readonly stdDeviationY: SVGAnimatedNumber;
13243     setStdDeviation(stdDeviationX: number, stdDeviationY: number): void;
13244     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEDropShadowElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13245     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13246     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEDropShadowElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13247     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13248 }
13249
13250 declare var SVGFEDropShadowElement: {
13251     prototype: SVGFEDropShadowElement;
13252     new(): SVGFEDropShadowElement;
13253 };
13254
13255 /** Corresponds to the <feFlood> element. */
13256 interface SVGFEFloodElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13257     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEFloodElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13258     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13259     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEFloodElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13260     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13261 }
13262
13263 declare var SVGFEFloodElement: {
13264     prototype: SVGFEFloodElement;
13265     new(): SVGFEFloodElement;
13266 };
13267
13268 /** Corresponds to the <feFuncA> element. */
13269 interface SVGFEFuncAElement extends SVGComponentTransferFunctionElement {
13270     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEFuncAElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13271     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13272     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEFuncAElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13273     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13274 }
13275
13276 declare var SVGFEFuncAElement: {
13277     prototype: SVGFEFuncAElement;
13278     new(): SVGFEFuncAElement;
13279 };
13280
13281 /** Corresponds to the <feFuncB> element. */
13282 interface SVGFEFuncBElement extends SVGComponentTransferFunctionElement {
13283     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEFuncBElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13284     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13285     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEFuncBElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13286     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13287 }
13288
13289 declare var SVGFEFuncBElement: {
13290     prototype: SVGFEFuncBElement;
13291     new(): SVGFEFuncBElement;
13292 };
13293
13294 /** Corresponds to the <feFuncG> element. */
13295 interface SVGFEFuncGElement extends SVGComponentTransferFunctionElement {
13296     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEFuncGElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13297     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13298     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEFuncGElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13299     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13300 }
13301
13302 declare var SVGFEFuncGElement: {
13303     prototype: SVGFEFuncGElement;
13304     new(): SVGFEFuncGElement;
13305 };
13306
13307 /** Corresponds to the <feFuncR> element. */
13308 interface SVGFEFuncRElement extends SVGComponentTransferFunctionElement {
13309     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEFuncRElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13310     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13311     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEFuncRElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13312     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13313 }
13314
13315 declare var SVGFEFuncRElement: {
13316     prototype: SVGFEFuncRElement;
13317     new(): SVGFEFuncRElement;
13318 };
13319
13320 /** Corresponds to the <feGaussianBlur> element. */
13321 interface SVGFEGaussianBlurElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13322     readonly in1: SVGAnimatedString;
13323     readonly stdDeviationX: SVGAnimatedNumber;
13324     readonly stdDeviationY: SVGAnimatedNumber;
13325     setStdDeviation(stdDeviationX: number, stdDeviationY: number): void;
13326     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEGaussianBlurElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13327     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13328     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEGaussianBlurElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13329     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13330 }
13331
13332 declare var SVGFEGaussianBlurElement: {
13333     prototype: SVGFEGaussianBlurElement;
13334     new(): SVGFEGaussianBlurElement;
13335 };
13336
13337 /** Corresponds to the <feImage> element. */
13338 interface SVGFEImageElement extends SVGElement, SVGFilterPrimitiveStandardAttributes, SVGURIReference {
13339     readonly preserveAspectRatio: SVGAnimatedPreserveAspectRatio;
13340     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEImageElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13341     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13342     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEImageElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13343     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13344 }
13345
13346 declare var SVGFEImageElement: {
13347     prototype: SVGFEImageElement;
13348     new(): SVGFEImageElement;
13349 };
13350
13351 /** Corresponds to the <feMerge> element. */
13352 interface SVGFEMergeElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13353     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEMergeElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13354     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13355     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEMergeElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13356     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13357 }
13358
13359 declare var SVGFEMergeElement: {
13360     prototype: SVGFEMergeElement;
13361     new(): SVGFEMergeElement;
13362 };
13363
13364 /** Corresponds to the <feMergeNode> element. */
13365 interface SVGFEMergeNodeElement extends SVGElement {
13366     readonly in1: SVGAnimatedString;
13367     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEMergeNodeElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13368     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13369     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEMergeNodeElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13370     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13371 }
13372
13373 declare var SVGFEMergeNodeElement: {
13374     prototype: SVGFEMergeNodeElement;
13375     new(): SVGFEMergeNodeElement;
13376 };
13377
13378 /** Corresponds to the <feMorphology> element. */
13379 interface SVGFEMorphologyElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13380     readonly in1: SVGAnimatedString;
13381     readonly operator: SVGAnimatedEnumeration;
13382     readonly radiusX: SVGAnimatedNumber;
13383     readonly radiusY: SVGAnimatedNumber;
13384     readonly SVG_MORPHOLOGY_OPERATOR_DILATE: number;
13385     readonly SVG_MORPHOLOGY_OPERATOR_ERODE: number;
13386     readonly SVG_MORPHOLOGY_OPERATOR_UNKNOWN: number;
13387     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEMorphologyElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13388     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13389     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEMorphologyElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13390     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13391 }
13392
13393 declare var SVGFEMorphologyElement: {
13394     prototype: SVGFEMorphologyElement;
13395     new(): SVGFEMorphologyElement;
13396     readonly SVG_MORPHOLOGY_OPERATOR_DILATE: number;
13397     readonly SVG_MORPHOLOGY_OPERATOR_ERODE: number;
13398     readonly SVG_MORPHOLOGY_OPERATOR_UNKNOWN: number;
13399 };
13400
13401 /** Corresponds to the <feOffset> element. */
13402 interface SVGFEOffsetElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13403     readonly dx: SVGAnimatedNumber;
13404     readonly dy: SVGAnimatedNumber;
13405     readonly in1: SVGAnimatedString;
13406     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEOffsetElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13407     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13408     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEOffsetElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13409     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13410 }
13411
13412 declare var SVGFEOffsetElement: {
13413     prototype: SVGFEOffsetElement;
13414     new(): SVGFEOffsetElement;
13415 };
13416
13417 /** Corresponds to the <fePointLight> element. */
13418 interface SVGFEPointLightElement extends SVGElement {
13419     readonly x: SVGAnimatedNumber;
13420     readonly y: SVGAnimatedNumber;
13421     readonly z: SVGAnimatedNumber;
13422     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEPointLightElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13423     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13424     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEPointLightElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13425     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13426 }
13427
13428 declare var SVGFEPointLightElement: {
13429     prototype: SVGFEPointLightElement;
13430     new(): SVGFEPointLightElement;
13431 };
13432
13433 /** Corresponds to the <feSpecularLighting> element. */
13434 interface SVGFESpecularLightingElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13435     readonly in1: SVGAnimatedString;
13436     readonly kernelUnitLengthX: SVGAnimatedNumber;
13437     readonly kernelUnitLengthY: SVGAnimatedNumber;
13438     readonly specularConstant: SVGAnimatedNumber;
13439     readonly specularExponent: SVGAnimatedNumber;
13440     readonly surfaceScale: SVGAnimatedNumber;
13441     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFESpecularLightingElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13442     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13443     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFESpecularLightingElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13444     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13445 }
13446
13447 declare var SVGFESpecularLightingElement: {
13448     prototype: SVGFESpecularLightingElement;
13449     new(): SVGFESpecularLightingElement;
13450 };
13451
13452 /** Corresponds to the <feSpotLight> element. */
13453 interface SVGFESpotLightElement extends SVGElement {
13454     readonly limitingConeAngle: SVGAnimatedNumber;
13455     readonly pointsAtX: SVGAnimatedNumber;
13456     readonly pointsAtY: SVGAnimatedNumber;
13457     readonly pointsAtZ: SVGAnimatedNumber;
13458     readonly specularExponent: SVGAnimatedNumber;
13459     readonly x: SVGAnimatedNumber;
13460     readonly y: SVGAnimatedNumber;
13461     readonly z: SVGAnimatedNumber;
13462     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFESpotLightElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13463     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13464     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFESpotLightElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13465     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13466 }
13467
13468 declare var SVGFESpotLightElement: {
13469     prototype: SVGFESpotLightElement;
13470     new(): SVGFESpotLightElement;
13471 };
13472
13473 /** Corresponds to the <feTile> element. */
13474 interface SVGFETileElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13475     readonly in1: SVGAnimatedString;
13476     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFETileElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13477     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13478     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFETileElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13479     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13480 }
13481
13482 declare var SVGFETileElement: {
13483     prototype: SVGFETileElement;
13484     new(): SVGFETileElement;
13485 };
13486
13487 /** Corresponds to the <feTurbulence> element. */
13488 interface SVGFETurbulenceElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13489     readonly baseFrequencyX: SVGAnimatedNumber;
13490     readonly baseFrequencyY: SVGAnimatedNumber;
13491     readonly numOctaves: SVGAnimatedInteger;
13492     readonly seed: SVGAnimatedNumber;
13493     readonly stitchTiles: SVGAnimatedEnumeration;
13494     readonly type: SVGAnimatedEnumeration;
13495     readonly SVG_STITCHTYPE_NOSTITCH: number;
13496     readonly SVG_STITCHTYPE_STITCH: number;
13497     readonly SVG_STITCHTYPE_UNKNOWN: number;
13498     readonly SVG_TURBULENCE_TYPE_FRACTALNOISE: number;
13499     readonly SVG_TURBULENCE_TYPE_TURBULENCE: number;
13500     readonly SVG_TURBULENCE_TYPE_UNKNOWN: number;
13501     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFETurbulenceElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13502     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13503     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFETurbulenceElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13504     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13505 }
13506
13507 declare var SVGFETurbulenceElement: {
13508     prototype: SVGFETurbulenceElement;
13509     new(): SVGFETurbulenceElement;
13510     readonly SVG_STITCHTYPE_NOSTITCH: number;
13511     readonly SVG_STITCHTYPE_STITCH: number;
13512     readonly SVG_STITCHTYPE_UNKNOWN: number;
13513     readonly SVG_TURBULENCE_TYPE_FRACTALNOISE: number;
13514     readonly SVG_TURBULENCE_TYPE_TURBULENCE: number;
13515     readonly SVG_TURBULENCE_TYPE_UNKNOWN: number;
13516 };
13517
13518 /** Provides access to the properties of <filter> elements, as well as methods to manipulate them. */
13519 interface SVGFilterElement extends SVGElement, SVGURIReference {
13520     readonly filterUnits: SVGAnimatedEnumeration;
13521     readonly height: SVGAnimatedLength;
13522     readonly primitiveUnits: SVGAnimatedEnumeration;
13523     readonly width: SVGAnimatedLength;
13524     readonly x: SVGAnimatedLength;
13525     readonly y: SVGAnimatedLength;
13526     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFilterElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13527     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13528     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFilterElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13529     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13530 }
13531
13532 declare var SVGFilterElement: {
13533     prototype: SVGFilterElement;
13534     new(): SVGFilterElement;
13535 };
13536
13537 interface SVGFilterPrimitiveStandardAttributes {
13538     readonly height: SVGAnimatedLength;
13539     readonly result: SVGAnimatedString;
13540     readonly width: SVGAnimatedLength;
13541     readonly x: SVGAnimatedLength;
13542     readonly y: SVGAnimatedLength;
13543 }
13544
13545 interface SVGFitToViewBox {
13546     readonly preserveAspectRatio: SVGAnimatedPreserveAspectRatio;
13547     readonly viewBox: SVGAnimatedRect;
13548 }
13549
13550 /** Provides access to the properties of <foreignObject> elements, as well as methods to manipulate them. */
13551 interface SVGForeignObjectElement extends SVGGraphicsElement {
13552     readonly height: SVGAnimatedLength;
13553     readonly width: SVGAnimatedLength;
13554     readonly x: SVGAnimatedLength;
13555     readonly y: SVGAnimatedLength;
13556     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGForeignObjectElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13557     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13558     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGForeignObjectElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13559     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13560 }
13561
13562 declare var SVGForeignObjectElement: {
13563     prototype: SVGForeignObjectElement;
13564     new(): SVGForeignObjectElement;
13565 };
13566
13567 /** Corresponds to the <g> element. */
13568 interface SVGGElement extends SVGGraphicsElement {
13569     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGGElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13570     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13571     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGGElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13572     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13573 }
13574
13575 declare var SVGGElement: {
13576     prototype: SVGGElement;
13577     new(): SVGGElement;
13578 };
13579
13580 interface SVGGeometryElement extends SVGGraphicsElement {
13581     readonly pathLength: SVGAnimatedNumber;
13582     getPointAtLength(distance: number): DOMPoint;
13583     getTotalLength(): number;
13584     isPointInFill(point?: DOMPointInit): boolean;
13585     isPointInStroke(point?: DOMPointInit): boolean;
13586     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGGeometryElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13587     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13588     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGGeometryElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13589     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13590 }
13591
13592 declare var SVGGeometryElement: {
13593     prototype: SVGGeometryElement;
13594     new(): SVGGeometryElement;
13595 };
13596
13597 /** The SVGGradient interface is a base interface used by SVGLinearGradientElement and SVGRadialGradientElement. */
13598 interface SVGGradientElement extends SVGElement, SVGURIReference {
13599     readonly gradientTransform: SVGAnimatedTransformList;
13600     readonly gradientUnits: SVGAnimatedEnumeration;
13601     readonly spreadMethod: SVGAnimatedEnumeration;
13602     readonly SVG_SPREADMETHOD_PAD: number;
13603     readonly SVG_SPREADMETHOD_REFLECT: number;
13604     readonly SVG_SPREADMETHOD_REPEAT: number;
13605     readonly SVG_SPREADMETHOD_UNKNOWN: number;
13606     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGGradientElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13607     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13608     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGGradientElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13609     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13610 }
13611
13612 declare var SVGGradientElement: {
13613     prototype: SVGGradientElement;
13614     new(): SVGGradientElement;
13615     readonly SVG_SPREADMETHOD_PAD: number;
13616     readonly SVG_SPREADMETHOD_REFLECT: number;
13617     readonly SVG_SPREADMETHOD_REPEAT: number;
13618     readonly SVG_SPREADMETHOD_UNKNOWN: number;
13619 };
13620
13621 /** SVG elements whose primary purpose is to directly render graphics into a group. */
13622 interface SVGGraphicsElement extends SVGElement, SVGTests {
13623     readonly transform: SVGAnimatedTransformList;
13624     getBBox(options?: SVGBoundingBoxOptions): DOMRect;
13625     getCTM(): DOMMatrix | null;
13626     getScreenCTM(): DOMMatrix | null;
13627     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGGraphicsElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13628     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13629     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGGraphicsElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13630     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13631 }
13632
13633 declare var SVGGraphicsElement: {
13634     prototype: SVGGraphicsElement;
13635     new(): SVGGraphicsElement;
13636 };
13637
13638 /** Corresponds to the <image> element. */
13639 interface SVGImageElement extends SVGGraphicsElement, SVGURIReference {
13640     readonly height: SVGAnimatedLength;
13641     readonly preserveAspectRatio: SVGAnimatedPreserveAspectRatio;
13642     readonly width: SVGAnimatedLength;
13643     readonly x: SVGAnimatedLength;
13644     readonly y: SVGAnimatedLength;
13645     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGImageElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13646     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13647     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGImageElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13648     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13649 }
13650
13651 declare var SVGImageElement: {
13652     prototype: SVGImageElement;
13653     new(): SVGImageElement;
13654 };
13655
13656 /** Correspond to the <length> basic data type. */
13657 interface SVGLength {
13658     readonly unitType: number;
13659     value: number;
13660     valueAsString: string;
13661     valueInSpecifiedUnits: number;
13662     convertToSpecifiedUnits(unitType: number): void;
13663     newValueSpecifiedUnits(unitType: number, valueInSpecifiedUnits: number): void;
13664     readonly SVG_LENGTHTYPE_CM: number;
13665     readonly SVG_LENGTHTYPE_EMS: number;
13666     readonly SVG_LENGTHTYPE_EXS: number;
13667     readonly SVG_LENGTHTYPE_IN: number;
13668     readonly SVG_LENGTHTYPE_MM: number;
13669     readonly SVG_LENGTHTYPE_NUMBER: number;
13670     readonly SVG_LENGTHTYPE_PC: number;
13671     readonly SVG_LENGTHTYPE_PERCENTAGE: number;
13672     readonly SVG_LENGTHTYPE_PT: number;
13673     readonly SVG_LENGTHTYPE_PX: number;
13674     readonly SVG_LENGTHTYPE_UNKNOWN: number;
13675 }
13676
13677 declare var SVGLength: {
13678     prototype: SVGLength;
13679     new(): SVGLength;
13680     readonly SVG_LENGTHTYPE_CM: number;
13681     readonly SVG_LENGTHTYPE_EMS: number;
13682     readonly SVG_LENGTHTYPE_EXS: number;
13683     readonly SVG_LENGTHTYPE_IN: number;
13684     readonly SVG_LENGTHTYPE_MM: number;
13685     readonly SVG_LENGTHTYPE_NUMBER: number;
13686     readonly SVG_LENGTHTYPE_PC: number;
13687     readonly SVG_LENGTHTYPE_PERCENTAGE: number;
13688     readonly SVG_LENGTHTYPE_PT: number;
13689     readonly SVG_LENGTHTYPE_PX: number;
13690     readonly SVG_LENGTHTYPE_UNKNOWN: number;
13691 };
13692
13693 /** The SVGLengthList defines a list of SVGLength objects. */
13694 interface SVGLengthList {
13695     readonly length: number;
13696     readonly numberOfItems: number;
13697     appendItem(newItem: SVGLength): SVGLength;
13698     clear(): void;
13699     getItem(index: number): SVGLength;
13700     initialize(newItem: SVGLength): SVGLength;
13701     insertItemBefore(newItem: SVGLength, index: number): SVGLength;
13702     removeItem(index: number): SVGLength;
13703     replaceItem(newItem: SVGLength, index: number): SVGLength;
13704     [index: number]: SVGLength;
13705 }
13706
13707 declare var SVGLengthList: {
13708     prototype: SVGLengthList;
13709     new(): SVGLengthList;
13710 };
13711
13712 /** Provides access to the properties of <line> elements, as well as methods to manipulate them. */
13713 interface SVGLineElement extends SVGGeometryElement {
13714     readonly x1: SVGAnimatedLength;
13715     readonly x2: SVGAnimatedLength;
13716     readonly y1: SVGAnimatedLength;
13717     readonly y2: SVGAnimatedLength;
13718     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGLineElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13719     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13720     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGLineElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13721     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13722 }
13723
13724 declare var SVGLineElement: {
13725     prototype: SVGLineElement;
13726     new(): SVGLineElement;
13727 };
13728
13729 /** Corresponds to the <linearGradient> element. */
13730 interface SVGLinearGradientElement extends SVGGradientElement {
13731     readonly x1: SVGAnimatedLength;
13732     readonly x2: SVGAnimatedLength;
13733     readonly y1: SVGAnimatedLength;
13734     readonly y2: SVGAnimatedLength;
13735     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGLinearGradientElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13736     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13737     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGLinearGradientElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13738     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13739 }
13740
13741 declare var SVGLinearGradientElement: {
13742     prototype: SVGLinearGradientElement;
13743     new(): SVGLinearGradientElement;
13744 };
13745
13746 interface SVGMarkerElement extends SVGElement, SVGFitToViewBox {
13747     readonly markerHeight: SVGAnimatedLength;
13748     readonly markerUnits: SVGAnimatedEnumeration;
13749     readonly markerWidth: SVGAnimatedLength;
13750     readonly orientAngle: SVGAnimatedAngle;
13751     readonly orientType: SVGAnimatedEnumeration;
13752     readonly refX: SVGAnimatedLength;
13753     readonly refY: SVGAnimatedLength;
13754     setOrientToAngle(angle: SVGAngle): void;
13755     setOrientToAuto(): void;
13756     readonly SVG_MARKERUNITS_STROKEWIDTH: number;
13757     readonly SVG_MARKERUNITS_UNKNOWN: number;
13758     readonly SVG_MARKERUNITS_USERSPACEONUSE: number;
13759     readonly SVG_MARKER_ORIENT_ANGLE: number;
13760     readonly SVG_MARKER_ORIENT_AUTO: number;
13761     readonly SVG_MARKER_ORIENT_UNKNOWN: number;
13762     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGMarkerElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13763     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13764     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGMarkerElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13765     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13766 }
13767
13768 declare var SVGMarkerElement: {
13769     prototype: SVGMarkerElement;
13770     new(): SVGMarkerElement;
13771     readonly SVG_MARKERUNITS_STROKEWIDTH: number;
13772     readonly SVG_MARKERUNITS_UNKNOWN: number;
13773     readonly SVG_MARKERUNITS_USERSPACEONUSE: number;
13774     readonly SVG_MARKER_ORIENT_ANGLE: number;
13775     readonly SVG_MARKER_ORIENT_AUTO: number;
13776     readonly SVG_MARKER_ORIENT_UNKNOWN: number;
13777 };
13778
13779 /** Provides access to the properties of <mask> elements, as well as methods to manipulate them. */
13780 interface SVGMaskElement extends SVGElement {
13781     readonly height: SVGAnimatedLength;
13782     readonly maskContentUnits: SVGAnimatedEnumeration;
13783     readonly maskUnits: SVGAnimatedEnumeration;
13784     readonly width: SVGAnimatedLength;
13785     readonly x: SVGAnimatedLength;
13786     readonly y: SVGAnimatedLength;
13787     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGMaskElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13788     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13789     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGMaskElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13790     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13791 }
13792
13793 declare var SVGMaskElement: {
13794     prototype: SVGMaskElement;
13795     new(): SVGMaskElement;
13796 };
13797
13798 /** Corresponds to the <metadata> element. */
13799 interface SVGMetadataElement extends SVGElement {
13800     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGMetadataElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13801     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13802     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGMetadataElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13803     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13804 }
13805
13806 declare var SVGMetadataElement: {
13807     prototype: SVGMetadataElement;
13808     new(): SVGMetadataElement;
13809 };
13810
13811 /** Corresponds to the <number> basic data type. */
13812 interface SVGNumber {
13813     value: number;
13814 }
13815
13816 declare var SVGNumber: {
13817     prototype: SVGNumber;
13818     new(): SVGNumber;
13819 };
13820
13821 /** The SVGNumberList defines a list of SVGNumber objects. */
13822 interface SVGNumberList {
13823     readonly length: number;
13824     readonly numberOfItems: number;
13825     appendItem(newItem: SVGNumber): SVGNumber;
13826     clear(): void;
13827     getItem(index: number): SVGNumber;
13828     initialize(newItem: SVGNumber): SVGNumber;
13829     insertItemBefore(newItem: SVGNumber, index: number): SVGNumber;
13830     removeItem(index: number): SVGNumber;
13831     replaceItem(newItem: SVGNumber, index: number): SVGNumber;
13832     [index: number]: SVGNumber;
13833 }
13834
13835 declare var SVGNumberList: {
13836     prototype: SVGNumberList;
13837     new(): SVGNumberList;
13838 };
13839
13840 /** Corresponds to the <path> element. */
13841 interface SVGPathElement extends SVGGraphicsElement {
13842     /** @deprecated */
13843     readonly pathSegList: SVGPathSegList;
13844     /** @deprecated */
13845     createSVGPathSegArcAbs(x: number, y: number, r1: number, r2: number, angle: number, largeArcFlag: boolean, sweepFlag: boolean): SVGPathSegArcAbs;
13846     /** @deprecated */
13847     createSVGPathSegArcRel(x: number, y: number, r1: number, r2: number, angle: number, largeArcFlag: boolean, sweepFlag: boolean): SVGPathSegArcRel;
13848     /** @deprecated */
13849     createSVGPathSegClosePath(): SVGPathSegClosePath;
13850     /** @deprecated */
13851     createSVGPathSegCurvetoCubicAbs(x: number, y: number, x1: number, y1: number, x2: number, y2: number): SVGPathSegCurvetoCubicAbs;
13852     /** @deprecated */
13853     createSVGPathSegCurvetoCubicRel(x: number, y: number, x1: number, y1: number, x2: number, y2: number): SVGPathSegCurvetoCubicRel;
13854     /** @deprecated */
13855     createSVGPathSegCurvetoCubicSmoothAbs(x: number, y: number, x2: number, y2: number): SVGPathSegCurvetoCubicSmoothAbs;
13856     /** @deprecated */
13857     createSVGPathSegCurvetoCubicSmoothRel(x: number, y: number, x2: number, y2: number): SVGPathSegCurvetoCubicSmoothRel;
13858     /** @deprecated */
13859     createSVGPathSegCurvetoQuadraticAbs(x: number, y: number, x1: number, y1: number): SVGPathSegCurvetoQuadraticAbs;
13860     /** @deprecated */
13861     createSVGPathSegCurvetoQuadraticRel(x: number, y: number, x1: number, y1: number): SVGPathSegCurvetoQuadraticRel;
13862     /** @deprecated */
13863     createSVGPathSegCurvetoQuadraticSmoothAbs(x: number, y: number): SVGPathSegCurvetoQuadraticSmoothAbs;
13864     /** @deprecated */
13865     createSVGPathSegCurvetoQuadraticSmoothRel(x: number, y: number): SVGPathSegCurvetoQuadraticSmoothRel;
13866     /** @deprecated */
13867     createSVGPathSegLinetoAbs(x: number, y: number): SVGPathSegLinetoAbs;
13868     /** @deprecated */
13869     createSVGPathSegLinetoHorizontalAbs(x: number): SVGPathSegLinetoHorizontalAbs;
13870     /** @deprecated */
13871     createSVGPathSegLinetoHorizontalRel(x: number): SVGPathSegLinetoHorizontalRel;
13872     /** @deprecated */
13873     createSVGPathSegLinetoRel(x: number, y: number): SVGPathSegLinetoRel;
13874     /** @deprecated */
13875     createSVGPathSegLinetoVerticalAbs(y: number): SVGPathSegLinetoVerticalAbs;
13876     /** @deprecated */
13877     createSVGPathSegLinetoVerticalRel(y: number): SVGPathSegLinetoVerticalRel;
13878     /** @deprecated */
13879     createSVGPathSegMovetoAbs(x: number, y: number): SVGPathSegMovetoAbs;
13880     /** @deprecated */
13881     createSVGPathSegMovetoRel(x: number, y: number): SVGPathSegMovetoRel;
13882     /** @deprecated */
13883     getPathSegAtLength(distance: number): number;
13884     getPointAtLength(distance: number): SVGPoint;
13885     getTotalLength(): number;
13886     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGPathElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13887     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13888     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGPathElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13889     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13890 }
13891
13892 declare var SVGPathElement: {
13893     prototype: SVGPathElement;
13894     new(): SVGPathElement;
13895 };
13896
13897 interface SVGPathSeg {
13898     readonly pathSegType: number;
13899     readonly pathSegTypeAsLetter: string;
13900     readonly PATHSEG_ARC_ABS: number;
13901     readonly PATHSEG_ARC_REL: number;
13902     readonly PATHSEG_CLOSEPATH: number;
13903     readonly PATHSEG_CURVETO_CUBIC_ABS: number;
13904     readonly PATHSEG_CURVETO_CUBIC_REL: number;
13905     readonly PATHSEG_CURVETO_CUBIC_SMOOTH_ABS: number;
13906     readonly PATHSEG_CURVETO_CUBIC_SMOOTH_REL: number;
13907     readonly PATHSEG_CURVETO_QUADRATIC_ABS: number;
13908     readonly PATHSEG_CURVETO_QUADRATIC_REL: number;
13909     readonly PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS: number;
13910     readonly PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL: number;
13911     readonly PATHSEG_LINETO_ABS: number;
13912     readonly PATHSEG_LINETO_HORIZONTAL_ABS: number;
13913     readonly PATHSEG_LINETO_HORIZONTAL_REL: number;
13914     readonly PATHSEG_LINETO_REL: number;
13915     readonly PATHSEG_LINETO_VERTICAL_ABS: number;
13916     readonly PATHSEG_LINETO_VERTICAL_REL: number;
13917     readonly PATHSEG_MOVETO_ABS: number;
13918     readonly PATHSEG_MOVETO_REL: number;
13919     readonly PATHSEG_UNKNOWN: number;
13920 }
13921
13922 declare var SVGPathSeg: {
13923     prototype: SVGPathSeg;
13924     new(): SVGPathSeg;
13925     readonly PATHSEG_ARC_ABS: number;
13926     readonly PATHSEG_ARC_REL: number;
13927     readonly PATHSEG_CLOSEPATH: number;
13928     readonly PATHSEG_CURVETO_CUBIC_ABS: number;
13929     readonly PATHSEG_CURVETO_CUBIC_REL: number;
13930     readonly PATHSEG_CURVETO_CUBIC_SMOOTH_ABS: number;
13931     readonly PATHSEG_CURVETO_CUBIC_SMOOTH_REL: number;
13932     readonly PATHSEG_CURVETO_QUADRATIC_ABS: number;
13933     readonly PATHSEG_CURVETO_QUADRATIC_REL: number;
13934     readonly PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS: number;
13935     readonly PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL: number;
13936     readonly PATHSEG_LINETO_ABS: number;
13937     readonly PATHSEG_LINETO_HORIZONTAL_ABS: number;
13938     readonly PATHSEG_LINETO_HORIZONTAL_REL: number;
13939     readonly PATHSEG_LINETO_REL: number;
13940     readonly PATHSEG_LINETO_VERTICAL_ABS: number;
13941     readonly PATHSEG_LINETO_VERTICAL_REL: number;
13942     readonly PATHSEG_MOVETO_ABS: number;
13943     readonly PATHSEG_MOVETO_REL: number;
13944     readonly PATHSEG_UNKNOWN: number;
13945 };
13946
13947 interface SVGPathSegArcAbs extends SVGPathSeg {
13948     angle: number;
13949     largeArcFlag: boolean;
13950     r1: number;
13951     r2: number;
13952     sweepFlag: boolean;
13953     x: number;
13954     y: number;
13955 }
13956
13957 declare var SVGPathSegArcAbs: {
13958     prototype: SVGPathSegArcAbs;
13959     new(): SVGPathSegArcAbs;
13960 };
13961
13962 interface SVGPathSegArcRel extends SVGPathSeg {
13963     angle: number;
13964     largeArcFlag: boolean;
13965     r1: number;
13966     r2: number;
13967     sweepFlag: boolean;
13968     x: number;
13969     y: number;
13970 }
13971
13972 declare var SVGPathSegArcRel: {
13973     prototype: SVGPathSegArcRel;
13974     new(): SVGPathSegArcRel;
13975 };
13976
13977 interface SVGPathSegClosePath extends SVGPathSeg {
13978 }
13979
13980 declare var SVGPathSegClosePath: {
13981     prototype: SVGPathSegClosePath;
13982     new(): SVGPathSegClosePath;
13983 };
13984
13985 interface SVGPathSegCurvetoCubicAbs extends SVGPathSeg {
13986     x: number;
13987     x1: number;
13988     x2: number;
13989     y: number;
13990     y1: number;
13991     y2: number;
13992 }
13993
13994 declare var SVGPathSegCurvetoCubicAbs: {
13995     prototype: SVGPathSegCurvetoCubicAbs;
13996     new(): SVGPathSegCurvetoCubicAbs;
13997 };
13998
13999 interface SVGPathSegCurvetoCubicRel extends SVGPathSeg {
14000     x: number;
14001     x1: number;
14002     x2: number;
14003     y: number;
14004     y1: number;
14005     y2: number;
14006 }
14007
14008 declare var SVGPathSegCurvetoCubicRel: {
14009     prototype: SVGPathSegCurvetoCubicRel;
14010     new(): SVGPathSegCurvetoCubicRel;
14011 };
14012
14013 interface SVGPathSegCurvetoCubicSmoothAbs extends SVGPathSeg {
14014     x: number;
14015     x2: number;
14016     y: number;
14017     y2: number;
14018 }
14019
14020 declare var SVGPathSegCurvetoCubicSmoothAbs: {
14021     prototype: SVGPathSegCurvetoCubicSmoothAbs;
14022     new(): SVGPathSegCurvetoCubicSmoothAbs;
14023 };
14024
14025 interface SVGPathSegCurvetoCubicSmoothRel extends SVGPathSeg {
14026     x: number;
14027     x2: number;
14028     y: number;
14029     y2: number;
14030 }
14031
14032 declare var SVGPathSegCurvetoCubicSmoothRel: {
14033     prototype: SVGPathSegCurvetoCubicSmoothRel;
14034     new(): SVGPathSegCurvetoCubicSmoothRel;
14035 };
14036
14037 interface SVGPathSegCurvetoQuadraticAbs extends SVGPathSeg {
14038     x: number;
14039     x1: number;
14040     y: number;
14041     y1: number;
14042 }
14043
14044 declare var SVGPathSegCurvetoQuadraticAbs: {
14045     prototype: SVGPathSegCurvetoQuadraticAbs;
14046     new(): SVGPathSegCurvetoQuadraticAbs;
14047 };
14048
14049 interface SVGPathSegCurvetoQuadraticRel extends SVGPathSeg {
14050     x: number;
14051     x1: number;
14052     y: number;
14053     y1: number;
14054 }
14055
14056 declare var SVGPathSegCurvetoQuadraticRel: {
14057     prototype: SVGPathSegCurvetoQuadraticRel;
14058     new(): SVGPathSegCurvetoQuadraticRel;
14059 };
14060
14061 interface SVGPathSegCurvetoQuadraticSmoothAbs extends SVGPathSeg {
14062     x: number;
14063     y: number;
14064 }
14065
14066 declare var SVGPathSegCurvetoQuadraticSmoothAbs: {
14067     prototype: SVGPathSegCurvetoQuadraticSmoothAbs;
14068     new(): SVGPathSegCurvetoQuadraticSmoothAbs;
14069 };
14070
14071 interface SVGPathSegCurvetoQuadraticSmoothRel extends SVGPathSeg {
14072     x: number;
14073     y: number;
14074 }
14075
14076 declare var SVGPathSegCurvetoQuadraticSmoothRel: {
14077     prototype: SVGPathSegCurvetoQuadraticSmoothRel;
14078     new(): SVGPathSegCurvetoQuadraticSmoothRel;
14079 };
14080
14081 interface SVGPathSegLinetoAbs extends SVGPathSeg {
14082     x: number;
14083     y: number;
14084 }
14085
14086 declare var SVGPathSegLinetoAbs: {
14087     prototype: SVGPathSegLinetoAbs;
14088     new(): SVGPathSegLinetoAbs;
14089 };
14090
14091 interface SVGPathSegLinetoHorizontalAbs extends SVGPathSeg {
14092     x: number;
14093 }
14094
14095 declare var SVGPathSegLinetoHorizontalAbs: {
14096     prototype: SVGPathSegLinetoHorizontalAbs;
14097     new(): SVGPathSegLinetoHorizontalAbs;
14098 };
14099
14100 interface SVGPathSegLinetoHorizontalRel extends SVGPathSeg {
14101     x: number;
14102 }
14103
14104 declare var SVGPathSegLinetoHorizontalRel: {
14105     prototype: SVGPathSegLinetoHorizontalRel;
14106     new(): SVGPathSegLinetoHorizontalRel;
14107 };
14108
14109 interface SVGPathSegLinetoRel extends SVGPathSeg {
14110     x: number;
14111     y: number;
14112 }
14113
14114 declare var SVGPathSegLinetoRel: {
14115     prototype: SVGPathSegLinetoRel;
14116     new(): SVGPathSegLinetoRel;
14117 };
14118
14119 interface SVGPathSegLinetoVerticalAbs extends SVGPathSeg {
14120     y: number;
14121 }
14122
14123 declare var SVGPathSegLinetoVerticalAbs: {
14124     prototype: SVGPathSegLinetoVerticalAbs;
14125     new(): SVGPathSegLinetoVerticalAbs;
14126 };
14127
14128 interface SVGPathSegLinetoVerticalRel extends SVGPathSeg {
14129     y: number;
14130 }
14131
14132 declare var SVGPathSegLinetoVerticalRel: {
14133     prototype: SVGPathSegLinetoVerticalRel;
14134     new(): SVGPathSegLinetoVerticalRel;
14135 };
14136
14137 interface SVGPathSegList {
14138     readonly numberOfItems: number;
14139     appendItem(newItem: SVGPathSeg): SVGPathSeg;
14140     clear(): void;
14141     getItem(index: number): SVGPathSeg;
14142     initialize(newItem: SVGPathSeg): SVGPathSeg;
14143     insertItemBefore(newItem: SVGPathSeg, index: number): SVGPathSeg;
14144     removeItem(index: number): SVGPathSeg;
14145     replaceItem(newItem: SVGPathSeg, index: number): SVGPathSeg;
14146 }
14147
14148 declare var SVGPathSegList: {
14149     prototype: SVGPathSegList;
14150     new(): SVGPathSegList;
14151 };
14152
14153 interface SVGPathSegMovetoAbs extends SVGPathSeg {
14154     x: number;
14155     y: number;
14156 }
14157
14158 declare var SVGPathSegMovetoAbs: {
14159     prototype: SVGPathSegMovetoAbs;
14160     new(): SVGPathSegMovetoAbs;
14161 };
14162
14163 interface SVGPathSegMovetoRel extends SVGPathSeg {
14164     x: number;
14165     y: number;
14166 }
14167
14168 declare var SVGPathSegMovetoRel: {
14169     prototype: SVGPathSegMovetoRel;
14170     new(): SVGPathSegMovetoRel;
14171 };
14172
14173 /** Corresponds to the <pattern> element. */
14174 interface SVGPatternElement extends SVGElement, SVGFitToViewBox, SVGURIReference {
14175     readonly height: SVGAnimatedLength;
14176     readonly patternContentUnits: SVGAnimatedEnumeration;
14177     readonly patternTransform: SVGAnimatedTransformList;
14178     readonly patternUnits: SVGAnimatedEnumeration;
14179     readonly width: SVGAnimatedLength;
14180     readonly x: SVGAnimatedLength;
14181     readonly y: SVGAnimatedLength;
14182     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGPatternElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14183     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14184     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGPatternElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14185     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14186 }
14187
14188 declare var SVGPatternElement: {
14189     prototype: SVGPatternElement;
14190     new(): SVGPatternElement;
14191 };
14192
14193 interface SVGPointList {
14194     readonly length: number;
14195     readonly numberOfItems: number;
14196     appendItem(newItem: DOMPoint): DOMPoint;
14197     clear(): void;
14198     getItem(index: number): DOMPoint;
14199     initialize(newItem: DOMPoint): DOMPoint;
14200     insertItemBefore(newItem: DOMPoint, index: number): DOMPoint;
14201     removeItem(index: number): DOMPoint;
14202     replaceItem(newItem: DOMPoint, index: number): DOMPoint;
14203     [index: number]: DOMPoint;
14204 }
14205
14206 declare var SVGPointList: {
14207     prototype: SVGPointList;
14208     new(): SVGPointList;
14209 };
14210
14211 /** Provides access to the properties of <polygon> elements, as well as methods to manipulate them. */
14212 interface SVGPolygonElement extends SVGGeometryElement, SVGAnimatedPoints {
14213     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGPolygonElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14214     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14215     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGPolygonElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14216     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14217 }
14218
14219 declare var SVGPolygonElement: {
14220     prototype: SVGPolygonElement;
14221     new(): SVGPolygonElement;
14222 };
14223
14224 /** Provides access to the properties of <polyline> elements, as well as methods to manipulate them. */
14225 interface SVGPolylineElement extends SVGGeometryElement, SVGAnimatedPoints {
14226     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGPolylineElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14227     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14228     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGPolylineElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14229     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14230 }
14231
14232 declare var SVGPolylineElement: {
14233     prototype: SVGPolylineElement;
14234     new(): SVGPolylineElement;
14235 };
14236
14237 /** Corresponds to the preserveAspectRatio attribute, which is available for some of SVG's elements. */
14238 interface SVGPreserveAspectRatio {
14239     align: number;
14240     meetOrSlice: number;
14241     readonly SVG_MEETORSLICE_MEET: number;
14242     readonly SVG_MEETORSLICE_SLICE: number;
14243     readonly SVG_MEETORSLICE_UNKNOWN: number;
14244     readonly SVG_PRESERVEASPECTRATIO_NONE: number;
14245     readonly SVG_PRESERVEASPECTRATIO_UNKNOWN: number;
14246     readonly SVG_PRESERVEASPECTRATIO_XMAXYMAX: number;
14247     readonly SVG_PRESERVEASPECTRATIO_XMAXYMID: number;
14248     readonly SVG_PRESERVEASPECTRATIO_XMAXYMIN: number;
14249     readonly SVG_PRESERVEASPECTRATIO_XMIDYMAX: number;
14250     readonly SVG_PRESERVEASPECTRATIO_XMIDYMID: number;
14251     readonly SVG_PRESERVEASPECTRATIO_XMIDYMIN: number;
14252     readonly SVG_PRESERVEASPECTRATIO_XMINYMAX: number;
14253     readonly SVG_PRESERVEASPECTRATIO_XMINYMID: number;
14254     readonly SVG_PRESERVEASPECTRATIO_XMINYMIN: number;
14255 }
14256
14257 declare var SVGPreserveAspectRatio: {
14258     prototype: SVGPreserveAspectRatio;
14259     new(): SVGPreserveAspectRatio;
14260     readonly SVG_MEETORSLICE_MEET: number;
14261     readonly SVG_MEETORSLICE_SLICE: number;
14262     readonly SVG_MEETORSLICE_UNKNOWN: number;
14263     readonly SVG_PRESERVEASPECTRATIO_NONE: number;
14264     readonly SVG_PRESERVEASPECTRATIO_UNKNOWN: number;
14265     readonly SVG_PRESERVEASPECTRATIO_XMAXYMAX: number;
14266     readonly SVG_PRESERVEASPECTRATIO_XMAXYMID: number;
14267     readonly SVG_PRESERVEASPECTRATIO_XMAXYMIN: number;
14268     readonly SVG_PRESERVEASPECTRATIO_XMIDYMAX: number;
14269     readonly SVG_PRESERVEASPECTRATIO_XMIDYMID: number;
14270     readonly SVG_PRESERVEASPECTRATIO_XMIDYMIN: number;
14271     readonly SVG_PRESERVEASPECTRATIO_XMINYMAX: number;
14272     readonly SVG_PRESERVEASPECTRATIO_XMINYMID: number;
14273     readonly SVG_PRESERVEASPECTRATIO_XMINYMIN: number;
14274 };
14275
14276 /** Corresponds to the <RadialGradient> element. */
14277 interface SVGRadialGradientElement extends SVGGradientElement {
14278     readonly cx: SVGAnimatedLength;
14279     readonly cy: SVGAnimatedLength;
14280     readonly fr: SVGAnimatedLength;
14281     readonly fx: SVGAnimatedLength;
14282     readonly fy: SVGAnimatedLength;
14283     readonly r: SVGAnimatedLength;
14284     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGRadialGradientElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14285     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14286     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGRadialGradientElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14287     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14288 }
14289
14290 declare var SVGRadialGradientElement: {
14291     prototype: SVGRadialGradientElement;
14292     new(): SVGRadialGradientElement;
14293 };
14294
14295 /** Provides access to the properties of <rect> elements, as well as methods to manipulate them. */
14296 interface SVGRectElement extends SVGGeometryElement {
14297     readonly height: SVGAnimatedLength;
14298     readonly rx: SVGAnimatedLength;
14299     readonly ry: SVGAnimatedLength;
14300     readonly width: SVGAnimatedLength;
14301     readonly x: SVGAnimatedLength;
14302     readonly y: SVGAnimatedLength;
14303     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGRectElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14304     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14305     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGRectElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14306     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14307 }
14308
14309 declare var SVGRectElement: {
14310     prototype: SVGRectElement;
14311     new(): SVGRectElement;
14312 };
14313
14314 interface SVGSVGElementEventMap extends SVGElementEventMap {
14315     "SVGUnload": Event;
14316     "SVGZoom": SVGZoomEvent;
14317 }
14318
14319 /** 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. */
14320 interface SVGSVGElement extends SVGGraphicsElement, DocumentEvent, SVGFitToViewBox, SVGZoomAndPan {
14321     /** @deprecated */
14322     contentScriptType: string;
14323     /** @deprecated */
14324     contentStyleType: string;
14325     currentScale: number;
14326     readonly currentTranslate: SVGPoint;
14327     readonly height: SVGAnimatedLength;
14328     onunload: ((this: SVGSVGElement, ev: Event) => any) | null;
14329     onzoom: ((this: SVGSVGElement, ev: SVGZoomEvent) => any) | null;
14330     /** @deprecated */
14331     readonly pixelUnitToMillimeterX: number;
14332     /** @deprecated */
14333     readonly pixelUnitToMillimeterY: number;
14334     /** @deprecated */
14335     readonly screenPixelToMillimeterX: number;
14336     /** @deprecated */
14337     readonly screenPixelToMillimeterY: number;
14338     /** @deprecated */
14339     readonly viewport: SVGRect;
14340     readonly width: SVGAnimatedLength;
14341     readonly x: SVGAnimatedLength;
14342     readonly y: SVGAnimatedLength;
14343     animationsPaused(): boolean;
14344     checkEnclosure(element: SVGElement, rect: SVGRect): boolean;
14345     checkIntersection(element: SVGElement, rect: SVGRect): boolean;
14346     createSVGAngle(): SVGAngle;
14347     createSVGLength(): SVGLength;
14348     createSVGMatrix(): SVGMatrix;
14349     createSVGNumber(): SVGNumber;
14350     createSVGPoint(): SVGPoint;
14351     createSVGRect(): SVGRect;
14352     createSVGTransform(): SVGTransform;
14353     createSVGTransformFromMatrix(matrix: SVGMatrix): SVGTransform;
14354     deselectAll(): void;
14355     /** @deprecated */
14356     forceRedraw(): void;
14357     getComputedStyle(elt: Element, pseudoElt?: string | null): CSSStyleDeclaration;
14358     getCurrentTime(): number;
14359     getElementById(elementId: string): Element;
14360     getEnclosureList(rect: SVGRect, referenceElement: SVGElement): NodeListOf<SVGCircleElement | SVGEllipseElement | SVGImageElement | SVGLineElement | SVGPathElement | SVGPolygonElement | SVGPolylineElement | SVGRectElement | SVGTextElement | SVGUseElement>;
14361     getIntersectionList(rect: SVGRect, referenceElement: SVGElement): NodeListOf<SVGCircleElement | SVGEllipseElement | SVGImageElement | SVGLineElement | SVGPathElement | SVGPolygonElement | SVGPolylineElement | SVGRectElement | SVGTextElement | SVGUseElement>;
14362     pauseAnimations(): void;
14363     setCurrentTime(seconds: number): void;
14364     /** @deprecated */
14365     suspendRedraw(maxWaitMilliseconds: number): number;
14366     unpauseAnimations(): void;
14367     /** @deprecated */
14368     unsuspendRedraw(suspendHandleID: number): void;
14369     /** @deprecated */
14370     unsuspendRedrawAll(): void;
14371     addEventListener<K extends keyof SVGSVGElementEventMap>(type: K, listener: (this: SVGSVGElement, ev: SVGSVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14372     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14373     removeEventListener<K extends keyof SVGSVGElementEventMap>(type: K, listener: (this: SVGSVGElement, ev: SVGSVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14374     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14375 }
14376
14377 declare var SVGSVGElement: {
14378     prototype: SVGSVGElement;
14379     new(): SVGSVGElement;
14380     readonly SVG_ZOOMANDPAN_DISABLE: number;
14381     readonly SVG_ZOOMANDPAN_MAGNIFY: number;
14382     readonly SVG_ZOOMANDPAN_UNKNOWN: number;
14383 };
14384
14385 /** Corresponds to the SVG <script> element. */
14386 interface SVGScriptElement extends SVGElement, SVGURIReference {
14387     type: string;
14388     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGScriptElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14389     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14390     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGScriptElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14391     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14392 }
14393
14394 declare var SVGScriptElement: {
14395     prototype: SVGScriptElement;
14396     new(): SVGScriptElement;
14397 };
14398
14399 /** Corresponds to the <stop> element. */
14400 interface SVGStopElement extends SVGElement {
14401     readonly offset: SVGAnimatedNumber;
14402     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGStopElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14403     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14404     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGStopElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14405     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14406 }
14407
14408 declare var SVGStopElement: {
14409     prototype: SVGStopElement;
14410     new(): SVGStopElement;
14411 };
14412
14413 /** The SVGStringList defines a list of DOMString objects. */
14414 interface SVGStringList {
14415     readonly length: number;
14416     readonly numberOfItems: number;
14417     appendItem(newItem: string): string;
14418     clear(): void;
14419     getItem(index: number): string;
14420     initialize(newItem: string): string;
14421     insertItemBefore(newItem: string, index: number): string;
14422     removeItem(index: number): string;
14423     replaceItem(newItem: string, index: number): string;
14424     [index: number]: string;
14425 }
14426
14427 declare var SVGStringList: {
14428     prototype: SVGStringList;
14429     new(): SVGStringList;
14430 };
14431
14432 /** Corresponds to the SVG <style> element. */
14433 interface SVGStyleElement extends SVGElement {
14434     disabled: boolean;
14435     media: string;
14436     title: string;
14437     type: string;
14438     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGStyleElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14439     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14440     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGStyleElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14441     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14442 }
14443
14444 declare var SVGStyleElement: {
14445     prototype: SVGStyleElement;
14446     new(): SVGStyleElement;
14447 };
14448
14449 /** Corresponds to the <switch> element. */
14450 interface SVGSwitchElement extends SVGGraphicsElement {
14451     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGSwitchElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14452     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14453     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGSwitchElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14454     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14455 }
14456
14457 declare var SVGSwitchElement: {
14458     prototype: SVGSwitchElement;
14459     new(): SVGSwitchElement;
14460 };
14461
14462 /** Corresponds to the <symbol> element. */
14463 interface SVGSymbolElement extends SVGElement, SVGFitToViewBox {
14464     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGSymbolElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14465     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14466     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGSymbolElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14467     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14468 }
14469
14470 declare var SVGSymbolElement: {
14471     prototype: SVGSymbolElement;
14472     new(): SVGSymbolElement;
14473 };
14474
14475 /** A <tspan> element. */
14476 interface SVGTSpanElement extends SVGTextPositioningElement {
14477     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTSpanElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14478     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14479     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTSpanElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14480     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14481 }
14482
14483 declare var SVGTSpanElement: {
14484     prototype: SVGTSpanElement;
14485     new(): SVGTSpanElement;
14486 };
14487
14488 interface SVGTests {
14489     readonly requiredExtensions: SVGStringList;
14490     readonly systemLanguage: SVGStringList;
14491 }
14492
14493 /** 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. */
14494 interface SVGTextContentElement extends SVGGraphicsElement {
14495     readonly lengthAdjust: SVGAnimatedEnumeration;
14496     readonly textLength: SVGAnimatedLength;
14497     getCharNumAtPosition(point?: DOMPointInit): number;
14498     getComputedTextLength(): number;
14499     getEndPositionOfChar(charnum: number): DOMPoint;
14500     getExtentOfChar(charnum: number): DOMRect;
14501     getNumberOfChars(): number;
14502     getRotationOfChar(charnum: number): number;
14503     getStartPositionOfChar(charnum: number): DOMPoint;
14504     getSubStringLength(charnum: number, nchars: number): number;
14505     selectSubString(charnum: number, nchars: number): void;
14506     readonly LENGTHADJUST_SPACING: number;
14507     readonly LENGTHADJUST_SPACINGANDGLYPHS: number;
14508     readonly LENGTHADJUST_UNKNOWN: number;
14509     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTextContentElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14510     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14511     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTextContentElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14512     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14513 }
14514
14515 declare var SVGTextContentElement: {
14516     prototype: SVGTextContentElement;
14517     new(): SVGTextContentElement;
14518     readonly LENGTHADJUST_SPACING: number;
14519     readonly LENGTHADJUST_SPACINGANDGLYPHS: number;
14520     readonly LENGTHADJUST_UNKNOWN: number;
14521 };
14522
14523 /** Corresponds to the <text> elements. */
14524 interface SVGTextElement extends SVGTextPositioningElement {
14525     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTextElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14526     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14527     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTextElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14528     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14529 }
14530
14531 declare var SVGTextElement: {
14532     prototype: SVGTextElement;
14533     new(): SVGTextElement;
14534 };
14535
14536 /** Corresponds to the <textPath> element. */
14537 interface SVGTextPathElement extends SVGTextContentElement, SVGURIReference {
14538     readonly method: SVGAnimatedEnumeration;
14539     readonly spacing: SVGAnimatedEnumeration;
14540     readonly startOffset: SVGAnimatedLength;
14541     readonly TEXTPATH_METHODTYPE_ALIGN: number;
14542     readonly TEXTPATH_METHODTYPE_STRETCH: number;
14543     readonly TEXTPATH_METHODTYPE_UNKNOWN: number;
14544     readonly TEXTPATH_SPACINGTYPE_AUTO: number;
14545     readonly TEXTPATH_SPACINGTYPE_EXACT: number;
14546     readonly TEXTPATH_SPACINGTYPE_UNKNOWN: number;
14547     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTextPathElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14548     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14549     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTextPathElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14550     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14551 }
14552
14553 declare var SVGTextPathElement: {
14554     prototype: SVGTextPathElement;
14555     new(): SVGTextPathElement;
14556     readonly TEXTPATH_METHODTYPE_ALIGN: number;
14557     readonly TEXTPATH_METHODTYPE_STRETCH: number;
14558     readonly TEXTPATH_METHODTYPE_UNKNOWN: number;
14559     readonly TEXTPATH_SPACINGTYPE_AUTO: number;
14560     readonly TEXTPATH_SPACINGTYPE_EXACT: number;
14561     readonly TEXTPATH_SPACINGTYPE_UNKNOWN: number;
14562 };
14563
14564 /** Implemented by elements that support attributes that position individual text glyphs. It is inherited by SVGTextElement, SVGTSpanElement, SVGTRefElement and SVGAltGlyphElement. */
14565 interface SVGTextPositioningElement extends SVGTextContentElement {
14566     readonly dx: SVGAnimatedLengthList;
14567     readonly dy: SVGAnimatedLengthList;
14568     readonly rotate: SVGAnimatedNumberList;
14569     readonly x: SVGAnimatedLengthList;
14570     readonly y: SVGAnimatedLengthList;
14571     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTextPositioningElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14572     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14573     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTextPositioningElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14574     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14575 }
14576
14577 declare var SVGTextPositioningElement: {
14578     prototype: SVGTextPositioningElement;
14579     new(): SVGTextPositioningElement;
14580 };
14581
14582 /** Corresponds to the <title> element. */
14583 interface SVGTitleElement extends SVGElement {
14584     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTitleElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14585     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14586     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTitleElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14587     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14588 }
14589
14590 declare var SVGTitleElement: {
14591     prototype: SVGTitleElement;
14592     new(): SVGTitleElement;
14593 };
14594
14595 /** 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. */
14596 interface SVGTransform {
14597     readonly angle: number;
14598     readonly matrix: SVGMatrix;
14599     readonly type: number;
14600     setMatrix(matrix: SVGMatrix): void;
14601     setRotate(angle: number, cx: number, cy: number): void;
14602     setScale(sx: number, sy: number): void;
14603     setSkewX(angle: number): void;
14604     setSkewY(angle: number): void;
14605     setTranslate(tx: number, ty: number): void;
14606     readonly SVG_TRANSFORM_MATRIX: number;
14607     readonly SVG_TRANSFORM_ROTATE: number;
14608     readonly SVG_TRANSFORM_SCALE: number;
14609     readonly SVG_TRANSFORM_SKEWX: number;
14610     readonly SVG_TRANSFORM_SKEWY: number;
14611     readonly SVG_TRANSFORM_TRANSLATE: number;
14612     readonly SVG_TRANSFORM_UNKNOWN: number;
14613 }
14614
14615 declare var SVGTransform: {
14616     prototype: SVGTransform;
14617     new(): SVGTransform;
14618     readonly SVG_TRANSFORM_MATRIX: number;
14619     readonly SVG_TRANSFORM_ROTATE: number;
14620     readonly SVG_TRANSFORM_SCALE: number;
14621     readonly SVG_TRANSFORM_SKEWX: number;
14622     readonly SVG_TRANSFORM_SKEWY: number;
14623     readonly SVG_TRANSFORM_TRANSLATE: number;
14624     readonly SVG_TRANSFORM_UNKNOWN: number;
14625 };
14626
14627 /** The SVGTransformList defines a list of SVGTransform objects. */
14628 interface SVGTransformList {
14629     readonly numberOfItems: number;
14630     appendItem(newItem: SVGTransform): SVGTransform;
14631     clear(): void;
14632     consolidate(): SVGTransform;
14633     createSVGTransformFromMatrix(matrix: SVGMatrix): SVGTransform;
14634     getItem(index: number): SVGTransform;
14635     initialize(newItem: SVGTransform): SVGTransform;
14636     insertItemBefore(newItem: SVGTransform, index: number): SVGTransform;
14637     removeItem(index: number): SVGTransform;
14638     replaceItem(newItem: SVGTransform, index: number): SVGTransform;
14639 }
14640
14641 declare var SVGTransformList: {
14642     prototype: SVGTransformList;
14643     new(): SVGTransformList;
14644 };
14645
14646 interface SVGURIReference {
14647     readonly href: SVGAnimatedString;
14648 }
14649
14650 /** A commonly used set of constants used for reflecting gradientUnits, patternContentUnits and other similar attributes. */
14651 interface SVGUnitTypes {
14652     readonly SVG_UNIT_TYPE_OBJECTBOUNDINGBOX: number;
14653     readonly SVG_UNIT_TYPE_UNKNOWN: number;
14654     readonly SVG_UNIT_TYPE_USERSPACEONUSE: number;
14655 }
14656
14657 declare var SVGUnitTypes: {
14658     prototype: SVGUnitTypes;
14659     new(): SVGUnitTypes;
14660     readonly SVG_UNIT_TYPE_OBJECTBOUNDINGBOX: number;
14661     readonly SVG_UNIT_TYPE_UNKNOWN: number;
14662     readonly SVG_UNIT_TYPE_USERSPACEONUSE: number;
14663 };
14664
14665 /** Corresponds to the <use> element. */
14666 interface SVGUseElement extends SVGGraphicsElement, SVGURIReference {
14667     readonly animatedInstanceRoot: SVGElementInstance | null;
14668     readonly height: SVGAnimatedLength;
14669     readonly instanceRoot: SVGElementInstance | null;
14670     readonly width: SVGAnimatedLength;
14671     readonly x: SVGAnimatedLength;
14672     readonly y: SVGAnimatedLength;
14673     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGUseElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14674     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14675     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGUseElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14676     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14677 }
14678
14679 declare var SVGUseElement: {
14680     prototype: SVGUseElement;
14681     new(): SVGUseElement;
14682 };
14683
14684 /** Provides access to the properties of <view> elements, as well as methods to manipulate them. */
14685 interface SVGViewElement extends SVGElement, SVGFitToViewBox, SVGZoomAndPan {
14686     /** @deprecated */
14687     readonly viewTarget: SVGStringList;
14688     addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGViewElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14689     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14690     removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGViewElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14691     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14692 }
14693
14694 declare var SVGViewElement: {
14695     prototype: SVGViewElement;
14696     new(): SVGViewElement;
14697     readonly SVG_ZOOMANDPAN_DISABLE: number;
14698     readonly SVG_ZOOMANDPAN_MAGNIFY: number;
14699     readonly SVG_ZOOMANDPAN_UNKNOWN: number;
14700 };
14701
14702 /** Used to reflect the zoomAndPan attribute, and is mixed in to other interfaces for elements that support this attribute. */
14703 interface SVGZoomAndPan {
14704     readonly zoomAndPan: number;
14705 }
14706
14707 declare var SVGZoomAndPan: {
14708     readonly SVG_ZOOMANDPAN_DISABLE: number;
14709     readonly SVG_ZOOMANDPAN_MAGNIFY: number;
14710     readonly SVG_ZOOMANDPAN_UNKNOWN: number;
14711 };
14712
14713 interface SVGZoomEvent extends UIEvent {
14714     readonly newScale: number;
14715     readonly newTranslate: SVGPoint;
14716     readonly previousScale: number;
14717     readonly previousTranslate: SVGPoint;
14718     readonly zoomRectScreen: SVGRect;
14719 }
14720
14721 declare var SVGZoomEvent: {
14722     prototype: SVGZoomEvent;
14723     new(): SVGZoomEvent;
14724 };
14725
14726 interface ScopedCredential {
14727     readonly id: ArrayBuffer;
14728     readonly type: ScopedCredentialType;
14729 }
14730
14731 declare var ScopedCredential: {
14732     prototype: ScopedCredential;
14733     new(): ScopedCredential;
14734 };
14735
14736 interface ScopedCredentialInfo {
14737     readonly credential: ScopedCredential;
14738     readonly publicKey: CryptoKey;
14739 }
14740
14741 declare var ScopedCredentialInfo: {
14742     prototype: ScopedCredentialInfo;
14743     new(): ScopedCredentialInfo;
14744 };
14745
14746 /** A screen, usually the one on which the current window is being rendered, and is obtained using window.screen. */
14747 interface Screen {
14748     readonly availHeight: number;
14749     readonly availWidth: number;
14750     readonly colorDepth: number;
14751     readonly height: number;
14752     readonly orientation: ScreenOrientation;
14753     readonly pixelDepth: number;
14754     readonly width: number;
14755 }
14756
14757 declare var Screen: {
14758     prototype: Screen;
14759     new(): Screen;
14760 };
14761
14762 interface ScreenOrientationEventMap {
14763     "change": Event;
14764 }
14765
14766 interface ScreenOrientation extends EventTarget {
14767     readonly angle: number;
14768     onchange: ((this: ScreenOrientation, ev: Event) => any) | null;
14769     readonly type: OrientationType;
14770     lock(orientation: OrientationLockType): Promise<void>;
14771     unlock(): void;
14772     addEventListener<K extends keyof ScreenOrientationEventMap>(type: K, listener: (this: ScreenOrientation, ev: ScreenOrientationEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14773     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14774     removeEventListener<K extends keyof ScreenOrientationEventMap>(type: K, listener: (this: ScreenOrientation, ev: ScreenOrientationEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14775     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14776 }
14777
14778 declare var ScreenOrientation: {
14779     prototype: ScreenOrientation;
14780     new(): ScreenOrientation;
14781 };
14782
14783 interface ScriptProcessorNodeEventMap {
14784     "audioprocess": AudioProcessingEvent;
14785 }
14786
14787 /** Allows the generation, processing, or analyzing of audio using JavaScript. */
14788 interface ScriptProcessorNode extends AudioNode {
14789     /** @deprecated */
14790     readonly bufferSize: number;
14791     /** @deprecated */
14792     onaudioprocess: ((this: ScriptProcessorNode, ev: AudioProcessingEvent) => any) | null;
14793     addEventListener<K extends keyof ScriptProcessorNodeEventMap>(type: K, listener: (this: ScriptProcessorNode, ev: ScriptProcessorNodeEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14794     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14795     removeEventListener<K extends keyof ScriptProcessorNodeEventMap>(type: K, listener: (this: ScriptProcessorNode, ev: ScriptProcessorNodeEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14796     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14797 }
14798
14799 declare var ScriptProcessorNode: {
14800     prototype: ScriptProcessorNode;
14801     new(): ScriptProcessorNode;
14802 };
14803
14804 /** Inherits from Event, and represents the event object of an event sent on a document or worker when its content security policy is violated. */
14805 interface SecurityPolicyViolationEvent extends Event {
14806     readonly blockedURI: string;
14807     readonly columnNumber: number;
14808     readonly documentURI: string;
14809     readonly effectiveDirective: string;
14810     readonly lineNumber: number;
14811     readonly originalPolicy: string;
14812     readonly referrer: string;
14813     readonly sourceFile: string;
14814     readonly statusCode: number;
14815     readonly violatedDirective: string;
14816 }
14817
14818 declare var SecurityPolicyViolationEvent: {
14819     prototype: SecurityPolicyViolationEvent;
14820     new(type: string, eventInitDict?: SecurityPolicyViolationEventInit): SecurityPolicyViolationEvent;
14821 };
14822
14823 /** 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(). */
14824 interface Selection {
14825     readonly anchorNode: Node | null;
14826     readonly anchorOffset: number;
14827     readonly focusNode: Node | null;
14828     readonly focusOffset: number;
14829     readonly isCollapsed: boolean;
14830     readonly rangeCount: number;
14831     readonly type: string;
14832     addRange(range: Range): void;
14833     collapse(node: Node | null, offset?: number): void;
14834     collapseToEnd(): void;
14835     collapseToStart(): void;
14836     containsNode(node: Node, allowPartialContainment?: boolean): boolean;
14837     deleteFromDocument(): void;
14838     empty(): void;
14839     extend(node: Node, offset?: number): void;
14840     getRangeAt(index: number): Range;
14841     removeAllRanges(): void;
14842     removeRange(range: Range): void;
14843     selectAllChildren(node: Node): void;
14844     setBaseAndExtent(anchorNode: Node, anchorOffset: number, focusNode: Node, focusOffset: number): void;
14845     setPosition(node: Node | null, offset?: number): void;
14846     toString(): string;
14847 }
14848
14849 declare var Selection: {
14850     prototype: Selection;
14851     new(): Selection;
14852     toString(): string;
14853 };
14854
14855 interface ServiceUIFrameContext {
14856     getCachedFrameMessage(key: string): string;
14857     postFrameMessage(key: string, data: string): void;
14858 }
14859 declare var ServiceUIFrameContext: ServiceUIFrameContext;
14860
14861 interface ServiceWorkerEventMap extends AbstractWorkerEventMap {
14862     "statechange": Event;
14863 }
14864
14865 /** 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. */
14866 interface ServiceWorker extends EventTarget, AbstractWorker {
14867     onstatechange: ((this: ServiceWorker, ev: Event) => any) | null;
14868     readonly scriptURL: string;
14869     readonly state: ServiceWorkerState;
14870     postMessage(message: any, transfer: Transferable[]): void;
14871     postMessage(message: any, options?: PostMessageOptions): void;
14872     addEventListener<K extends keyof ServiceWorkerEventMap>(type: K, listener: (this: ServiceWorker, ev: ServiceWorkerEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14873     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14874     removeEventListener<K extends keyof ServiceWorkerEventMap>(type: K, listener: (this: ServiceWorker, ev: ServiceWorkerEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14875     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14876 }
14877
14878 declare var ServiceWorker: {
14879     prototype: ServiceWorker;
14880     new(): ServiceWorker;
14881 };
14882
14883 interface ServiceWorkerContainerEventMap {
14884     "controllerchange": Event;
14885     "message": MessageEvent;
14886     "messageerror": MessageEvent;
14887 }
14888
14889 /** 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. */
14890 interface ServiceWorkerContainer extends EventTarget {
14891     readonly controller: ServiceWorker | null;
14892     oncontrollerchange: ((this: ServiceWorkerContainer, ev: Event) => any) | null;
14893     onmessage: ((this: ServiceWorkerContainer, ev: MessageEvent) => any) | null;
14894     onmessageerror: ((this: ServiceWorkerContainer, ev: MessageEvent) => any) | null;
14895     readonly ready: Promise<ServiceWorkerRegistration>;
14896     getRegistration(clientURL?: string): Promise<ServiceWorkerRegistration | undefined>;
14897     getRegistrations(): Promise<ReadonlyArray<ServiceWorkerRegistration>>;
14898     register(scriptURL: string, options?: RegistrationOptions): Promise<ServiceWorkerRegistration>;
14899     startMessages(): void;
14900     addEventListener<K extends keyof ServiceWorkerContainerEventMap>(type: K, listener: (this: ServiceWorkerContainer, ev: ServiceWorkerContainerEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14901     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14902     removeEventListener<K extends keyof ServiceWorkerContainerEventMap>(type: K, listener: (this: ServiceWorkerContainer, ev: ServiceWorkerContainerEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14903     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14904 }
14905
14906 declare var ServiceWorkerContainer: {
14907     prototype: ServiceWorkerContainer;
14908     new(): ServiceWorkerContainer;
14909 };
14910
14911 /** This ServiceWorker API interface contains information about an event sent to a ServiceWorkerContainer target. This extends the default message event to allow setting a ServiceWorker object as the source of a message. The event object is accessed via the handler function of a message event, when fired by a message received from a service worker. */
14912 interface ServiceWorkerMessageEvent extends Event {
14913     readonly data: any;
14914     readonly lastEventId: string;
14915     readonly origin: string;
14916     readonly ports: ReadonlyArray<MessagePort> | null;
14917     readonly source: ServiceWorker | MessagePort | null;
14918 }
14919
14920 declare var ServiceWorkerMessageEvent: {
14921     prototype: ServiceWorkerMessageEvent;
14922     new(type: string, eventInitDict?: ServiceWorkerMessageEventInit): ServiceWorkerMessageEvent;
14923 };
14924
14925 interface ServiceWorkerRegistrationEventMap {
14926     "updatefound": Event;
14927 }
14928
14929 /** 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. */
14930 interface ServiceWorkerRegistration extends EventTarget {
14931     readonly active: ServiceWorker | null;
14932     readonly installing: ServiceWorker | null;
14933     readonly navigationPreload: NavigationPreloadManager;
14934     onupdatefound: ((this: ServiceWorkerRegistration, ev: Event) => any) | null;
14935     readonly pushManager: PushManager;
14936     readonly scope: string;
14937     readonly sync: SyncManager;
14938     readonly updateViaCache: ServiceWorkerUpdateViaCache;
14939     readonly waiting: ServiceWorker | null;
14940     getNotifications(filter?: GetNotificationOptions): Promise<Notification[]>;
14941     showNotification(title: string, options?: NotificationOptions): Promise<void>;
14942     unregister(): Promise<boolean>;
14943     update(): Promise<void>;
14944     addEventListener<K extends keyof ServiceWorkerRegistrationEventMap>(type: K, listener: (this: ServiceWorkerRegistration, ev: ServiceWorkerRegistrationEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14945     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14946     removeEventListener<K extends keyof ServiceWorkerRegistrationEventMap>(type: K, listener: (this: ServiceWorkerRegistration, ev: ServiceWorkerRegistrationEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14947     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14948 }
14949
14950 declare var ServiceWorkerRegistration: {
14951     prototype: ServiceWorkerRegistration;
14952     new(): ServiceWorkerRegistration;
14953 };
14954
14955 interface ShadowRoot extends DocumentFragment, DocumentOrShadowRoot, InnerHTML {
14956     readonly host: Element;
14957     readonly mode: ShadowRootMode;
14958     /**
14959      * Throws a "NotSupportedError" DOMException if context object is a shadow root.
14960      */
14961 }
14962
14963 declare var ShadowRoot: {
14964     prototype: ShadowRoot;
14965     new(): ShadowRoot;
14966 };
14967
14968 interface SharedWorker extends EventTarget, AbstractWorker {
14969     /**
14970      * Returns sharedWorker's MessagePort object which can be used to communicate with the global environment.
14971      */
14972     readonly port: MessagePort;
14973     addEventListener<K extends keyof AbstractWorkerEventMap>(type: K, listener: (this: SharedWorker, ev: AbstractWorkerEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14974     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14975     removeEventListener<K extends keyof AbstractWorkerEventMap>(type: K, listener: (this: SharedWorker, ev: AbstractWorkerEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14976     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14977 }
14978
14979 declare var SharedWorker: {
14980     prototype: SharedWorker;
14981     new(scriptURL: string, options?: string | WorkerOptions): SharedWorker;
14982 };
14983
14984 interface Slotable {
14985     readonly assignedSlot: HTMLSlotElement | null;
14986 }
14987
14988 interface SourceBufferEventMap {
14989     "abort": Event;
14990     "error": Event;
14991     "update": Event;
14992     "updateend": Event;
14993     "updatestart": Event;
14994 }
14995
14996 /** 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. */
14997 interface SourceBuffer extends EventTarget {
14998     appendWindowEnd: number;
14999     appendWindowStart: number;
15000     readonly buffered: TimeRanges;
15001     mode: AppendMode;
15002     onabort: ((this: SourceBuffer, ev: Event) => any) | null;
15003     onerror: ((this: SourceBuffer, ev: Event) => any) | null;
15004     onupdate: ((this: SourceBuffer, ev: Event) => any) | null;
15005     onupdateend: ((this: SourceBuffer, ev: Event) => any) | null;
15006     onupdatestart: ((this: SourceBuffer, ev: Event) => any) | null;
15007     timestampOffset: number;
15008     readonly updating: boolean;
15009     abort(): void;
15010     appendBuffer(data: BufferSource): void;
15011     remove(start: number, end: number): void;
15012     addEventListener<K extends keyof SourceBufferEventMap>(type: K, listener: (this: SourceBuffer, ev: SourceBufferEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
15013     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
15014     removeEventListener<K extends keyof SourceBufferEventMap>(type: K, listener: (this: SourceBuffer, ev: SourceBufferEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
15015     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
15016 }
15017
15018 declare var SourceBuffer: {
15019     prototype: SourceBuffer;
15020     new(): SourceBuffer;
15021 };
15022
15023 interface SourceBufferListEventMap {
15024     "addsourcebuffer": Event;
15025     "removesourcebuffer": Event;
15026 }
15027
15028 /** A simple container list for multiple SourceBuffer objects. */
15029 interface SourceBufferList extends EventTarget {
15030     readonly length: number;
15031     onaddsourcebuffer: ((this: SourceBufferList, ev: Event) => any) | null;
15032     onremovesourcebuffer: ((this: SourceBufferList, ev: Event) => any) | null;
15033     addEventListener<K extends keyof SourceBufferListEventMap>(type: K, listener: (this: SourceBufferList, ev: SourceBufferListEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
15034     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
15035     removeEventListener<K extends keyof SourceBufferListEventMap>(type: K, listener: (this: SourceBufferList, ev: SourceBufferListEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
15036     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
15037     [index: number]: SourceBuffer;
15038 }
15039
15040 declare var SourceBufferList: {
15041     prototype: SourceBufferList;
15042     new(): SourceBufferList;
15043 };
15044
15045 interface SpeechGrammar {
15046     src: string;
15047     weight: number;
15048 }
15049
15050 declare var SpeechGrammar: {
15051     prototype: SpeechGrammar;
15052     new(): SpeechGrammar;
15053 };
15054
15055 interface SpeechGrammarList {
15056     readonly length: number;
15057     addFromString(string: string, weight?: number): void;
15058     addFromURI(src: string, weight?: number): void;
15059     item(index: number): SpeechGrammar;
15060     [index: number]: SpeechGrammar;
15061 }
15062
15063 declare var SpeechGrammarList: {
15064     prototype: SpeechGrammarList;
15065     new(): SpeechGrammarList;
15066 };
15067
15068 interface SpeechRecognitionEventMap {
15069     "audioend": Event;
15070     "audiostart": Event;
15071     "end": Event;
15072     "error": Event;
15073     "nomatch": SpeechRecognitionEvent;
15074     "result": SpeechRecognitionEvent;
15075     "soundend": Event;
15076     "soundstart": Event;
15077     "speechend": Event;
15078     "speechstart": Event;
15079     "start": Event;
15080 }
15081
15082 interface SpeechRecognition extends EventTarget {
15083     continuous: boolean;
15084     grammars: SpeechGrammarList;
15085     interimResults: boolean;
15086     lang: string;
15087     maxAlternatives: number;
15088     onaudioend: ((this: SpeechRecognition, ev: Event) => any) | null;
15089     onaudiostart: ((this: SpeechRecognition, ev: Event) => any) | null;
15090     onend: ((this: SpeechRecognition, ev: Event) => any) | null;
15091     onerror: ((this: SpeechRecognition, ev: Event) => any) | null;
15092     onnomatch: ((this: SpeechRecognition, ev: SpeechRecognitionEvent) => any) | null;
15093     onresult: ((this: SpeechRecognition, ev: SpeechRecognitionEvent) => any) | null;
15094     onsoundend: ((this: SpeechRecognition, ev: Event) => any) | null;
15095     onsoundstart: ((this: SpeechRecognition, ev: Event) => any) | null;
15096     onspeechend: ((this: SpeechRecognition, ev: Event) => any) | null;
15097     onspeechstart: ((this: SpeechRecognition, ev: Event) => any) | null;
15098     onstart: ((this: SpeechRecognition, ev: Event) => any) | null;
15099     abort(): void;
15100     start(): void;
15101     stop(): void;
15102     addEventListener<K extends keyof SpeechRecognitionEventMap>(type: K, listener: (this: SpeechRecognition, ev: SpeechRecognitionEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
15103     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
15104     removeEventListener<K extends keyof SpeechRecognitionEventMap>(type: K, listener: (this: SpeechRecognition, ev: SpeechRecognitionEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
15105     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
15106 }
15107
15108 declare var SpeechRecognition: {
15109     prototype: SpeechRecognition;
15110     new(): SpeechRecognition;
15111 };
15112
15113 interface SpeechRecognitionAlternative {
15114     readonly confidence: number;
15115     readonly transcript: string;
15116 }
15117
15118 declare var SpeechRecognitionAlternative: {
15119     prototype: SpeechRecognitionAlternative;
15120     new(): SpeechRecognitionAlternative;
15121 };
15122
15123 interface SpeechRecognitionEvent extends Event {
15124     readonly resultIndex: number;
15125     readonly results: SpeechRecognitionResultList;
15126 }
15127
15128 declare var SpeechRecognitionEvent: {
15129     prototype: SpeechRecognitionEvent;
15130     new(): SpeechRecognitionEvent;
15131 };
15132
15133 interface SpeechRecognitionResult {
15134     readonly isFinal: boolean;
15135     readonly length: number;
15136     item(index: number): SpeechRecognitionAlternative;
15137     [index: number]: SpeechRecognitionAlternative;
15138 }
15139
15140 declare var SpeechRecognitionResult: {
15141     prototype: SpeechRecognitionResult;
15142     new(): SpeechRecognitionResult;
15143 };
15144
15145 interface SpeechRecognitionResultList {
15146     readonly length: number;
15147     item(index: number): SpeechRecognitionResult;
15148     [index: number]: SpeechRecognitionResult;
15149 }
15150
15151 declare var SpeechRecognitionResultList: {
15152     prototype: SpeechRecognitionResultList;
15153     new(): SpeechRecognitionResultList;
15154 };
15155
15156 interface SpeechSynthesisEventMap {
15157     "voiceschanged": Event;
15158 }
15159
15160 /** 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. */
15161 interface SpeechSynthesis extends EventTarget {
15162     onvoiceschanged: ((this: SpeechSynthesis, ev: Event) => any) | null;
15163     readonly paused: boolean;
15164     readonly pending: boolean;
15165     readonly speaking: boolean;
15166     cancel(): void;
15167     getVoices(): SpeechSynthesisVoice[];
15168     pause(): void;
15169     resume(): void;
15170     speak(utterance: SpeechSynthesisUtterance): void;
15171     addEventListener<K extends keyof SpeechSynthesisEventMap>(type: K, listener: (this: SpeechSynthesis, ev: SpeechSynthesisEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
15172     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
15173     removeEventListener<K extends keyof SpeechSynthesisEventMap>(type: K, listener: (this: SpeechSynthesis, ev: SpeechSynthesisEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
15174     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
15175 }
15176
15177 declare var SpeechSynthesis: {
15178     prototype: SpeechSynthesis;
15179     new(): SpeechSynthesis;
15180 };
15181
15182 interface SpeechSynthesisErrorEvent extends SpeechSynthesisEvent {
15183     readonly error: SpeechSynthesisErrorCode;
15184 }
15185
15186 declare var SpeechSynthesisErrorEvent: {
15187     prototype: SpeechSynthesisErrorEvent;
15188     new(type: string, eventInitDict: SpeechSynthesisErrorEventInit): SpeechSynthesisErrorEvent;
15189 };
15190
15191 /** This Web Speech API interface contains information about the current state of SpeechSynthesisUtterance objects that have been processed in the speech service. */
15192 interface SpeechSynthesisEvent extends Event {
15193     readonly charIndex: number;
15194     readonly charLength: number;
15195     readonly elapsedTime: number;
15196     readonly name: string;
15197     readonly utterance: SpeechSynthesisUtterance;
15198 }
15199
15200 declare var SpeechSynthesisEvent: {
15201     prototype: SpeechSynthesisEvent;
15202     new(type: string, eventInitDict: SpeechSynthesisEventInit): SpeechSynthesisEvent;
15203 };
15204
15205 interface SpeechSynthesisUtteranceEventMap {
15206     "boundary": SpeechSynthesisEvent;
15207     "end": SpeechSynthesisEvent;
15208     "error": SpeechSynthesisErrorEvent;
15209     "mark": SpeechSynthesisEvent;
15210     "pause": SpeechSynthesisEvent;
15211     "resume": SpeechSynthesisEvent;
15212     "start": SpeechSynthesisEvent;
15213 }
15214
15215 /** 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.) */
15216 interface SpeechSynthesisUtterance extends EventTarget {
15217     lang: string;
15218     onboundary: ((this: SpeechSynthesisUtterance, ev: SpeechSynthesisEvent) => any) | null;
15219     onend: ((this: SpeechSynthesisUtterance, ev: SpeechSynthesisEvent) => any) | null;
15220     onerror: ((this: SpeechSynthesisUtterance, ev: SpeechSynthesisErrorEvent) => any) | null;
15221     onmark: ((this: SpeechSynthesisUtterance, ev: SpeechSynthesisEvent) => any) | null;
15222     onpause: ((this: SpeechSynthesisUtterance, ev: SpeechSynthesisEvent) => any) | null;
15223     onresume: ((this: SpeechSynthesisUtterance, ev: SpeechSynthesisEvent) => any) | null;
15224     onstart: ((this: SpeechSynthesisUtterance, ev: SpeechSynthesisEvent) => any) | null;
15225     pitch: number;
15226     rate: number;
15227     text: string;
15228     voice: SpeechSynthesisVoice | null;
15229     volume: number;
15230     addEventListener<K extends keyof SpeechSynthesisUtteranceEventMap>(type: K, listener: (this: SpeechSynthesisUtterance, ev: SpeechSynthesisUtteranceEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
15231     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
15232     removeEventListener<K extends keyof SpeechSynthesisUtteranceEventMap>(type: K, listener: (this: SpeechSynthesisUtterance, ev: SpeechSynthesisUtteranceEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
15233     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
15234 }
15235
15236 declare var SpeechSynthesisUtterance: {
15237     prototype: SpeechSynthesisUtterance;
15238     new(text?: string): SpeechSynthesisUtterance;
15239 };
15240
15241 /** 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. */
15242 interface SpeechSynthesisVoice {
15243     readonly default: boolean;
15244     readonly lang: string;
15245     readonly localService: boolean;
15246     readonly name: string;
15247     readonly voiceURI: string;
15248 }
15249
15250 declare var SpeechSynthesisVoice: {
15251     prototype: SpeechSynthesisVoice;
15252     new(): SpeechSynthesisVoice;
15253 };
15254
15255 interface StaticRange extends AbstractRange {
15256 }
15257
15258 declare var StaticRange: {
15259     prototype: StaticRange;
15260     new(init: StaticRangeInit): StaticRange;
15261 };
15262
15263 /** 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. */
15264 interface StereoPannerNode extends AudioNode {
15265     readonly pan: AudioParam;
15266 }
15267
15268 declare var StereoPannerNode: {
15269     prototype: StereoPannerNode;
15270     new(context: BaseAudioContext, options?: StereoPannerOptions): StereoPannerNode;
15271 };
15272
15273 /** 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. */
15274 interface Storage {
15275     /**
15276      * Returns the number of key/value pairs currently present in the list associated with the object.
15277      */
15278     readonly length: number;
15279     /**
15280      * Empties the list associated with the object of all key/value pairs, if there are any.
15281      */
15282     clear(): void;
15283     /**
15284      * Returns the current value associated with the given key, or null if the given key does not exist in the list associated with the object.
15285      */
15286     getItem(key: string): string | null;
15287     /**
15288      * Returns the name of the nth key in the list, or null if n is greater than or equal to the number of key/value pairs in the object.
15289      */
15290     key(index: number): string | null;
15291     /**
15292      * Removes the key/value pair with the given key from the list associated with the object, if a key/value pair with the given key exists.
15293      */
15294     removeItem(key: string): void;
15295     /**
15296      * Sets the value of the pair identified by key to value, creating a new key/value pair if none existed for key previously.
15297      *
15298      * 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.)
15299      */
15300     setItem(key: string, value: string): void;
15301     [name: string]: any;
15302 }
15303
15304 declare var Storage: {
15305     prototype: Storage;
15306     new(): Storage;
15307 };
15308
15309 /** A StorageEvent is sent to a window when a storage area it has access to is changed within the context of another document. */
15310 interface StorageEvent extends Event {
15311     /**
15312      * Returns the key of the storage item being changed.
15313      */
15314     readonly key: string | null;
15315     /**
15316      * Returns the new value of the key of the storage item whose value is being changed.
15317      */
15318     readonly newValue: string | null;
15319     /**
15320      * Returns the old value of the key of the storage item whose value is being changed.
15321      */
15322     readonly oldValue: string | null;
15323     /**
15324      * Returns the Storage object that was affected.
15325      */
15326     readonly storageArea: Storage | null;
15327     /**
15328      * Returns the URL of the document whose storage item changed.
15329      */
15330     readonly url: string;
15331 }
15332
15333 declare var StorageEvent: {
15334     prototype: StorageEvent;
15335     new(type: string, eventInitDict?: StorageEventInit): StorageEvent;
15336 };
15337
15338 interface StorageManager {
15339     estimate(): Promise<StorageEstimate>;
15340     persist(): Promise<boolean>;
15341     persisted(): Promise<boolean>;
15342 }
15343
15344 declare var StorageManager: {
15345     prototype: StorageManager;
15346     new(): StorageManager;
15347 };
15348
15349 interface StyleMedia {
15350     readonly type: string;
15351     matchMedium(mediaquery: string): boolean;
15352 }
15353
15354 declare var StyleMedia: {
15355     prototype: StyleMedia;
15356     new(): StyleMedia;
15357 };
15358
15359 /** A single style sheet. CSS style sheets will further implement the more specialized CSSStyleSheet interface. */
15360 interface StyleSheet {
15361     disabled: boolean;
15362     readonly href: string | null;
15363     readonly media: MediaList;
15364     readonly ownerNode: Element | ProcessingInstruction | null;
15365     readonly parentStyleSheet: CSSStyleSheet | null;
15366     readonly title: string | null;
15367     readonly type: string;
15368 }
15369
15370 declare var StyleSheet: {
15371     prototype: StyleSheet;
15372     new(): StyleSheet;
15373 };
15374
15375 /** A list of StyleSheet. */
15376 interface StyleSheetList {
15377     readonly length: number;
15378     item(index: number): CSSStyleSheet | null;
15379     [index: number]: CSSStyleSheet;
15380 }
15381
15382 declare var StyleSheetList: {
15383     prototype: StyleSheetList;
15384     new(): StyleSheetList;
15385 };
15386
15387 /** 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). */
15388 interface SubtleCrypto {
15389     decrypt(algorithm: AlgorithmIdentifier | RsaOaepParams | AesCtrParams | AesCbcParams | AesCmacParams | AesGcmParams | AesCfbParams, key: CryptoKey, data: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer): PromiseLike<ArrayBuffer>;
15390     deriveBits(algorithm: AlgorithmIdentifier | EcdhKeyDeriveParams | DhKeyDeriveParams | ConcatParams | HkdfCtrParams | Pbkdf2Params, baseKey: CryptoKey, length: number): PromiseLike<ArrayBuffer>;
15391     deriveKey(algorithm: AlgorithmIdentifier | EcdhKeyDeriveParams | DhKeyDeriveParams | ConcatParams | HkdfCtrParams | Pbkdf2Params, baseKey: CryptoKey, derivedKeyType: string | AesDerivedKeyParams | HmacImportParams | ConcatParams | HkdfCtrParams | Pbkdf2Params, extractable: boolean, keyUsages: KeyUsage[]): PromiseLike<CryptoKey>;
15392     digest(algorithm: AlgorithmIdentifier, data: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer): PromiseLike<ArrayBuffer>;
15393     encrypt(algorithm: AlgorithmIdentifier | RsaOaepParams | AesCtrParams | AesCbcParams | AesCmacParams | AesGcmParams | AesCfbParams, key: CryptoKey, data: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer): PromiseLike<ArrayBuffer>;
15394     exportKey(format: "jwk", key: CryptoKey): PromiseLike<JsonWebKey>;
15395     exportKey(format: "raw" | "pkcs8" | "spki", key: CryptoKey): PromiseLike<ArrayBuffer>;
15396     exportKey(format: string, key: CryptoKey): PromiseLike<JsonWebKey | ArrayBuffer>;
15397     generateKey(algorithm: AlgorithmIdentifier, extractable: boolean, keyUsages: KeyUsage[]): PromiseLike<CryptoKeyPair | CryptoKey>;
15398     generateKey(algorithm: RsaHashedKeyGenParams | EcKeyGenParams | DhKeyGenParams, extractable: boolean, keyUsages: KeyUsage[]): PromiseLike<CryptoKeyPair>;
15399     generateKey(algorithm: AesKeyGenParams | HmacKeyGenParams | Pbkdf2Params, extractable: boolean, keyUsages: KeyUsage[]): PromiseLike<CryptoKey>;
15400     importKey(format: "jwk", keyData: JsonWebKey, algorithm: AlgorithmIdentifier | RsaHashedImportParams | EcKeyImportParams | HmacImportParams | DhImportKeyParams | AesKeyAlgorithm, extractable: boolean, keyUsages: KeyUsage[]): PromiseLike<CryptoKey>;
15401     importKey(format: "raw" | "pkcs8" | "spki", keyData: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer, algorithm: AlgorithmIdentifier | RsaHashedImportParams | EcKeyImportParams | HmacImportParams | DhImportKeyParams | AesKeyAlgorithm, extractable: boolean, keyUsages: KeyUsage[]): PromiseLike<CryptoKey>;
15402     importKey(format: string, keyData: JsonWebKey | Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer, algorithm: AlgorithmIdentifier | RsaHashedImportParams | EcKeyImportParams | HmacImportParams | DhImportKeyParams | AesKeyAlgorithm, extractable: boolean, keyUsages: KeyUsage[]): PromiseLike<CryptoKey>;
15403     sign(algorithm: AlgorithmIdentifier | RsaPssParams | EcdsaParams | AesCmacParams, key: CryptoKey, data: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer): PromiseLike<ArrayBuffer>;
15404     unwrapKey(format: "raw" | "pkcs8" | "spki" | "jwk" | string, wrappedKey: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer, unwrappingKey: CryptoKey, unwrapAlgorithm: AlgorithmIdentifier | RsaOaepParams | AesCtrParams | AesCbcParams | AesCmacParams | AesGcmParams | AesCfbParams, unwrappedKeyAlgorithm: AlgorithmIdentifier | RsaHashedImportParams | EcKeyImportParams | HmacImportParams | DhImportKeyParams | AesKeyAlgorithm, extractable: boolean, keyUsages: KeyUsage[]): PromiseLike<CryptoKey>;
15405     verify(algorithm: AlgorithmIdentifier | RsaPssParams | EcdsaParams | AesCmacParams, key: CryptoKey, signature: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer, data: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer): PromiseLike<boolean>;
15406     wrapKey(format: "raw" | "pkcs8" | "spki" | "jwk" | string, key: CryptoKey, wrappingKey: CryptoKey, wrapAlgorithm: AlgorithmIdentifier | RsaOaepParams | AesCtrParams | AesCbcParams | AesCmacParams | AesGcmParams | AesCfbParams): PromiseLike<ArrayBuffer>;
15407 }
15408
15409 declare var SubtleCrypto: {
15410     prototype: SubtleCrypto;
15411     new(): SubtleCrypto;
15412 };
15413
15414 /** This ServiceWorker API interface provides an interface for registering and listing sync registrations. */
15415 interface SyncManager {
15416     getTags(): Promise<string[]>;
15417     register(tag: string): Promise<void>;
15418 }
15419
15420 declare var SyncManager: {
15421     prototype: SyncManager;
15422     new(): SyncManager;
15423 };
15424
15425 /** 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. */
15426 interface Text extends CharacterData, Slotable {
15427     readonly assignedSlot: HTMLSlotElement | null;
15428     /**
15429      * Returns the combined data of all direct Text node siblings.
15430      */
15431     readonly wholeText: string;
15432     /**
15433      * Splits data at the given offset and returns the remainder as Text node.
15434      */
15435     splitText(offset: number): Text;
15436 }
15437
15438 declare var Text: {
15439     prototype: Text;
15440     new(data?: string): Text;
15441 };
15442
15443 /** 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. */
15444 interface TextDecoder extends TextDecoderCommon {
15445     /**
15446      * 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 stream. If the invocation without options's stream (or set to false) has no input, it's clearest to omit both arguments.
15447      *
15448      * ```
15449      * var string = "", decoder = new TextDecoder(encoding), buffer;
15450      * while(buffer = next_chunk()) {
15451      *   string += decoder.decode(buffer, {stream:true});
15452      * }
15453      * string += decoder.decode(); // end-of-stream
15454      * ```
15455      *
15456      * If the error mode is "fatal" and encoding's decoder returns error, throws a TypeError.
15457      */
15458     decode(input?: BufferSource, options?: TextDecodeOptions): string;
15459 }
15460
15461 declare var TextDecoder: {
15462     prototype: TextDecoder;
15463     new(label?: string, options?: TextDecoderOptions): TextDecoder;
15464 };
15465
15466 interface TextDecoderCommon {
15467     /**
15468      * Returns encoding's name, lowercased.
15469      */
15470     readonly encoding: string;
15471     /**
15472      * Returns true if error mode is "fatal", and false otherwise.
15473      */
15474     readonly fatal: boolean;
15475     /**
15476      * Returns true if ignore BOM flag is set, and false otherwise.
15477      */
15478     readonly ignoreBOM: boolean;
15479 }
15480
15481 interface TextDecoderStream extends GenericTransformStream, TextDecoderCommon {
15482     readonly readable: ReadableStream<string>;
15483     readonly writable: WritableStream<BufferSource>;
15484 }
15485
15486 declare var TextDecoderStream: {
15487     prototype: TextDecoderStream;
15488     new(label?: string, options?: TextDecoderOptions): TextDecoderStream;
15489 };
15490
15491 /** 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. */
15492 interface TextEncoder extends TextEncoderCommon {
15493     /**
15494      * Returns the result of running UTF-8's encoder.
15495      */
15496     encode(input?: string): Uint8Array;
15497     /**
15498      * Runs the UTF-8 encoder on source, stores the result of that operation into destination, and returns the progress made as a dictionary whereby read is the number of converted code units of source and written is the number of bytes modified in destination.
15499      */
15500     encodeInto(source: string, destination: Uint8Array): TextEncoderEncodeIntoResult;
15501 }
15502
15503 declare var TextEncoder: {
15504     prototype: TextEncoder;
15505     new(): TextEncoder;
15506 };
15507
15508 interface TextEncoderCommon {
15509     /**
15510      * Returns "utf-8".
15511      */
15512     readonly encoding: string;
15513 }
15514
15515 interface TextEncoderStream extends GenericTransformStream, TextEncoderCommon {
15516     readonly readable: ReadableStream<Uint8Array>;
15517     readonly writable: WritableStream<string>;
15518 }
15519
15520 declare var TextEncoderStream: {
15521     prototype: TextEncoderStream;
15522     new(): TextEncoderStream;
15523 };
15524
15525 interface TextEvent extends UIEvent {
15526     readonly data: string;
15527     initTextEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, viewArg: Window, dataArg: string, inputMethod: number, locale: string): void;
15528     readonly DOM_INPUT_METHOD_DROP: number;
15529     readonly DOM_INPUT_METHOD_HANDWRITING: number;
15530     readonly DOM_INPUT_METHOD_IME: number;
15531     readonly DOM_INPUT_METHOD_KEYBOARD: number;
15532     readonly DOM_INPUT_METHOD_MULTIMODAL: number;
15533     readonly DOM_INPUT_METHOD_OPTION: number;
15534     readonly DOM_INPUT_METHOD_PASTE: number;
15535     readonly DOM_INPUT_METHOD_SCRIPT: number;
15536     readonly DOM_INPUT_METHOD_UNKNOWN: number;
15537     readonly DOM_INPUT_METHOD_VOICE: number;
15538 }
15539
15540 declare var TextEvent: {
15541     prototype: TextEvent;
15542     new(): TextEvent;
15543     readonly DOM_INPUT_METHOD_DROP: number;
15544     readonly DOM_INPUT_METHOD_HANDWRITING: number;
15545     readonly DOM_INPUT_METHOD_IME: number;
15546     readonly DOM_INPUT_METHOD_KEYBOARD: number;
15547     readonly DOM_INPUT_METHOD_MULTIMODAL: number;
15548     readonly DOM_INPUT_METHOD_OPTION: number;
15549     readonly DOM_INPUT_METHOD_PASTE: number;
15550     readonly DOM_INPUT_METHOD_SCRIPT: number;
15551     readonly DOM_INPUT_METHOD_UNKNOWN: number;
15552     readonly DOM_INPUT_METHOD_VOICE: number;
15553 };
15554
15555 /** The dimensions of a piece of text in the canvas, as created by the CanvasRenderingContext2D.measureText() method. */
15556 interface TextMetrics {
15557     /**
15558      * Returns the measurement described below.
15559      */
15560     readonly actualBoundingBoxAscent: number;
15561     /**
15562      * Returns the measurement described below.
15563      */
15564     readonly actualBoundingBoxDescent: number;
15565     /**
15566      * Returns the measurement described below.
15567      */
15568     readonly actualBoundingBoxLeft: number;
15569     /**
15570      * Returns the measurement described below.
15571      */
15572     readonly actualBoundingBoxRight: number;
15573     /**
15574      * Returns the measurement described below.
15575      */
15576     readonly alphabeticBaseline: number;
15577     /**
15578      * Returns the measurement described below.
15579      */
15580     readonly emHeightAscent: number;
15581     /**
15582      * Returns the measurement described below.
15583      */
15584     readonly emHeightDescent: number;
15585     /**
15586      * Returns the measurement described below.
15587      */
15588     readonly fontBoundingBoxAscent: number;
15589     /**
15590      * Returns the measurement described below.
15591      */
15592     readonly fontBoundingBoxDescent: number;
15593     /**
15594      * Returns the measurement described below.
15595      */
15596     readonly hangingBaseline: number;
15597     /**
15598      * Returns the measurement described below.
15599      */
15600     readonly ideographicBaseline: number;
15601     /**
15602      * Returns the measurement described below.
15603      */
15604     readonly width: number;
15605 }
15606
15607 declare var TextMetrics: {
15608     prototype: TextMetrics;
15609     new(): TextMetrics;
15610 };
15611
15612 interface TextTrackEventMap {
15613     "cuechange": Event;
15614 }
15615
15616 /** This interface also inherits properties from EventTarget. */
15617 interface TextTrack extends EventTarget {
15618     /**
15619      * 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.
15620      */
15621     readonly activeCues: TextTrackCueList | null;
15622     /**
15623      * Returns the text track list of cues, as a TextTrackCueList object.
15624      */
15625     readonly cues: TextTrackCueList | null;
15626     /**
15627      * Returns the ID of the given track.
15628      *
15629      * 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.
15630      *
15631      * For TextTrack objects corresponding to track elements, this is the ID of the track element.
15632      */
15633     readonly id: string;
15634     /**
15635      * Returns the text track in-band metadata track dispatch type string.
15636      */
15637     readonly inBandMetadataTrackDispatchType: string;
15638     /**
15639      * Returns the text track kind string.
15640      */
15641     readonly kind: TextTrackKind;
15642     /**
15643      * 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).
15644      */
15645     readonly label: string;
15646     /**
15647      * Returns the text track language string.
15648      */
15649     readonly language: string;
15650     /**
15651      * Returns the text track mode, represented by a string from the following list:
15652      *
15653      * Can be set, to change the mode.
15654      */
15655     mode: TextTrackMode;
15656     oncuechange: ((this: TextTrack, ev: Event) => any) | null;
15657     readonly sourceBuffer: SourceBuffer | null;
15658     /**
15659      * Adds the given cue to textTrack's text track list of cues.
15660      */
15661     addCue(cue: TextTrackCue): void;
15662     /**
15663      * Removes the given cue from textTrack's text track list of cues.
15664      */
15665     removeCue(cue: TextTrackCue): void;
15666     addEventListener<K extends keyof TextTrackEventMap>(type: K, listener: (this: TextTrack, ev: TextTrackEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
15667     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
15668     removeEventListener<K extends keyof TextTrackEventMap>(type: K, listener: (this: TextTrack, ev: TextTrackEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
15669     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
15670 }
15671
15672 declare var TextTrack: {
15673     prototype: TextTrack;
15674     new(): TextTrack;
15675 };
15676
15677 interface TextTrackCueEventMap {
15678     "enter": Event;
15679     "exit": Event;
15680 }
15681
15682 /** 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. */
15683 interface TextTrackCue extends EventTarget {
15684     /**
15685      * Returns the text track cue end time, in seconds.
15686      *
15687      * Can be set.
15688      */
15689     endTime: number;
15690     /**
15691      * Returns the text track cue identifier.
15692      *
15693      * Can be set.
15694      */
15695     id: string;
15696     onenter: ((this: TextTrackCue, ev: Event) => any) | null;
15697     onexit: ((this: TextTrackCue, ev: Event) => any) | null;
15698     /**
15699      * Returns true if the text track cue pause-on-exit flag is set, false otherwise.
15700      *
15701      * Can be set.
15702      */
15703     pauseOnExit: boolean;
15704     /**
15705      * Returns the text track cue start time, in seconds.
15706      *
15707      * Can be set.
15708      */
15709     startTime: number;
15710     /**
15711      * Returns the TextTrack object to which this text track cue belongs, if any, or null otherwise.
15712      */
15713     readonly track: TextTrack | null;
15714     addEventListener<K extends keyof TextTrackCueEventMap>(type: K, listener: (this: TextTrackCue, ev: TextTrackCueEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
15715     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
15716     removeEventListener<K extends keyof TextTrackCueEventMap>(type: K, listener: (this: TextTrackCue, ev: TextTrackCueEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
15717     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
15718 }
15719
15720 declare var TextTrackCue: {
15721     prototype: TextTrackCue;
15722     new(): TextTrackCue;
15723 };
15724
15725 interface TextTrackCueList {
15726     /**
15727      * Returns the number of cues in the list.
15728      */
15729     readonly length: number;
15730     /**
15731      * Returns the first text track cue (in text track cue order) with text track cue identifier id.
15732      *
15733      * Returns null if none of the cues have the given identifier or if the argument is the empty string.
15734      */
15735     getCueById(id: string): TextTrackCue | null;
15736     [index: number]: TextTrackCue;
15737 }
15738
15739 declare var TextTrackCueList: {
15740     prototype: TextTrackCueList;
15741     new(): TextTrackCueList;
15742 };
15743
15744 interface TextTrackListEventMap {
15745     "addtrack": TrackEvent;
15746     "change": Event;
15747     "removetrack": TrackEvent;
15748 }
15749
15750 interface TextTrackList extends EventTarget {
15751     readonly length: number;
15752     onaddtrack: ((this: TextTrackList, ev: TrackEvent) => any) | null;
15753     onchange: ((this: TextTrackList, ev: Event) => any) | null;
15754     onremovetrack: ((this: TextTrackList, ev: TrackEvent) => any) | null;
15755     getTrackById(id: string): TextTrack | null;
15756     addEventListener<K extends keyof TextTrackListEventMap>(type: K, listener: (this: TextTrackList, ev: TextTrackListEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
15757     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
15758     removeEventListener<K extends keyof TextTrackListEventMap>(type: K, listener: (this: TextTrackList, ev: TextTrackListEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
15759     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
15760     [index: number]: TextTrack;
15761 }
15762
15763 declare var TextTrackList: {
15764     prototype: TextTrackList;
15765     new(): TextTrackList;
15766 };
15767
15768 /** 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. */
15769 interface TimeRanges {
15770     /**
15771      * Returns the number of ranges in the object.
15772      */
15773     readonly length: number;
15774     /**
15775      * Returns the time for the end of the range with the given index.
15776      *
15777      * Throws an "IndexSizeError" DOMException if the index is out of range.
15778      */
15779     end(index: number): number;
15780     /**
15781      * Returns the time for the start of the range with the given index.
15782      *
15783      * Throws an "IndexSizeError" DOMException if the index is out of range.
15784      */
15785     start(index: number): number;
15786 }
15787
15788 declare var TimeRanges: {
15789     prototype: TimeRanges;
15790     new(): TimeRanges;
15791 };
15792
15793 /** 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. */
15794 interface Touch {
15795     readonly altitudeAngle: number;
15796     readonly azimuthAngle: number;
15797     readonly clientX: number;
15798     readonly clientY: number;
15799     readonly force: number;
15800     readonly identifier: number;
15801     readonly pageX: number;
15802     readonly pageY: number;
15803     readonly radiusX: number;
15804     readonly radiusY: number;
15805     readonly rotationAngle: number;
15806     readonly screenX: number;
15807     readonly screenY: number;
15808     readonly target: EventTarget;
15809     readonly touchType: TouchType;
15810 }
15811
15812 declare var Touch: {
15813     prototype: Touch;
15814     new(touchInitDict: TouchInit): Touch;
15815 };
15816
15817 /** 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. */
15818 interface TouchEvent extends UIEvent {
15819     readonly altKey: boolean;
15820     readonly changedTouches: TouchList;
15821     readonly ctrlKey: boolean;
15822     readonly metaKey: boolean;
15823     readonly shiftKey: boolean;
15824     readonly targetTouches: TouchList;
15825     readonly touches: TouchList;
15826 }
15827
15828 declare var TouchEvent: {
15829     prototype: TouchEvent;
15830     new(type: string, eventInitDict?: TouchEventInit): TouchEvent;
15831 };
15832
15833 /** 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. */
15834 interface TouchList {
15835     readonly length: number;
15836     item(index: number): Touch | null;
15837     [index: number]: Touch;
15838 }
15839
15840 declare var TouchList: {
15841     prototype: TouchList;
15842     new(): TouchList;
15843 };
15844
15845 /** 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. */
15846 interface TrackEvent extends Event {
15847     /**
15848      * Returns the track object (TextTrack, AudioTrack, or VideoTrack) to which the event relates.
15849      */
15850     readonly track: TextTrack | null;
15851 }
15852
15853 declare var TrackEvent: {
15854     prototype: TrackEvent;
15855     new(type: string, eventInitDict?: TrackEventInit): TrackEvent;
15856 };
15857
15858 interface TransformStream<I = any, O = any> {
15859     readonly readable: ReadableStream<O>;
15860     readonly writable: WritableStream<I>;
15861 }
15862
15863 declare var TransformStream: {
15864     prototype: TransformStream;
15865     new<I = any, O = any>(transformer?: Transformer<I, O>, writableStrategy?: QueuingStrategy<I>, readableStrategy?: QueuingStrategy<O>): TransformStream<I, O>;
15866 };
15867
15868 interface TransformStreamDefaultController<O = any> {
15869     readonly desiredSize: number | null;
15870     enqueue(chunk: O): void;
15871     error(reason?: any): void;
15872     terminate(): void;
15873 }
15874
15875 /** Events providing information related to transitions. */
15876 interface TransitionEvent extends Event {
15877     readonly elapsedTime: number;
15878     readonly propertyName: string;
15879     readonly pseudoElement: string;
15880 }
15881
15882 declare var TransitionEvent: {
15883     prototype: TransitionEvent;
15884     new(type: string, transitionEventInitDict?: TransitionEventInit): TransitionEvent;
15885 };
15886
15887 /** The nodes of a document subtree and a position within them. */
15888 interface TreeWalker {
15889     currentNode: Node;
15890     readonly filter: NodeFilter | null;
15891     readonly root: Node;
15892     readonly whatToShow: number;
15893     firstChild(): Node | null;
15894     lastChild(): Node | null;
15895     nextNode(): Node | null;
15896     nextSibling(): Node | null;
15897     parentNode(): Node | null;
15898     previousNode(): Node | null;
15899     previousSibling(): Node | null;
15900 }
15901
15902 declare var TreeWalker: {
15903     prototype: TreeWalker;
15904     new(): TreeWalker;
15905 };
15906
15907 /** Simple user interface events. */
15908 interface UIEvent extends Event {
15909     readonly detail: number;
15910     readonly view: Window | null;
15911     /** @deprecated */
15912     readonly which: number;
15913 }
15914
15915 declare var UIEvent: {
15916     prototype: UIEvent;
15917     new(type: string, eventInitDict?: UIEventInit): UIEvent;
15918 };
15919
15920 /** The URL interface represents an object providing static methods used for creating object URLs. */
15921 interface URL {
15922     hash: string;
15923     host: string;
15924     hostname: string;
15925     href: string;
15926     toString(): string;
15927     readonly origin: string;
15928     password: string;
15929     pathname: string;
15930     port: string;
15931     protocol: string;
15932     search: string;
15933     readonly searchParams: URLSearchParams;
15934     username: string;
15935     toJSON(): string;
15936 }
15937
15938 declare var URL: {
15939     prototype: URL;
15940     new(url: string, base?: string | URL): URL;
15941     createObjectURL(object: any): string;
15942     revokeObjectURL(url: string): void;
15943 };
15944
15945 type webkitURL = URL;
15946 declare var webkitURL: typeof URL;
15947
15948 interface URLSearchParams {
15949     /**
15950      * Appends a specified key/value pair as a new search parameter.
15951      */
15952     append(name: string, value: string): void;
15953     /**
15954      * Deletes the given search parameter, and its associated value, from the list of all search parameters.
15955      */
15956     delete(name: string): void;
15957     /**
15958      * Returns the first value associated to the given search parameter.
15959      */
15960     get(name: string): string | null;
15961     /**
15962      * Returns all the values association with a given search parameter.
15963      */
15964     getAll(name: string): string[];
15965     /**
15966      * Returns a Boolean indicating if such a search parameter exists.
15967      */
15968     has(name: string): boolean;
15969     /**
15970      * Sets the value associated to a given search parameter to the given value. If there were several values, delete the others.
15971      */
15972     set(name: string, value: string): void;
15973     sort(): void;
15974     /**
15975      * Returns a string containing a query string suitable for use in a URL. Does not include the question mark.
15976      */
15977     toString(): string;
15978     forEach(callbackfn: (value: string, key: string, parent: URLSearchParams) => void, thisArg?: any): void;
15979 }
15980
15981 declare var URLSearchParams: {
15982     prototype: URLSearchParams;
15983     new(init?: string[][] | Record<string, string> | string | URLSearchParams): URLSearchParams;
15984     toString(): string;
15985 };
15986
15987 /** This WebVR API interface represents any VR device supported by this API. It includes generic information such as device IDs and descriptions, as well as methods for starting to present a VR scene, retrieving eye parameters and display capabilities, and other important functionality. */
15988 interface VRDisplay extends EventTarget {
15989     readonly capabilities: VRDisplayCapabilities;
15990     depthFar: number;
15991     depthNear: number;
15992     readonly displayId: number;
15993     readonly displayName: string;
15994     readonly isConnected: boolean;
15995     readonly isPresenting: boolean;
15996     readonly stageParameters: VRStageParameters | null;
15997     cancelAnimationFrame(handle: number): void;
15998     exitPresent(): Promise<void>;
15999     getEyeParameters(whichEye: string): VREyeParameters;
16000     getFrameData(frameData: VRFrameData): boolean;
16001     getLayers(): VRLayer[];
16002     /** @deprecated */
16003     getPose(): VRPose;
16004     requestAnimationFrame(callback: FrameRequestCallback): number;
16005     requestPresent(layers: VRLayer[]): Promise<void>;
16006     resetPose(): void;
16007     submitFrame(pose?: VRPose): void;
16008 }
16009
16010 declare var VRDisplay: {
16011     prototype: VRDisplay;
16012     new(): VRDisplay;
16013 };
16014
16015 /** This WebVR API interface describes the capabilities of a VRDisplay — its features can be used to perform VR device capability tests, for example can it return position information. */
16016 interface VRDisplayCapabilities {
16017     readonly canPresent: boolean;
16018     readonly hasExternalDisplay: boolean;
16019     readonly hasOrientation: boolean;
16020     readonly hasPosition: boolean;
16021     readonly maxLayers: number;
16022 }
16023
16024 declare var VRDisplayCapabilities: {
16025     prototype: VRDisplayCapabilities;
16026     new(): VRDisplayCapabilities;
16027 };
16028
16029 /** This WebVR API interface represents represents the event object of WebVR-related events (see the list of WebVR window extensions). */
16030 interface VRDisplayEvent extends Event {
16031     readonly display: VRDisplay;
16032     readonly reason: VRDisplayEventReason | null;
16033 }
16034
16035 declare var VRDisplayEvent: {
16036     prototype: VRDisplayEvent;
16037     new(type: string, eventInitDict: VRDisplayEventInit): VRDisplayEvent;
16038 };
16039
16040 /** This WebVR API interface represents all the information required to correctly render a scene for a given eye, including field of view information. */
16041 interface VREyeParameters {
16042     /** @deprecated */
16043     readonly fieldOfView: VRFieldOfView;
16044     readonly offset: Float32Array;
16045     readonly renderHeight: number;
16046     readonly renderWidth: number;
16047 }
16048
16049 declare var VREyeParameters: {
16050     prototype: VREyeParameters;
16051     new(): VREyeParameters;
16052 };
16053
16054 /** This WebVR API interface represents a field of view defined by 4 different degree values describing the view from a center point. */
16055 interface VRFieldOfView {
16056     readonly downDegrees: number;
16057     readonly leftDegrees: number;
16058     readonly rightDegrees: number;
16059     readonly upDegrees: number;
16060 }
16061
16062 declare var VRFieldOfView: {
16063     prototype: VRFieldOfView;
16064     new(): VRFieldOfView;
16065 };
16066
16067 /** This WebVR API interface represents all the information needed to render a single frame of a VR scene; constructed by VRDisplay.getFrameData(). */
16068 interface VRFrameData {
16069     readonly leftProjectionMatrix: Float32Array;
16070     readonly leftViewMatrix: Float32Array;
16071     readonly pose: VRPose;
16072     readonly rightProjectionMatrix: Float32Array;
16073     readonly rightViewMatrix: Float32Array;
16074     readonly timestamp: number;
16075 }
16076
16077 declare var VRFrameData: {
16078     prototype: VRFrameData;
16079     new(): VRFrameData;
16080 };
16081
16082 /** This WebVR API interface represents the state of a VR sensor at a given timestamp (which includes orientation, position, velocity, and acceleration information.) */
16083 interface VRPose {
16084     readonly angularAcceleration: Float32Array | null;
16085     readonly angularVelocity: Float32Array | null;
16086     readonly linearAcceleration: Float32Array | null;
16087     readonly linearVelocity: Float32Array | null;
16088     readonly orientation: Float32Array | null;
16089     readonly position: Float32Array | null;
16090     readonly timestamp: number;
16091 }
16092
16093 declare var VRPose: {
16094     prototype: VRPose;
16095     new(): VRPose;
16096 };
16097
16098 interface VTTCue extends TextTrackCue {
16099     align: AlignSetting;
16100     line: LineAndPositionSetting;
16101     lineAlign: LineAlignSetting;
16102     position: LineAndPositionSetting;
16103     positionAlign: PositionAlignSetting;
16104     region: VTTRegion | null;
16105     size: number;
16106     snapToLines: boolean;
16107     text: string;
16108     vertical: DirectionSetting;
16109     getCueAsHTML(): DocumentFragment;
16110     addEventListener<K extends keyof TextTrackCueEventMap>(type: K, listener: (this: VTTCue, ev: TextTrackCueEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
16111     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
16112     removeEventListener<K extends keyof TextTrackCueEventMap>(type: K, listener: (this: VTTCue, ev: TextTrackCueEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
16113     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
16114 }
16115
16116 declare var VTTCue: {
16117     prototype: VTTCue;
16118     new(startTime: number, endTime: number, text: string): VTTCue;
16119 };
16120
16121 interface VTTRegion {
16122     id: string;
16123     lines: number;
16124     regionAnchorX: number;
16125     regionAnchorY: number;
16126     scroll: ScrollSetting;
16127     viewportAnchorX: number;
16128     viewportAnchorY: number;
16129     width: number;
16130 }
16131
16132 declare var VTTRegion: {
16133     prototype: VTTRegion;
16134     new(): VTTRegion;
16135 };
16136
16137 /** 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. */
16138 interface ValidityState {
16139     readonly badInput: boolean;
16140     readonly customError: boolean;
16141     readonly patternMismatch: boolean;
16142     readonly rangeOverflow: boolean;
16143     readonly rangeUnderflow: boolean;
16144     readonly stepMismatch: boolean;
16145     readonly tooLong: boolean;
16146     readonly tooShort: boolean;
16147     readonly typeMismatch: boolean;
16148     readonly valid: boolean;
16149     readonly valueMissing: boolean;
16150 }
16151
16152 declare var ValidityState: {
16153     prototype: ValidityState;
16154     new(): ValidityState;
16155 };
16156
16157 /** Returned by the HTMLVideoElement.getVideoPlaybackQuality() method and contains metrics that can be used to determine the playback quality of a video. */
16158 interface VideoPlaybackQuality {
16159     readonly creationTime: number;
16160     readonly droppedVideoFrames: number;
16161     readonly totalVideoFrames: number;
16162 }
16163
16164 declare var VideoPlaybackQuality: {
16165     prototype: VideoPlaybackQuality;
16166     new(): VideoPlaybackQuality;
16167 };
16168
16169 interface WEBGL_color_buffer_float {
16170     readonly FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE_EXT: GLenum;
16171     readonly RGBA32F_EXT: GLenum;
16172     readonly UNSIGNED_NORMALIZED_EXT: GLenum;
16173 }
16174
16175 interface WEBGL_compressed_texture_astc {
16176     getSupportedProfiles(): string[];
16177     readonly COMPRESSED_RGBA_ASTC_10x10_KHR: GLenum;
16178     readonly COMPRESSED_RGBA_ASTC_10x5_KHR: GLenum;
16179     readonly COMPRESSED_RGBA_ASTC_10x6_KHR: GLenum;
16180     readonly COMPRESSED_RGBA_ASTC_10x8_KHR: GLenum;
16181     readonly COMPRESSED_RGBA_ASTC_12x10_KHR: GLenum;
16182     readonly COMPRESSED_RGBA_ASTC_12x12_KHR: GLenum;
16183     readonly COMPRESSED_RGBA_ASTC_4x4_KHR: GLenum;
16184     readonly COMPRESSED_RGBA_ASTC_5x4_KHR: GLenum;
16185     readonly COMPRESSED_RGBA_ASTC_5x5_KHR: GLenum;
16186     readonly COMPRESSED_RGBA_ASTC_6x5_KHR: GLenum;
16187     readonly COMPRESSED_RGBA_ASTC_6x6_KHR: GLenum;
16188     readonly COMPRESSED_RGBA_ASTC_8x5_KHR: GLenum;
16189     readonly COMPRESSED_RGBA_ASTC_8x6_KHR: GLenum;
16190     readonly COMPRESSED_RGBA_ASTC_8x8_KHR: GLenum;
16191     readonly COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR: GLenum;
16192     readonly COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR: GLenum;
16193     readonly COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR: GLenum;
16194     readonly COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR: GLenum;
16195     readonly COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR: GLenum;
16196     readonly COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR: GLenum;
16197     readonly COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR: GLenum;
16198     readonly COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR: GLenum;
16199     readonly COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR: GLenum;
16200     readonly COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR: GLenum;
16201     readonly COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR: GLenum;
16202     readonly COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR: GLenum;
16203     readonly COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR: GLenum;
16204     readonly COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR: GLenum;
16205 }
16206
16207 /** The WEBGL_compressed_texture_s3tc extension is part of the WebGL API and exposes four S3TC compressed texture formats. */
16208 interface WEBGL_compressed_texture_s3tc {
16209     readonly COMPRESSED_RGBA_S3TC_DXT1_EXT: GLenum;
16210     readonly COMPRESSED_RGBA_S3TC_DXT3_EXT: GLenum;
16211     readonly COMPRESSED_RGBA_S3TC_DXT5_EXT: GLenum;
16212     readonly COMPRESSED_RGB_S3TC_DXT1_EXT: GLenum;
16213 }
16214
16215 interface WEBGL_compressed_texture_s3tc_srgb {
16216     readonly COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT: GLenum;
16217     readonly COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT: GLenum;
16218     readonly COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT: GLenum;
16219     readonly COMPRESSED_SRGB_S3TC_DXT1_EXT: GLenum;
16220 }
16221
16222 /** 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. */
16223 interface WEBGL_debug_renderer_info {
16224     readonly UNMASKED_RENDERER_WEBGL: GLenum;
16225     readonly UNMASKED_VENDOR_WEBGL: GLenum;
16226 }
16227
16228 interface WEBGL_debug_shaders {
16229     getTranslatedShaderSource(shader: WebGLShader): string;
16230 }
16231
16232 /** The WEBGL_depth_texture extension is part of the WebGL API and defines 2D depth and depth-stencil textures. */
16233 interface WEBGL_depth_texture {
16234     readonly UNSIGNED_INT_24_8_WEBGL: GLenum;
16235 }
16236
16237 interface WEBGL_draw_buffers {
16238     drawBuffersWEBGL(buffers: GLenum[]): void;
16239     readonly COLOR_ATTACHMENT0_WEBGL: GLenum;
16240     readonly COLOR_ATTACHMENT10_WEBGL: GLenum;
16241     readonly COLOR_ATTACHMENT11_WEBGL: GLenum;
16242     readonly COLOR_ATTACHMENT12_WEBGL: GLenum;
16243     readonly COLOR_ATTACHMENT13_WEBGL: GLenum;
16244     readonly COLOR_ATTACHMENT14_WEBGL: GLenum;
16245     readonly COLOR_ATTACHMENT15_WEBGL: GLenum;
16246     readonly COLOR_ATTACHMENT1_WEBGL: GLenum;
16247     readonly COLOR_ATTACHMENT2_WEBGL: GLenum;
16248     readonly COLOR_ATTACHMENT3_WEBGL: GLenum;
16249     readonly COLOR_ATTACHMENT4_WEBGL: GLenum;
16250     readonly COLOR_ATTACHMENT5_WEBGL: GLenum;
16251     readonly COLOR_ATTACHMENT6_WEBGL: GLenum;
16252     readonly COLOR_ATTACHMENT7_WEBGL: GLenum;
16253     readonly COLOR_ATTACHMENT8_WEBGL: GLenum;
16254     readonly COLOR_ATTACHMENT9_WEBGL: GLenum;
16255     readonly DRAW_BUFFER0_WEBGL: GLenum;
16256     readonly DRAW_BUFFER10_WEBGL: GLenum;
16257     readonly DRAW_BUFFER11_WEBGL: GLenum;
16258     readonly DRAW_BUFFER12_WEBGL: GLenum;
16259     readonly DRAW_BUFFER13_WEBGL: GLenum;
16260     readonly DRAW_BUFFER14_WEBGL: GLenum;
16261     readonly DRAW_BUFFER15_WEBGL: GLenum;
16262     readonly DRAW_BUFFER1_WEBGL: GLenum;
16263     readonly DRAW_BUFFER2_WEBGL: GLenum;
16264     readonly DRAW_BUFFER3_WEBGL: GLenum;
16265     readonly DRAW_BUFFER4_WEBGL: GLenum;
16266     readonly DRAW_BUFFER5_WEBGL: GLenum;
16267     readonly DRAW_BUFFER6_WEBGL: GLenum;
16268     readonly DRAW_BUFFER7_WEBGL: GLenum;
16269     readonly DRAW_BUFFER8_WEBGL: GLenum;
16270     readonly DRAW_BUFFER9_WEBGL: GLenum;
16271     readonly MAX_COLOR_ATTACHMENTS_WEBGL: GLenum;
16272     readonly MAX_DRAW_BUFFERS_WEBGL: GLenum;
16273 }
16274
16275 interface WEBGL_lose_context {
16276     loseContext(): void;
16277     restoreContext(): void;
16278 }
16279
16280 /** A WaveShaperNode always has exactly one input and one output. */
16281 interface WaveShaperNode extends AudioNode {
16282     curve: Float32Array | null;
16283     oversample: OverSampleType;
16284 }
16285
16286 declare var WaveShaperNode: {
16287     prototype: WaveShaperNode;
16288     new(context: BaseAudioContext, options?: WaveShaperOptions): WaveShaperNode;
16289 };
16290
16291 interface WebAuthentication {
16292     getAssertion(assertionChallenge: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer | null, options?: AssertionOptions): Promise<WebAuthnAssertion>;
16293     makeCredential(accountInformation: Account, cryptoParameters: ScopedCredentialParameters[], attestationChallenge: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer | null, options?: ScopedCredentialOptions): Promise<ScopedCredentialInfo>;
16294 }
16295
16296 declare var WebAuthentication: {
16297     prototype: WebAuthentication;
16298     new(): WebAuthentication;
16299 };
16300
16301 interface WebAuthnAssertion {
16302     readonly authenticatorData: ArrayBuffer;
16303     readonly clientData: ArrayBuffer;
16304     readonly credential: ScopedCredential;
16305     readonly signature: ArrayBuffer;
16306 }
16307
16308 declare var WebAuthnAssertion: {
16309     prototype: WebAuthnAssertion;
16310     new(): WebAuthnAssertion;
16311 };
16312
16313 interface WebGL2RenderingContext extends WebGL2RenderingContextBase, WebGL2RenderingContextOverloads, WebGLRenderingContextBase {
16314 }
16315
16316 declare var WebGL2RenderingContext: {
16317     prototype: WebGL2RenderingContext;
16318     new(): WebGL2RenderingContext;
16319     readonly ACTIVE_ATTRIBUTES: GLenum;
16320     readonly ACTIVE_TEXTURE: GLenum;
16321     readonly ACTIVE_UNIFORMS: GLenum;
16322     readonly ALIASED_LINE_WIDTH_RANGE: GLenum;
16323     readonly ALIASED_POINT_SIZE_RANGE: GLenum;
16324     readonly ALPHA: GLenum;
16325     readonly ALPHA_BITS: GLenum;
16326     readonly ALWAYS: GLenum;
16327     readonly ARRAY_BUFFER: GLenum;
16328     readonly ARRAY_BUFFER_BINDING: GLenum;
16329     readonly ATTACHED_SHADERS: GLenum;
16330     readonly BACK: GLenum;
16331     readonly BLEND: GLenum;
16332     readonly BLEND_COLOR: GLenum;
16333     readonly BLEND_DST_ALPHA: GLenum;
16334     readonly BLEND_DST_RGB: GLenum;
16335     readonly BLEND_EQUATION: GLenum;
16336     readonly BLEND_EQUATION_ALPHA: GLenum;
16337     readonly BLEND_EQUATION_RGB: GLenum;
16338     readonly BLEND_SRC_ALPHA: GLenum;
16339     readonly BLEND_SRC_RGB: GLenum;
16340     readonly BLUE_BITS: GLenum;
16341     readonly BOOL: GLenum;
16342     readonly BOOL_VEC2: GLenum;
16343     readonly BOOL_VEC3: GLenum;
16344     readonly BOOL_VEC4: GLenum;
16345     readonly BROWSER_DEFAULT_WEBGL: GLenum;
16346     readonly BUFFER_SIZE: GLenum;
16347     readonly BUFFER_USAGE: GLenum;
16348     readonly BYTE: GLenum;
16349     readonly CCW: GLenum;
16350     readonly CLAMP_TO_EDGE: GLenum;
16351     readonly COLOR_ATTACHMENT0: GLenum;
16352     readonly COLOR_BUFFER_BIT: GLenum;
16353     readonly COLOR_CLEAR_VALUE: GLenum;
16354     readonly COLOR_WRITEMASK: GLenum;
16355     readonly COMPILE_STATUS: GLenum;
16356     readonly COMPRESSED_TEXTURE_FORMATS: GLenum;
16357     readonly CONSTANT_ALPHA: GLenum;
16358     readonly CONSTANT_COLOR: GLenum;
16359     readonly CONTEXT_LOST_WEBGL: GLenum;
16360     readonly CULL_FACE: GLenum;
16361     readonly CULL_FACE_MODE: GLenum;
16362     readonly CURRENT_PROGRAM: GLenum;
16363     readonly CURRENT_VERTEX_ATTRIB: GLenum;
16364     readonly CW: GLenum;
16365     readonly DECR: GLenum;
16366     readonly DECR_WRAP: GLenum;
16367     readonly DELETE_STATUS: GLenum;
16368     readonly DEPTH_ATTACHMENT: GLenum;
16369     readonly DEPTH_BITS: GLenum;
16370     readonly DEPTH_BUFFER_BIT: GLenum;
16371     readonly DEPTH_CLEAR_VALUE: GLenum;
16372     readonly DEPTH_COMPONENT: GLenum;
16373     readonly DEPTH_COMPONENT16: GLenum;
16374     readonly DEPTH_FUNC: GLenum;
16375     readonly DEPTH_RANGE: GLenum;
16376     readonly DEPTH_STENCIL: GLenum;
16377     readonly DEPTH_STENCIL_ATTACHMENT: GLenum;
16378     readonly DEPTH_TEST: GLenum;
16379     readonly DEPTH_WRITEMASK: GLenum;
16380     readonly DITHER: GLenum;
16381     readonly DONT_CARE: GLenum;
16382     readonly DST_ALPHA: GLenum;
16383     readonly DST_COLOR: GLenum;
16384     readonly DYNAMIC_DRAW: GLenum;
16385     readonly ELEMENT_ARRAY_BUFFER: GLenum;
16386     readonly ELEMENT_ARRAY_BUFFER_BINDING: GLenum;
16387     readonly EQUAL: GLenum;
16388     readonly FASTEST: GLenum;
16389     readonly FLOAT: GLenum;
16390     readonly FLOAT_MAT2: GLenum;
16391     readonly FLOAT_MAT3: GLenum;
16392     readonly FLOAT_MAT4: GLenum;
16393     readonly FLOAT_VEC2: GLenum;
16394     readonly FLOAT_VEC3: GLenum;
16395     readonly FLOAT_VEC4: GLenum;
16396     readonly FRAGMENT_SHADER: GLenum;
16397     readonly FRAMEBUFFER: GLenum;
16398     readonly FRAMEBUFFER_ATTACHMENT_OBJECT_NAME: GLenum;
16399     readonly FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE: GLenum;
16400     readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE: GLenum;
16401     readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL: GLenum;
16402     readonly FRAMEBUFFER_BINDING: GLenum;
16403     readonly FRAMEBUFFER_COMPLETE: GLenum;
16404     readonly FRAMEBUFFER_INCOMPLETE_ATTACHMENT: GLenum;
16405     readonly FRAMEBUFFER_INCOMPLETE_DIMENSIONS: GLenum;
16406     readonly FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: GLenum;
16407     readonly FRAMEBUFFER_UNSUPPORTED: GLenum;
16408     readonly FRONT: GLenum;
16409     readonly FRONT_AND_BACK: GLenum;
16410     readonly FRONT_FACE: GLenum;
16411     readonly FUNC_ADD: GLenum;
16412     readonly FUNC_REVERSE_SUBTRACT: GLenum;
16413     readonly FUNC_SUBTRACT: GLenum;
16414     readonly GENERATE_MIPMAP_HINT: GLenum;
16415     readonly GEQUAL: GLenum;
16416     readonly GREATER: GLenum;
16417     readonly GREEN_BITS: GLenum;
16418     readonly HIGH_FLOAT: GLenum;
16419     readonly HIGH_INT: GLenum;
16420     readonly IMPLEMENTATION_COLOR_READ_FORMAT: GLenum;
16421     readonly IMPLEMENTATION_COLOR_READ_TYPE: GLenum;
16422     readonly INCR: GLenum;
16423     readonly INCR_WRAP: GLenum;
16424     readonly INT: GLenum;
16425     readonly INT_VEC2: GLenum;
16426     readonly INT_VEC3: GLenum;
16427     readonly INT_VEC4: GLenum;
16428     readonly INVALID_ENUM: GLenum;
16429     readonly INVALID_FRAMEBUFFER_OPERATION: GLenum;
16430     readonly INVALID_OPERATION: GLenum;
16431     readonly INVALID_VALUE: GLenum;
16432     readonly INVERT: GLenum;
16433     readonly KEEP: GLenum;
16434     readonly LEQUAL: GLenum;
16435     readonly LESS: GLenum;
16436     readonly LINEAR: GLenum;
16437     readonly LINEAR_MIPMAP_LINEAR: GLenum;
16438     readonly LINEAR_MIPMAP_NEAREST: GLenum;
16439     readonly LINES: GLenum;
16440     readonly LINE_LOOP: GLenum;
16441     readonly LINE_STRIP: GLenum;
16442     readonly LINE_WIDTH: GLenum;
16443     readonly LINK_STATUS: GLenum;
16444     readonly LOW_FLOAT: GLenum;
16445     readonly LOW_INT: GLenum;
16446     readonly LUMINANCE: GLenum;
16447     readonly LUMINANCE_ALPHA: GLenum;
16448     readonly MAX_COMBINED_TEXTURE_IMAGE_UNITS: GLenum;
16449     readonly MAX_CUBE_MAP_TEXTURE_SIZE: GLenum;
16450     readonly MAX_FRAGMENT_UNIFORM_VECTORS: GLenum;
16451     readonly MAX_RENDERBUFFER_SIZE: GLenum;
16452     readonly MAX_TEXTURE_IMAGE_UNITS: GLenum;
16453     readonly MAX_TEXTURE_SIZE: GLenum;
16454     readonly MAX_VARYING_VECTORS: GLenum;
16455     readonly MAX_VERTEX_ATTRIBS: GLenum;
16456     readonly MAX_VERTEX_TEXTURE_IMAGE_UNITS: GLenum;
16457     readonly MAX_VERTEX_UNIFORM_VECTORS: GLenum;
16458     readonly MAX_VIEWPORT_DIMS: GLenum;
16459     readonly MEDIUM_FLOAT: GLenum;
16460     readonly MEDIUM_INT: GLenum;
16461     readonly MIRRORED_REPEAT: GLenum;
16462     readonly NEAREST: GLenum;
16463     readonly NEAREST_MIPMAP_LINEAR: GLenum;
16464     readonly NEAREST_MIPMAP_NEAREST: GLenum;
16465     readonly NEVER: GLenum;
16466     readonly NICEST: GLenum;
16467     readonly NONE: GLenum;
16468     readonly NOTEQUAL: GLenum;
16469     readonly NO_ERROR: GLenum;
16470     readonly ONE: GLenum;
16471     readonly ONE_MINUS_CONSTANT_ALPHA: GLenum;
16472     readonly ONE_MINUS_CONSTANT_COLOR: GLenum;
16473     readonly ONE_MINUS_DST_ALPHA: GLenum;
16474     readonly ONE_MINUS_DST_COLOR: GLenum;
16475     readonly ONE_MINUS_SRC_ALPHA: GLenum;
16476     readonly ONE_MINUS_SRC_COLOR: GLenum;
16477     readonly OUT_OF_MEMORY: GLenum;
16478     readonly PACK_ALIGNMENT: GLenum;
16479     readonly POINTS: GLenum;
16480     readonly POLYGON_OFFSET_FACTOR: GLenum;
16481     readonly POLYGON_OFFSET_FILL: GLenum;
16482     readonly POLYGON_OFFSET_UNITS: GLenum;
16483     readonly RED_BITS: GLenum;
16484     readonly RENDERBUFFER: GLenum;
16485     readonly RENDERBUFFER_ALPHA_SIZE: GLenum;
16486     readonly RENDERBUFFER_BINDING: GLenum;
16487     readonly RENDERBUFFER_BLUE_SIZE: GLenum;
16488     readonly RENDERBUFFER_DEPTH_SIZE: GLenum;
16489     readonly RENDERBUFFER_GREEN_SIZE: GLenum;
16490     readonly RENDERBUFFER_HEIGHT: GLenum;
16491     readonly RENDERBUFFER_INTERNAL_FORMAT: GLenum;
16492     readonly RENDERBUFFER_RED_SIZE: GLenum;
16493     readonly RENDERBUFFER_STENCIL_SIZE: GLenum;
16494     readonly RENDERBUFFER_WIDTH: GLenum;
16495     readonly RENDERER: GLenum;
16496     readonly REPEAT: GLenum;
16497     readonly REPLACE: GLenum;
16498     readonly RGB: GLenum;
16499     readonly RGB565: GLenum;
16500     readonly RGB5_A1: GLenum;
16501     readonly RGBA: GLenum;
16502     readonly RGBA4: GLenum;
16503     readonly SAMPLER_2D: GLenum;
16504     readonly SAMPLER_CUBE: GLenum;
16505     readonly SAMPLES: GLenum;
16506     readonly SAMPLE_ALPHA_TO_COVERAGE: GLenum;
16507     readonly SAMPLE_BUFFERS: GLenum;
16508     readonly SAMPLE_COVERAGE: GLenum;
16509     readonly SAMPLE_COVERAGE_INVERT: GLenum;
16510     readonly SAMPLE_COVERAGE_VALUE: GLenum;
16511     readonly SCISSOR_BOX: GLenum;
16512     readonly SCISSOR_TEST: GLenum;
16513     readonly SHADER_TYPE: GLenum;
16514     readonly SHADING_LANGUAGE_VERSION: GLenum;
16515     readonly SHORT: GLenum;
16516     readonly SRC_ALPHA: GLenum;
16517     readonly SRC_ALPHA_SATURATE: GLenum;
16518     readonly SRC_COLOR: GLenum;
16519     readonly STATIC_DRAW: GLenum;
16520     readonly STENCIL_ATTACHMENT: GLenum;
16521     readonly STENCIL_BACK_FAIL: GLenum;
16522     readonly STENCIL_BACK_FUNC: GLenum;
16523     readonly STENCIL_BACK_PASS_DEPTH_FAIL: GLenum;
16524     readonly STENCIL_BACK_PASS_DEPTH_PASS: GLenum;
16525     readonly STENCIL_BACK_REF: GLenum;
16526     readonly STENCIL_BACK_VALUE_MASK: GLenum;
16527     readonly STENCIL_BACK_WRITEMASK: GLenum;
16528     readonly STENCIL_BITS: GLenum;
16529     readonly STENCIL_BUFFER_BIT: GLenum;
16530     readonly STENCIL_CLEAR_VALUE: GLenum;
16531     readonly STENCIL_FAIL: GLenum;
16532     readonly STENCIL_FUNC: GLenum;
16533     readonly STENCIL_INDEX8: GLenum;
16534     readonly STENCIL_PASS_DEPTH_FAIL: GLenum;
16535     readonly STENCIL_PASS_DEPTH_PASS: GLenum;
16536     readonly STENCIL_REF: GLenum;
16537     readonly STENCIL_TEST: GLenum;
16538     readonly STENCIL_VALUE_MASK: GLenum;
16539     readonly STENCIL_WRITEMASK: GLenum;
16540     readonly STREAM_DRAW: GLenum;
16541     readonly SUBPIXEL_BITS: GLenum;
16542     readonly TEXTURE: GLenum;
16543     readonly TEXTURE0: GLenum;
16544     readonly TEXTURE1: GLenum;
16545     readonly TEXTURE10: GLenum;
16546     readonly TEXTURE11: GLenum;
16547     readonly TEXTURE12: GLenum;
16548     readonly TEXTURE13: GLenum;
16549     readonly TEXTURE14: GLenum;
16550     readonly TEXTURE15: GLenum;
16551     readonly TEXTURE16: GLenum;
16552     readonly TEXTURE17: GLenum;
16553     readonly TEXTURE18: GLenum;
16554     readonly TEXTURE19: GLenum;
16555     readonly TEXTURE2: GLenum;
16556     readonly TEXTURE20: GLenum;
16557     readonly TEXTURE21: GLenum;
16558     readonly TEXTURE22: GLenum;
16559     readonly TEXTURE23: GLenum;
16560     readonly TEXTURE24: GLenum;
16561     readonly TEXTURE25: GLenum;
16562     readonly TEXTURE26: GLenum;
16563     readonly TEXTURE27: GLenum;
16564     readonly TEXTURE28: GLenum;
16565     readonly TEXTURE29: GLenum;
16566     readonly TEXTURE3: GLenum;
16567     readonly TEXTURE30: GLenum;
16568     readonly TEXTURE31: GLenum;
16569     readonly TEXTURE4: GLenum;
16570     readonly TEXTURE5: GLenum;
16571     readonly TEXTURE6: GLenum;
16572     readonly TEXTURE7: GLenum;
16573     readonly TEXTURE8: GLenum;
16574     readonly TEXTURE9: GLenum;
16575     readonly TEXTURE_2D: GLenum;
16576     readonly TEXTURE_BINDING_2D: GLenum;
16577     readonly TEXTURE_BINDING_CUBE_MAP: GLenum;
16578     readonly TEXTURE_CUBE_MAP: GLenum;
16579     readonly TEXTURE_CUBE_MAP_NEGATIVE_X: GLenum;
16580     readonly TEXTURE_CUBE_MAP_NEGATIVE_Y: GLenum;
16581     readonly TEXTURE_CUBE_MAP_NEGATIVE_Z: GLenum;
16582     readonly TEXTURE_CUBE_MAP_POSITIVE_X: GLenum;
16583     readonly TEXTURE_CUBE_MAP_POSITIVE_Y: GLenum;
16584     readonly TEXTURE_CUBE_MAP_POSITIVE_Z: GLenum;
16585     readonly TEXTURE_MAG_FILTER: GLenum;
16586     readonly TEXTURE_MIN_FILTER: GLenum;
16587     readonly TEXTURE_WRAP_S: GLenum;
16588     readonly TEXTURE_WRAP_T: GLenum;
16589     readonly TRIANGLES: GLenum;
16590     readonly TRIANGLE_FAN: GLenum;
16591     readonly TRIANGLE_STRIP: GLenum;
16592     readonly UNPACK_ALIGNMENT: GLenum;
16593     readonly UNPACK_COLORSPACE_CONVERSION_WEBGL: GLenum;
16594     readonly UNPACK_FLIP_Y_WEBGL: GLenum;
16595     readonly UNPACK_PREMULTIPLY_ALPHA_WEBGL: GLenum;
16596     readonly UNSIGNED_BYTE: GLenum;
16597     readonly UNSIGNED_INT: GLenum;
16598     readonly UNSIGNED_SHORT: GLenum;
16599     readonly UNSIGNED_SHORT_4_4_4_4: GLenum;
16600     readonly UNSIGNED_SHORT_5_5_5_1: GLenum;
16601     readonly UNSIGNED_SHORT_5_6_5: GLenum;
16602     readonly VALIDATE_STATUS: GLenum;
16603     readonly VENDOR: GLenum;
16604     readonly VERSION: GLenum;
16605     readonly VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: GLenum;
16606     readonly VERTEX_ATTRIB_ARRAY_ENABLED: GLenum;
16607     readonly VERTEX_ATTRIB_ARRAY_NORMALIZED: GLenum;
16608     readonly VERTEX_ATTRIB_ARRAY_POINTER: GLenum;
16609     readonly VERTEX_ATTRIB_ARRAY_SIZE: GLenum;
16610     readonly VERTEX_ATTRIB_ARRAY_STRIDE: GLenum;
16611     readonly VERTEX_ATTRIB_ARRAY_TYPE: GLenum;
16612     readonly VERTEX_SHADER: GLenum;
16613     readonly VIEWPORT: GLenum;
16614     readonly ZERO: GLenum;
16615     readonly ACTIVE_UNIFORM_BLOCKS: GLenum;
16616     readonly ALREADY_SIGNALED: GLenum;
16617     readonly ANY_SAMPLES_PASSED: GLenum;
16618     readonly ANY_SAMPLES_PASSED_CONSERVATIVE: GLenum;
16619     readonly COLOR: GLenum;
16620     readonly COLOR_ATTACHMENT1: GLenum;
16621     readonly COLOR_ATTACHMENT10: GLenum;
16622     readonly COLOR_ATTACHMENT11: GLenum;
16623     readonly COLOR_ATTACHMENT12: GLenum;
16624     readonly COLOR_ATTACHMENT13: GLenum;
16625     readonly COLOR_ATTACHMENT14: GLenum;
16626     readonly COLOR_ATTACHMENT15: GLenum;
16627     readonly COLOR_ATTACHMENT2: GLenum;
16628     readonly COLOR_ATTACHMENT3: GLenum;
16629     readonly COLOR_ATTACHMENT4: GLenum;
16630     readonly COLOR_ATTACHMENT5: GLenum;
16631     readonly COLOR_ATTACHMENT6: GLenum;
16632     readonly COLOR_ATTACHMENT7: GLenum;
16633     readonly COLOR_ATTACHMENT8: GLenum;
16634     readonly COLOR_ATTACHMENT9: GLenum;
16635     readonly COMPARE_REF_TO_TEXTURE: GLenum;
16636     readonly CONDITION_SATISFIED: GLenum;
16637     readonly COPY_READ_BUFFER: GLenum;
16638     readonly COPY_READ_BUFFER_BINDING: GLenum;
16639     readonly COPY_WRITE_BUFFER: GLenum;
16640     readonly COPY_WRITE_BUFFER_BINDING: GLenum;
16641     readonly CURRENT_QUERY: GLenum;
16642     readonly DEPTH: GLenum;
16643     readonly DEPTH24_STENCIL8: GLenum;
16644     readonly DEPTH32F_STENCIL8: GLenum;
16645     readonly DEPTH_COMPONENT24: GLenum;
16646     readonly DEPTH_COMPONENT32F: GLenum;
16647     readonly DRAW_BUFFER0: GLenum;
16648     readonly DRAW_BUFFER1: GLenum;
16649     readonly DRAW_BUFFER10: GLenum;
16650     readonly DRAW_BUFFER11: GLenum;
16651     readonly DRAW_BUFFER12: GLenum;
16652     readonly DRAW_BUFFER13: GLenum;
16653     readonly DRAW_BUFFER14: GLenum;
16654     readonly DRAW_BUFFER15: GLenum;
16655     readonly DRAW_BUFFER2: GLenum;
16656     readonly DRAW_BUFFER3: GLenum;
16657     readonly DRAW_BUFFER4: GLenum;
16658     readonly DRAW_BUFFER5: GLenum;
16659     readonly DRAW_BUFFER6: GLenum;
16660     readonly DRAW_BUFFER7: GLenum;
16661     readonly DRAW_BUFFER8: GLenum;
16662     readonly DRAW_BUFFER9: GLenum;
16663     readonly DRAW_FRAMEBUFFER: GLenum;
16664     readonly DRAW_FRAMEBUFFER_BINDING: GLenum;
16665     readonly DYNAMIC_COPY: GLenum;
16666     readonly DYNAMIC_READ: GLenum;
16667     readonly FLOAT_32_UNSIGNED_INT_24_8_REV: GLenum;
16668     readonly FLOAT_MAT2x3: GLenum;
16669     readonly FLOAT_MAT2x4: GLenum;
16670     readonly FLOAT_MAT3x2: GLenum;
16671     readonly FLOAT_MAT3x4: GLenum;
16672     readonly FLOAT_MAT4x2: GLenum;
16673     readonly FLOAT_MAT4x3: GLenum;
16674     readonly FRAGMENT_SHADER_DERIVATIVE_HINT: GLenum;
16675     readonly FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE: GLenum;
16676     readonly FRAMEBUFFER_ATTACHMENT_BLUE_SIZE: GLenum;
16677     readonly FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING: GLenum;
16678     readonly FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE: GLenum;
16679     readonly FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE: GLenum;
16680     readonly FRAMEBUFFER_ATTACHMENT_GREEN_SIZE: GLenum;
16681     readonly FRAMEBUFFER_ATTACHMENT_RED_SIZE: GLenum;
16682     readonly FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE: GLenum;
16683     readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER: GLenum;
16684     readonly FRAMEBUFFER_DEFAULT: GLenum;
16685     readonly FRAMEBUFFER_INCOMPLETE_MULTISAMPLE: GLenum;
16686     readonly HALF_FLOAT: GLenum;
16687     readonly INTERLEAVED_ATTRIBS: GLenum;
16688     readonly INT_2_10_10_10_REV: GLenum;
16689     readonly INT_SAMPLER_2D: GLenum;
16690     readonly INT_SAMPLER_2D_ARRAY: GLenum;
16691     readonly INT_SAMPLER_3D: GLenum;
16692     readonly INT_SAMPLER_CUBE: GLenum;
16693     readonly INVALID_INDEX: GLenum;
16694     readonly MAX: GLenum;
16695     readonly MAX_3D_TEXTURE_SIZE: GLenum;
16696     readonly MAX_ARRAY_TEXTURE_LAYERS: GLenum;
16697     readonly MAX_CLIENT_WAIT_TIMEOUT_WEBGL: GLenum;
16698     readonly MAX_COLOR_ATTACHMENTS: GLenum;
16699     readonly MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS: GLenum;
16700     readonly MAX_COMBINED_UNIFORM_BLOCKS: GLenum;
16701     readonly MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS: GLenum;
16702     readonly MAX_DRAW_BUFFERS: GLenum;
16703     readonly MAX_ELEMENTS_INDICES: GLenum;
16704     readonly MAX_ELEMENTS_VERTICES: GLenum;
16705     readonly MAX_ELEMENT_INDEX: GLenum;
16706     readonly MAX_FRAGMENT_INPUT_COMPONENTS: GLenum;
16707     readonly MAX_FRAGMENT_UNIFORM_BLOCKS: GLenum;
16708     readonly MAX_FRAGMENT_UNIFORM_COMPONENTS: GLenum;
16709     readonly MAX_PROGRAM_TEXEL_OFFSET: GLenum;
16710     readonly MAX_SAMPLES: GLenum;
16711     readonly MAX_SERVER_WAIT_TIMEOUT: GLenum;
16712     readonly MAX_TEXTURE_LOD_BIAS: GLenum;
16713     readonly MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS: GLenum;
16714     readonly MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS: GLenum;
16715     readonly MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS: GLenum;
16716     readonly MAX_UNIFORM_BLOCK_SIZE: GLenum;
16717     readonly MAX_UNIFORM_BUFFER_BINDINGS: GLenum;
16718     readonly MAX_VARYING_COMPONENTS: GLenum;
16719     readonly MAX_VERTEX_OUTPUT_COMPONENTS: GLenum;
16720     readonly MAX_VERTEX_UNIFORM_BLOCKS: GLenum;
16721     readonly MAX_VERTEX_UNIFORM_COMPONENTS: GLenum;
16722     readonly MIN: GLenum;
16723     readonly MIN_PROGRAM_TEXEL_OFFSET: GLenum;
16724     readonly OBJECT_TYPE: GLenum;
16725     readonly PACK_ROW_LENGTH: GLenum;
16726     readonly PACK_SKIP_PIXELS: GLenum;
16727     readonly PACK_SKIP_ROWS: GLenum;
16728     readonly PIXEL_PACK_BUFFER: GLenum;
16729     readonly PIXEL_PACK_BUFFER_BINDING: GLenum;
16730     readonly PIXEL_UNPACK_BUFFER: GLenum;
16731     readonly PIXEL_UNPACK_BUFFER_BINDING: GLenum;
16732     readonly QUERY_RESULT: GLenum;
16733     readonly QUERY_RESULT_AVAILABLE: GLenum;
16734     readonly R11F_G11F_B10F: GLenum;
16735     readonly R16F: GLenum;
16736     readonly R16I: GLenum;
16737     readonly R16UI: GLenum;
16738     readonly R32F: GLenum;
16739     readonly R32I: GLenum;
16740     readonly R32UI: GLenum;
16741     readonly R8: GLenum;
16742     readonly R8I: GLenum;
16743     readonly R8UI: GLenum;
16744     readonly R8_SNORM: GLenum;
16745     readonly RASTERIZER_DISCARD: GLenum;
16746     readonly READ_BUFFER: GLenum;
16747     readonly READ_FRAMEBUFFER: GLenum;
16748     readonly READ_FRAMEBUFFER_BINDING: GLenum;
16749     readonly RED: GLenum;
16750     readonly RED_INTEGER: GLenum;
16751     readonly RENDERBUFFER_SAMPLES: GLenum;
16752     readonly RG: GLenum;
16753     readonly RG16F: GLenum;
16754     readonly RG16I: GLenum;
16755     readonly RG16UI: GLenum;
16756     readonly RG32F: GLenum;
16757     readonly RG32I: GLenum;
16758     readonly RG32UI: GLenum;
16759     readonly RG8: GLenum;
16760     readonly RG8I: GLenum;
16761     readonly RG8UI: GLenum;
16762     readonly RG8_SNORM: GLenum;
16763     readonly RGB10_A2: GLenum;
16764     readonly RGB10_A2UI: GLenum;
16765     readonly RGB16F: GLenum;
16766     readonly RGB16I: GLenum;
16767     readonly RGB16UI: GLenum;
16768     readonly RGB32F: GLenum;
16769     readonly RGB32I: GLenum;
16770     readonly RGB32UI: GLenum;
16771     readonly RGB8: GLenum;
16772     readonly RGB8I: GLenum;
16773     readonly RGB8UI: GLenum;
16774     readonly RGB8_SNORM: GLenum;
16775     readonly RGB9_E5: GLenum;
16776     readonly RGBA16F: GLenum;
16777     readonly RGBA16I: GLenum;
16778     readonly RGBA16UI: GLenum;
16779     readonly RGBA32F: GLenum;
16780     readonly RGBA32I: GLenum;
16781     readonly RGBA32UI: GLenum;
16782     readonly RGBA8: GLenum;
16783     readonly RGBA8I: GLenum;
16784     readonly RGBA8UI: GLenum;
16785     readonly RGBA8_SNORM: GLenum;
16786     readonly RGBA_INTEGER: GLenum;
16787     readonly RGB_INTEGER: GLenum;
16788     readonly RG_INTEGER: GLenum;
16789     readonly SAMPLER_2D_ARRAY: GLenum;
16790     readonly SAMPLER_2D_ARRAY_SHADOW: GLenum;
16791     readonly SAMPLER_2D_SHADOW: GLenum;
16792     readonly SAMPLER_3D: GLenum;
16793     readonly SAMPLER_BINDING: GLenum;
16794     readonly SAMPLER_CUBE_SHADOW: GLenum;
16795     readonly SEPARATE_ATTRIBS: GLenum;
16796     readonly SIGNALED: GLenum;
16797     readonly SIGNED_NORMALIZED: GLenum;
16798     readonly SRGB: GLenum;
16799     readonly SRGB8: GLenum;
16800     readonly SRGB8_ALPHA8: GLenum;
16801     readonly STATIC_COPY: GLenum;
16802     readonly STATIC_READ: GLenum;
16803     readonly STENCIL: GLenum;
16804     readonly STREAM_COPY: GLenum;
16805     readonly STREAM_READ: GLenum;
16806     readonly SYNC_CONDITION: GLenum;
16807     readonly SYNC_FENCE: GLenum;
16808     readonly SYNC_FLAGS: GLenum;
16809     readonly SYNC_FLUSH_COMMANDS_BIT: GLenum;
16810     readonly SYNC_GPU_COMMANDS_COMPLETE: GLenum;
16811     readonly SYNC_STATUS: GLenum;
16812     readonly TEXTURE_2D_ARRAY: GLenum;
16813     readonly TEXTURE_3D: GLenum;
16814     readonly TEXTURE_BASE_LEVEL: GLenum;
16815     readonly TEXTURE_BINDING_2D_ARRAY: GLenum;
16816     readonly TEXTURE_BINDING_3D: GLenum;
16817     readonly TEXTURE_COMPARE_FUNC: GLenum;
16818     readonly TEXTURE_COMPARE_MODE: GLenum;
16819     readonly TEXTURE_IMMUTABLE_FORMAT: GLenum;
16820     readonly TEXTURE_IMMUTABLE_LEVELS: GLenum;
16821     readonly TEXTURE_MAX_LEVEL: GLenum;
16822     readonly TEXTURE_MAX_LOD: GLenum;
16823     readonly TEXTURE_MIN_LOD: GLenum;
16824     readonly TEXTURE_WRAP_R: GLenum;
16825     readonly TIMEOUT_EXPIRED: GLenum;
16826     readonly TIMEOUT_IGNORED: GLint64;
16827     readonly TRANSFORM_FEEDBACK: GLenum;
16828     readonly TRANSFORM_FEEDBACK_ACTIVE: GLenum;
16829     readonly TRANSFORM_FEEDBACK_BINDING: GLenum;
16830     readonly TRANSFORM_FEEDBACK_BUFFER: GLenum;
16831     readonly TRANSFORM_FEEDBACK_BUFFER_BINDING: GLenum;
16832     readonly TRANSFORM_FEEDBACK_BUFFER_MODE: GLenum;
16833     readonly TRANSFORM_FEEDBACK_BUFFER_SIZE: GLenum;
16834     readonly TRANSFORM_FEEDBACK_BUFFER_START: GLenum;
16835     readonly TRANSFORM_FEEDBACK_PAUSED: GLenum;
16836     readonly TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN: GLenum;
16837     readonly TRANSFORM_FEEDBACK_VARYINGS: GLenum;
16838     readonly UNIFORM_ARRAY_STRIDE: GLenum;
16839     readonly UNIFORM_BLOCK_ACTIVE_UNIFORMS: GLenum;
16840     readonly UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES: GLenum;
16841     readonly UNIFORM_BLOCK_BINDING: GLenum;
16842     readonly UNIFORM_BLOCK_DATA_SIZE: GLenum;
16843     readonly UNIFORM_BLOCK_INDEX: GLenum;
16844     readonly UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER: GLenum;
16845     readonly UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER: GLenum;
16846     readonly UNIFORM_BUFFER: GLenum;
16847     readonly UNIFORM_BUFFER_BINDING: GLenum;
16848     readonly UNIFORM_BUFFER_OFFSET_ALIGNMENT: GLenum;
16849     readonly UNIFORM_BUFFER_SIZE: GLenum;
16850     readonly UNIFORM_BUFFER_START: GLenum;
16851     readonly UNIFORM_IS_ROW_MAJOR: GLenum;
16852     readonly UNIFORM_MATRIX_STRIDE: GLenum;
16853     readonly UNIFORM_OFFSET: GLenum;
16854     readonly UNIFORM_SIZE: GLenum;
16855     readonly UNIFORM_TYPE: GLenum;
16856     readonly UNPACK_IMAGE_HEIGHT: GLenum;
16857     readonly UNPACK_ROW_LENGTH: GLenum;
16858     readonly UNPACK_SKIP_IMAGES: GLenum;
16859     readonly UNPACK_SKIP_PIXELS: GLenum;
16860     readonly UNPACK_SKIP_ROWS: GLenum;
16861     readonly UNSIGNALED: GLenum;
16862     readonly UNSIGNED_INT_10F_11F_11F_REV: GLenum;
16863     readonly UNSIGNED_INT_24_8: GLenum;
16864     readonly UNSIGNED_INT_2_10_10_10_REV: GLenum;
16865     readonly UNSIGNED_INT_5_9_9_9_REV: GLenum;
16866     readonly UNSIGNED_INT_SAMPLER_2D: GLenum;
16867     readonly UNSIGNED_INT_SAMPLER_2D_ARRAY: GLenum;
16868     readonly UNSIGNED_INT_SAMPLER_3D: GLenum;
16869     readonly UNSIGNED_INT_SAMPLER_CUBE: GLenum;
16870     readonly UNSIGNED_INT_VEC2: GLenum;
16871     readonly UNSIGNED_INT_VEC3: GLenum;
16872     readonly UNSIGNED_INT_VEC4: GLenum;
16873     readonly UNSIGNED_NORMALIZED: GLenum;
16874     readonly VERTEX_ARRAY_BINDING: GLenum;
16875     readonly VERTEX_ATTRIB_ARRAY_DIVISOR: GLenum;
16876     readonly VERTEX_ATTRIB_ARRAY_INTEGER: GLenum;
16877     readonly WAIT_FAILED: GLenum;
16878 };
16879
16880 interface WebGL2RenderingContextBase {
16881     beginQuery(target: GLenum, query: WebGLQuery): void;
16882     beginTransformFeedback(primitiveMode: GLenum): void;
16883     bindBufferBase(target: GLenum, index: GLuint, buffer: WebGLBuffer | null): void;
16884     bindBufferRange(target: GLenum, index: GLuint, buffer: WebGLBuffer | null, offset: GLintptr, size: GLsizeiptr): void;
16885     bindSampler(unit: GLuint, sampler: WebGLSampler | null): void;
16886     bindTransformFeedback(target: GLenum, tf: WebGLTransformFeedback | null): void;
16887     bindVertexArray(array: WebGLVertexArrayObject | null): void;
16888     blitFramebuffer(srcX0: GLint, srcY0: GLint, srcX1: GLint, srcY1: GLint, dstX0: GLint, dstY0: GLint, dstX1: GLint, dstY1: GLint, mask: GLbitfield, filter: GLenum): void;
16889     clearBufferfi(buffer: GLenum, drawbuffer: GLint, depth: GLfloat, stencil: GLint): void;
16890     clearBufferfv(buffer: GLenum, drawbuffer: GLint, values: Float32List, srcOffset?: GLuint): void;
16891     clearBufferiv(buffer: GLenum, drawbuffer: GLint, values: Int32List, srcOffset?: GLuint): void;
16892     clearBufferuiv(buffer: GLenum, drawbuffer: GLint, values: Uint32List, srcOffset?: GLuint): void;
16893     clientWaitSync(sync: WebGLSync, flags: GLbitfield, timeout: GLuint64): GLenum;
16894     compressedTexImage3D(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, imageSize: GLsizei, offset: GLintptr): void;
16895     compressedTexImage3D(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, srcData: ArrayBufferView, srcOffset?: GLuint, srcLengthOverride?: GLuint): void;
16896     compressedTexSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, imageSize: GLsizei, offset: GLintptr): void;
16897     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;
16898     copyBufferSubData(readTarget: GLenum, writeTarget: GLenum, readOffset: GLintptr, writeOffset: GLintptr, size: GLsizeiptr): void;
16899     copyTexSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, x: GLint, y: GLint, width: GLsizei, height: GLsizei): void;
16900     createQuery(): WebGLQuery | null;
16901     createSampler(): WebGLSampler | null;
16902     createTransformFeedback(): WebGLTransformFeedback | null;
16903     createVertexArray(): WebGLVertexArrayObject | null;
16904     deleteQuery(query: WebGLQuery | null): void;
16905     deleteSampler(sampler: WebGLSampler | null): void;
16906     deleteSync(sync: WebGLSync | null): void;
16907     deleteTransformFeedback(tf: WebGLTransformFeedback | null): void;
16908     deleteVertexArray(vertexArray: WebGLVertexArrayObject | null): void;
16909     drawArraysInstanced(mode: GLenum, first: GLint, count: GLsizei, instanceCount: GLsizei): void;
16910     drawBuffers(buffers: GLenum[]): void;
16911     drawElementsInstanced(mode: GLenum, count: GLsizei, type: GLenum, offset: GLintptr, instanceCount: GLsizei): void;
16912     drawRangeElements(mode: GLenum, start: GLuint, end: GLuint, count: GLsizei, type: GLenum, offset: GLintptr): void;
16913     endQuery(target: GLenum): void;
16914     endTransformFeedback(): void;
16915     fenceSync(condition: GLenum, flags: GLbitfield): WebGLSync | null;
16916     framebufferTextureLayer(target: GLenum, attachment: GLenum, texture: WebGLTexture | null, level: GLint, layer: GLint): void;
16917     getActiveUniformBlockName(program: WebGLProgram, uniformBlockIndex: GLuint): string | null;
16918     getActiveUniformBlockParameter(program: WebGLProgram, uniformBlockIndex: GLuint, pname: GLenum): any;
16919     getActiveUniforms(program: WebGLProgram, uniformIndices: GLuint[], pname: GLenum): any;
16920     getBufferSubData(target: GLenum, srcByteOffset: GLintptr, dstBuffer: ArrayBufferView, dstOffset?: GLuint, length?: GLuint): void;
16921     getFragDataLocation(program: WebGLProgram, name: string): GLint;
16922     getIndexedParameter(target: GLenum, index: GLuint): any;
16923     getInternalformatParameter(target: GLenum, internalformat: GLenum, pname: GLenum): any;
16924     getQuery(target: GLenum, pname: GLenum): WebGLQuery | null;
16925     getQueryParameter(query: WebGLQuery, pname: GLenum): any;
16926     getSamplerParameter(sampler: WebGLSampler, pname: GLenum): any;
16927     getSyncParameter(sync: WebGLSync, pname: GLenum): any;
16928     getTransformFeedbackVarying(program: WebGLProgram, index: GLuint): WebGLActiveInfo | null;
16929     getUniformBlockIndex(program: WebGLProgram, uniformBlockName: string): GLuint;
16930     getUniformIndices(program: WebGLProgram, uniformNames: string[]): GLuint[] | null;
16931     invalidateFramebuffer(target: GLenum, attachments: GLenum[]): void;
16932     invalidateSubFramebuffer(target: GLenum, attachments: GLenum[], x: GLint, y: GLint, width: GLsizei, height: GLsizei): void;
16933     isQuery(query: WebGLQuery | null): GLboolean;
16934     isSampler(sampler: WebGLSampler | null): GLboolean;
16935     isSync(sync: WebGLSync | null): GLboolean;
16936     isTransformFeedback(tf: WebGLTransformFeedback | null): GLboolean;
16937     isVertexArray(vertexArray: WebGLVertexArrayObject | null): GLboolean;
16938     pauseTransformFeedback(): void;
16939     readBuffer(src: GLenum): void;
16940     renderbufferStorageMultisample(target: GLenum, samples: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei): void;
16941     resumeTransformFeedback(): void;
16942     samplerParameterf(sampler: WebGLSampler, pname: GLenum, param: GLfloat): void;
16943     samplerParameteri(sampler: WebGLSampler, pname: GLenum, param: GLint): void;
16944     texImage3D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, format: GLenum, type: GLenum, pboOffset: GLintptr): void;
16945     texImage3D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, format: GLenum, type: GLenum, source: TexImageSource): void;
16946     texImage3D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, format: GLenum, type: GLenum, srcData: ArrayBufferView | null): void;
16947     texImage3D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, format: GLenum, type: GLenum, srcData: ArrayBufferView, srcOffset: GLuint): void;
16948     texStorage2D(target: GLenum, levels: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei): void;
16949     texStorage3D(target: GLenum, levels: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei): void;
16950     texSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, type: GLenum, pboOffset: GLintptr): void;
16951     texSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, type: GLenum, source: TexImageSource): void;
16952     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;
16953     transformFeedbackVaryings(program: WebGLProgram, varyings: string[], bufferMode: GLenum): void;
16954     uniform1ui(location: WebGLUniformLocation | null, v0: GLuint): void;
16955     uniform1uiv(location: WebGLUniformLocation | null, data: Uint32List, srcOffset?: GLuint, srcLength?: GLuint): void;
16956     uniform2ui(location: WebGLUniformLocation | null, v0: GLuint, v1: GLuint): void;
16957     uniform2uiv(location: WebGLUniformLocation | null, data: Uint32List, srcOffset?: GLuint, srcLength?: GLuint): void;
16958     uniform3ui(location: WebGLUniformLocation | null, v0: GLuint, v1: GLuint, v2: GLuint): void;
16959     uniform3uiv(location: WebGLUniformLocation | null, data: Uint32List, srcOffset?: GLuint, srcLength?: GLuint): void;
16960     uniform4ui(location: WebGLUniformLocation | null, v0: GLuint, v1: GLuint, v2: GLuint, v3: GLuint): void;
16961     uniform4uiv(location: WebGLUniformLocation | null, data: Uint32List, srcOffset?: GLuint, srcLength?: GLuint): void;
16962     uniformBlockBinding(program: WebGLProgram, uniformBlockIndex: GLuint, uniformBlockBinding: GLuint): void;
16963     uniformMatrix2x3fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
16964     uniformMatrix2x4fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
16965     uniformMatrix3x2fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
16966     uniformMatrix3x4fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
16967     uniformMatrix4x2fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
16968     uniformMatrix4x3fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
16969     vertexAttribDivisor(index: GLuint, divisor: GLuint): void;
16970     vertexAttribI4i(index: GLuint, x: GLint, y: GLint, z: GLint, w: GLint): void;
16971     vertexAttribI4iv(index: GLuint, values: Int32List): void;
16972     vertexAttribI4ui(index: GLuint, x: GLuint, y: GLuint, z: GLuint, w: GLuint): void;
16973     vertexAttribI4uiv(index: GLuint, values: Uint32List): void;
16974     vertexAttribIPointer(index: GLuint, size: GLint, type: GLenum, stride: GLsizei, offset: GLintptr): void;
16975     waitSync(sync: WebGLSync, flags: GLbitfield, timeout: GLint64): void;
16976     readonly ACTIVE_UNIFORM_BLOCKS: GLenum;
16977     readonly ALREADY_SIGNALED: GLenum;
16978     readonly ANY_SAMPLES_PASSED: GLenum;
16979     readonly ANY_SAMPLES_PASSED_CONSERVATIVE: GLenum;
16980     readonly COLOR: GLenum;
16981     readonly COLOR_ATTACHMENT1: GLenum;
16982     readonly COLOR_ATTACHMENT10: GLenum;
16983     readonly COLOR_ATTACHMENT11: GLenum;
16984     readonly COLOR_ATTACHMENT12: GLenum;
16985     readonly COLOR_ATTACHMENT13: GLenum;
16986     readonly COLOR_ATTACHMENT14: GLenum;
16987     readonly COLOR_ATTACHMENT15: GLenum;
16988     readonly COLOR_ATTACHMENT2: GLenum;
16989     readonly COLOR_ATTACHMENT3: GLenum;
16990     readonly COLOR_ATTACHMENT4: GLenum;
16991     readonly COLOR_ATTACHMENT5: GLenum;
16992     readonly COLOR_ATTACHMENT6: GLenum;
16993     readonly COLOR_ATTACHMENT7: GLenum;
16994     readonly COLOR_ATTACHMENT8: GLenum;
16995     readonly COLOR_ATTACHMENT9: GLenum;
16996     readonly COMPARE_REF_TO_TEXTURE: GLenum;
16997     readonly CONDITION_SATISFIED: GLenum;
16998     readonly COPY_READ_BUFFER: GLenum;
16999     readonly COPY_READ_BUFFER_BINDING: GLenum;
17000     readonly COPY_WRITE_BUFFER: GLenum;
17001     readonly COPY_WRITE_BUFFER_BINDING: GLenum;
17002     readonly CURRENT_QUERY: GLenum;
17003     readonly DEPTH: GLenum;
17004     readonly DEPTH24_STENCIL8: GLenum;
17005     readonly DEPTH32F_STENCIL8: GLenum;
17006     readonly DEPTH_COMPONENT24: GLenum;
17007     readonly DEPTH_COMPONENT32F: GLenum;
17008     readonly DRAW_BUFFER0: GLenum;
17009     readonly DRAW_BUFFER1: GLenum;
17010     readonly DRAW_BUFFER10: GLenum;
17011     readonly DRAW_BUFFER11: GLenum;
17012     readonly DRAW_BUFFER12: GLenum;
17013     readonly DRAW_BUFFER13: GLenum;
17014     readonly DRAW_BUFFER14: GLenum;
17015     readonly DRAW_BUFFER15: GLenum;
17016     readonly DRAW_BUFFER2: GLenum;
17017     readonly DRAW_BUFFER3: GLenum;
17018     readonly DRAW_BUFFER4: GLenum;
17019     readonly DRAW_BUFFER5: GLenum;
17020     readonly DRAW_BUFFER6: GLenum;
17021     readonly DRAW_BUFFER7: GLenum;
17022     readonly DRAW_BUFFER8: GLenum;
17023     readonly DRAW_BUFFER9: GLenum;
17024     readonly DRAW_FRAMEBUFFER: GLenum;
17025     readonly DRAW_FRAMEBUFFER_BINDING: GLenum;
17026     readonly DYNAMIC_COPY: GLenum;
17027     readonly DYNAMIC_READ: GLenum;
17028     readonly FLOAT_32_UNSIGNED_INT_24_8_REV: GLenum;
17029     readonly FLOAT_MAT2x3: GLenum;
17030     readonly FLOAT_MAT2x4: GLenum;
17031     readonly FLOAT_MAT3x2: GLenum;
17032     readonly FLOAT_MAT3x4: GLenum;
17033     readonly FLOAT_MAT4x2: GLenum;
17034     readonly FLOAT_MAT4x3: GLenum;
17035     readonly FRAGMENT_SHADER_DERIVATIVE_HINT: GLenum;
17036     readonly FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE: GLenum;
17037     readonly FRAMEBUFFER_ATTACHMENT_BLUE_SIZE: GLenum;
17038     readonly FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING: GLenum;
17039     readonly FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE: GLenum;
17040     readonly FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE: GLenum;
17041     readonly FRAMEBUFFER_ATTACHMENT_GREEN_SIZE: GLenum;
17042     readonly FRAMEBUFFER_ATTACHMENT_RED_SIZE: GLenum;
17043     readonly FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE: GLenum;
17044     readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER: GLenum;
17045     readonly FRAMEBUFFER_DEFAULT: GLenum;
17046     readonly FRAMEBUFFER_INCOMPLETE_MULTISAMPLE: GLenum;
17047     readonly HALF_FLOAT: GLenum;
17048     readonly INTERLEAVED_ATTRIBS: GLenum;
17049     readonly INT_2_10_10_10_REV: GLenum;
17050     readonly INT_SAMPLER_2D: GLenum;
17051     readonly INT_SAMPLER_2D_ARRAY: GLenum;
17052     readonly INT_SAMPLER_3D: GLenum;
17053     readonly INT_SAMPLER_CUBE: GLenum;
17054     readonly INVALID_INDEX: GLenum;
17055     readonly MAX: GLenum;
17056     readonly MAX_3D_TEXTURE_SIZE: GLenum;
17057     readonly MAX_ARRAY_TEXTURE_LAYERS: GLenum;
17058     readonly MAX_CLIENT_WAIT_TIMEOUT_WEBGL: GLenum;
17059     readonly MAX_COLOR_ATTACHMENTS: GLenum;
17060     readonly MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS: GLenum;
17061     readonly MAX_COMBINED_UNIFORM_BLOCKS: GLenum;
17062     readonly MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS: GLenum;
17063     readonly MAX_DRAW_BUFFERS: GLenum;
17064     readonly MAX_ELEMENTS_INDICES: GLenum;
17065     readonly MAX_ELEMENTS_VERTICES: GLenum;
17066     readonly MAX_ELEMENT_INDEX: GLenum;
17067     readonly MAX_FRAGMENT_INPUT_COMPONENTS: GLenum;
17068     readonly MAX_FRAGMENT_UNIFORM_BLOCKS: GLenum;
17069     readonly MAX_FRAGMENT_UNIFORM_COMPONENTS: GLenum;
17070     readonly MAX_PROGRAM_TEXEL_OFFSET: GLenum;
17071     readonly MAX_SAMPLES: GLenum;
17072     readonly MAX_SERVER_WAIT_TIMEOUT: GLenum;
17073     readonly MAX_TEXTURE_LOD_BIAS: GLenum;
17074     readonly MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS: GLenum;
17075     readonly MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS: GLenum;
17076     readonly MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS: GLenum;
17077     readonly MAX_UNIFORM_BLOCK_SIZE: GLenum;
17078     readonly MAX_UNIFORM_BUFFER_BINDINGS: GLenum;
17079     readonly MAX_VARYING_COMPONENTS: GLenum;
17080     readonly MAX_VERTEX_OUTPUT_COMPONENTS: GLenum;
17081     readonly MAX_VERTEX_UNIFORM_BLOCKS: GLenum;
17082     readonly MAX_VERTEX_UNIFORM_COMPONENTS: GLenum;
17083     readonly MIN: GLenum;
17084     readonly MIN_PROGRAM_TEXEL_OFFSET: GLenum;
17085     readonly OBJECT_TYPE: GLenum;
17086     readonly PACK_ROW_LENGTH: GLenum;
17087     readonly PACK_SKIP_PIXELS: GLenum;
17088     readonly PACK_SKIP_ROWS: GLenum;
17089     readonly PIXEL_PACK_BUFFER: GLenum;
17090     readonly PIXEL_PACK_BUFFER_BINDING: GLenum;
17091     readonly PIXEL_UNPACK_BUFFER: GLenum;
17092     readonly PIXEL_UNPACK_BUFFER_BINDING: GLenum;
17093     readonly QUERY_RESULT: GLenum;
17094     readonly QUERY_RESULT_AVAILABLE: GLenum;
17095     readonly R11F_G11F_B10F: GLenum;
17096     readonly R16F: GLenum;
17097     readonly R16I: GLenum;
17098     readonly R16UI: GLenum;
17099     readonly R32F: GLenum;
17100     readonly R32I: GLenum;
17101     readonly R32UI: GLenum;
17102     readonly R8: GLenum;
17103     readonly R8I: GLenum;
17104     readonly R8UI: GLenum;
17105     readonly R8_SNORM: GLenum;
17106     readonly RASTERIZER_DISCARD: GLenum;
17107     readonly READ_BUFFER: GLenum;
17108     readonly READ_FRAMEBUFFER: GLenum;
17109     readonly READ_FRAMEBUFFER_BINDING: GLenum;
17110     readonly RED: GLenum;
17111     readonly RED_INTEGER: GLenum;
17112     readonly RENDERBUFFER_SAMPLES: GLenum;
17113     readonly RG: GLenum;
17114     readonly RG16F: GLenum;
17115     readonly RG16I: GLenum;
17116     readonly RG16UI: GLenum;
17117     readonly RG32F: GLenum;
17118     readonly RG32I: GLenum;
17119     readonly RG32UI: GLenum;
17120     readonly RG8: GLenum;
17121     readonly RG8I: GLenum;
17122     readonly RG8UI: GLenum;
17123     readonly RG8_SNORM: GLenum;
17124     readonly RGB10_A2: GLenum;
17125     readonly RGB10_A2UI: GLenum;
17126     readonly RGB16F: GLenum;
17127     readonly RGB16I: GLenum;
17128     readonly RGB16UI: GLenum;
17129     readonly RGB32F: GLenum;
17130     readonly RGB32I: GLenum;
17131     readonly RGB32UI: GLenum;
17132     readonly RGB8: GLenum;
17133     readonly RGB8I: GLenum;
17134     readonly RGB8UI: GLenum;
17135     readonly RGB8_SNORM: GLenum;
17136     readonly RGB9_E5: GLenum;
17137     readonly RGBA16F: GLenum;
17138     readonly RGBA16I: GLenum;
17139     readonly RGBA16UI: GLenum;
17140     readonly RGBA32F: GLenum;
17141     readonly RGBA32I: GLenum;
17142     readonly RGBA32UI: GLenum;
17143     readonly RGBA8: GLenum;
17144     readonly RGBA8I: GLenum;
17145     readonly RGBA8UI: GLenum;
17146     readonly RGBA8_SNORM: GLenum;
17147     readonly RGBA_INTEGER: GLenum;
17148     readonly RGB_INTEGER: GLenum;
17149     readonly RG_INTEGER: GLenum;
17150     readonly SAMPLER_2D_ARRAY: GLenum;
17151     readonly SAMPLER_2D_ARRAY_SHADOW: GLenum;
17152     readonly SAMPLER_2D_SHADOW: GLenum;
17153     readonly SAMPLER_3D: GLenum;
17154     readonly SAMPLER_BINDING: GLenum;
17155     readonly SAMPLER_CUBE_SHADOW: GLenum;
17156     readonly SEPARATE_ATTRIBS: GLenum;
17157     readonly SIGNALED: GLenum;
17158     readonly SIGNED_NORMALIZED: GLenum;
17159     readonly SRGB: GLenum;
17160     readonly SRGB8: GLenum;
17161     readonly SRGB8_ALPHA8: GLenum;
17162     readonly STATIC_COPY: GLenum;
17163     readonly STATIC_READ: GLenum;
17164     readonly STENCIL: GLenum;
17165     readonly STREAM_COPY: GLenum;
17166     readonly STREAM_READ: GLenum;
17167     readonly SYNC_CONDITION: GLenum;
17168     readonly SYNC_FENCE: GLenum;
17169     readonly SYNC_FLAGS: GLenum;
17170     readonly SYNC_FLUSH_COMMANDS_BIT: GLenum;
17171     readonly SYNC_GPU_COMMANDS_COMPLETE: GLenum;
17172     readonly SYNC_STATUS: GLenum;
17173     readonly TEXTURE_2D_ARRAY: GLenum;
17174     readonly TEXTURE_3D: GLenum;
17175     readonly TEXTURE_BASE_LEVEL: GLenum;
17176     readonly TEXTURE_BINDING_2D_ARRAY: GLenum;
17177     readonly TEXTURE_BINDING_3D: GLenum;
17178     readonly TEXTURE_COMPARE_FUNC: GLenum;
17179     readonly TEXTURE_COMPARE_MODE: GLenum;
17180     readonly TEXTURE_IMMUTABLE_FORMAT: GLenum;
17181     readonly TEXTURE_IMMUTABLE_LEVELS: GLenum;
17182     readonly TEXTURE_MAX_LEVEL: GLenum;
17183     readonly TEXTURE_MAX_LOD: GLenum;
17184     readonly TEXTURE_MIN_LOD: GLenum;
17185     readonly TEXTURE_WRAP_R: GLenum;
17186     readonly TIMEOUT_EXPIRED: GLenum;
17187     readonly TIMEOUT_IGNORED: GLint64;
17188     readonly TRANSFORM_FEEDBACK: GLenum;
17189     readonly TRANSFORM_FEEDBACK_ACTIVE: GLenum;
17190     readonly TRANSFORM_FEEDBACK_BINDING: GLenum;
17191     readonly TRANSFORM_FEEDBACK_BUFFER: GLenum;
17192     readonly TRANSFORM_FEEDBACK_BUFFER_BINDING: GLenum;
17193     readonly TRANSFORM_FEEDBACK_BUFFER_MODE: GLenum;
17194     readonly TRANSFORM_FEEDBACK_BUFFER_SIZE: GLenum;
17195     readonly TRANSFORM_FEEDBACK_BUFFER_START: GLenum;
17196     readonly TRANSFORM_FEEDBACK_PAUSED: GLenum;
17197     readonly TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN: GLenum;
17198     readonly TRANSFORM_FEEDBACK_VARYINGS: GLenum;
17199     readonly UNIFORM_ARRAY_STRIDE: GLenum;
17200     readonly UNIFORM_BLOCK_ACTIVE_UNIFORMS: GLenum;
17201     readonly UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES: GLenum;
17202     readonly UNIFORM_BLOCK_BINDING: GLenum;
17203     readonly UNIFORM_BLOCK_DATA_SIZE: GLenum;
17204     readonly UNIFORM_BLOCK_INDEX: GLenum;
17205     readonly UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER: GLenum;
17206     readonly UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER: GLenum;
17207     readonly UNIFORM_BUFFER: GLenum;
17208     readonly UNIFORM_BUFFER_BINDING: GLenum;
17209     readonly UNIFORM_BUFFER_OFFSET_ALIGNMENT: GLenum;
17210     readonly UNIFORM_BUFFER_SIZE: GLenum;
17211     readonly UNIFORM_BUFFER_START: GLenum;
17212     readonly UNIFORM_IS_ROW_MAJOR: GLenum;
17213     readonly UNIFORM_MATRIX_STRIDE: GLenum;
17214     readonly UNIFORM_OFFSET: GLenum;
17215     readonly UNIFORM_SIZE: GLenum;
17216     readonly UNIFORM_TYPE: GLenum;
17217     readonly UNPACK_IMAGE_HEIGHT: GLenum;
17218     readonly UNPACK_ROW_LENGTH: GLenum;
17219     readonly UNPACK_SKIP_IMAGES: GLenum;
17220     readonly UNPACK_SKIP_PIXELS: GLenum;
17221     readonly UNPACK_SKIP_ROWS: GLenum;
17222     readonly UNSIGNALED: GLenum;
17223     readonly UNSIGNED_INT_10F_11F_11F_REV: GLenum;
17224     readonly UNSIGNED_INT_24_8: GLenum;
17225     readonly UNSIGNED_INT_2_10_10_10_REV: GLenum;
17226     readonly UNSIGNED_INT_5_9_9_9_REV: GLenum;
17227     readonly UNSIGNED_INT_SAMPLER_2D: GLenum;
17228     readonly UNSIGNED_INT_SAMPLER_2D_ARRAY: GLenum;
17229     readonly UNSIGNED_INT_SAMPLER_3D: GLenum;
17230     readonly UNSIGNED_INT_SAMPLER_CUBE: GLenum;
17231     readonly UNSIGNED_INT_VEC2: GLenum;
17232     readonly UNSIGNED_INT_VEC3: GLenum;
17233     readonly UNSIGNED_INT_VEC4: GLenum;
17234     readonly UNSIGNED_NORMALIZED: GLenum;
17235     readonly VERTEX_ARRAY_BINDING: GLenum;
17236     readonly VERTEX_ATTRIB_ARRAY_DIVISOR: GLenum;
17237     readonly VERTEX_ATTRIB_ARRAY_INTEGER: GLenum;
17238     readonly WAIT_FAILED: GLenum;
17239 }
17240
17241 interface WebGL2RenderingContextOverloads {
17242     bufferData(target: GLenum, size: GLsizeiptr, usage: GLenum): void;
17243     bufferData(target: GLenum, srcData: BufferSource | null, usage: GLenum): void;
17244     bufferData(target: GLenum, srcData: ArrayBufferView, usage: GLenum, srcOffset: GLuint, length?: GLuint): void;
17245     bufferSubData(target: GLenum, dstByteOffset: GLintptr, srcData: BufferSource): void;
17246     bufferSubData(target: GLenum, dstByteOffset: GLintptr, srcData: ArrayBufferView, srcOffset: GLuint, length?: GLuint): void;
17247     compressedTexImage2D(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, border: GLint, imageSize: GLsizei, offset: GLintptr): void;
17248     compressedTexImage2D(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, border: GLint, srcData: ArrayBufferView, srcOffset?: GLuint, srcLengthOverride?: GLuint): void;
17249     compressedTexSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, imageSize: GLsizei, offset: GLintptr): void;
17250     compressedTexSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, srcData: ArrayBufferView, srcOffset?: GLuint, srcLengthOverride?: GLuint): void;
17251     readPixels(x: GLint, y: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, dstData: ArrayBufferView | null): void;
17252     readPixels(x: GLint, y: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, offset: GLintptr): void;
17253     readPixels(x: GLint, y: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, dstData: ArrayBufferView, dstOffset: GLuint): void;
17254     texImage2D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, border: GLint, format: GLenum, type: GLenum, pixels: ArrayBufferView | null): void;
17255     texImage2D(target: GLenum, level: GLint, internalformat: GLint, format: GLenum, type: GLenum, source: TexImageSource): void;
17256     texImage2D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, border: GLint, format: GLenum, type: GLenum, pboOffset: GLintptr): void;
17257     texImage2D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, border: GLint, format: GLenum, type: GLenum, source: TexImageSource): void;
17258     texImage2D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, border: GLint, format: GLenum, type: GLenum, srcData: ArrayBufferView, srcOffset: GLuint): void;
17259     texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, pixels: ArrayBufferView | null): void;
17260     texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, format: GLenum, type: GLenum, source: TexImageSource): void;
17261     texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, pboOffset: GLintptr): void;
17262     texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, source: TexImageSource): void;
17263     texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, srcData: ArrayBufferView, srcOffset: GLuint): void;
17264     uniform1fv(location: WebGLUniformLocation | null, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17265     uniform1iv(location: WebGLUniformLocation | null, data: Int32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17266     uniform2fv(location: WebGLUniformLocation | null, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17267     uniform2iv(location: WebGLUniformLocation | null, data: Int32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17268     uniform3fv(location: WebGLUniformLocation | null, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17269     uniform3iv(location: WebGLUniformLocation | null, data: Int32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17270     uniform4fv(location: WebGLUniformLocation | null, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17271     uniform4iv(location: WebGLUniformLocation | null, data: Int32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17272     uniformMatrix2fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17273     uniformMatrix3fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17274     uniformMatrix4fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17275 }
17276
17277 /** Part of the WebGL API and represents the information returned by calling the WebGLRenderingContext.getActiveAttrib() and WebGLRenderingContext.getActiveUniform() methods. */
17278 interface WebGLActiveInfo {
17279     readonly name: string;
17280     readonly size: GLint;
17281     readonly type: GLenum;
17282 }
17283
17284 declare var WebGLActiveInfo: {
17285     prototype: WebGLActiveInfo;
17286     new(): WebGLActiveInfo;
17287 };
17288
17289 /** Part of the WebGL API and represents an opaque buffer object storing data such as vertices or colors. */
17290 interface WebGLBuffer extends WebGLObject {
17291 }
17292
17293 declare var WebGLBuffer: {
17294     prototype: WebGLBuffer;
17295     new(): WebGLBuffer;
17296 };
17297
17298 /** 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. */
17299 interface WebGLContextEvent extends Event {
17300     readonly statusMessage: string;
17301 }
17302
17303 declare var WebGLContextEvent: {
17304     prototype: WebGLContextEvent;
17305     new(type: string, eventInit?: WebGLContextEventInit): WebGLContextEvent;
17306 };
17307
17308 /** Part of the WebGL API and represents a collection of buffers that serve as a rendering destination. */
17309 interface WebGLFramebuffer extends WebGLObject {
17310 }
17311
17312 declare var WebGLFramebuffer: {
17313     prototype: WebGLFramebuffer;
17314     new(): WebGLFramebuffer;
17315 };
17316
17317 interface WebGLObject {
17318 }
17319
17320 declare var WebGLObject: {
17321     prototype: WebGLObject;
17322     new(): WebGLObject;
17323 };
17324
17325 /** 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). */
17326 interface WebGLProgram extends WebGLObject {
17327 }
17328
17329 declare var WebGLProgram: {
17330     prototype: WebGLProgram;
17331     new(): WebGLProgram;
17332 };
17333
17334 interface WebGLQuery extends WebGLObject {
17335 }
17336
17337 declare var WebGLQuery: {
17338     prototype: WebGLQuery;
17339     new(): WebGLQuery;
17340 };
17341
17342 /** Part of the WebGL API and represents a buffer that can contain an image, or can be source or target of an rendering operation. */
17343 interface WebGLRenderbuffer extends WebGLObject {
17344 }
17345
17346 declare var WebGLRenderbuffer: {
17347     prototype: WebGLRenderbuffer;
17348     new(): WebGLRenderbuffer;
17349 };
17350
17351 /** Provides an interface to the OpenGL ES 2.0 graphics rendering context for the drawing surface of an HTML <canvas> element. */
17352 interface WebGLRenderingContext extends WebGLRenderingContextBase, WebGLRenderingContextOverloads {
17353 }
17354
17355 declare var WebGLRenderingContext: {
17356     prototype: WebGLRenderingContext;
17357     new(): WebGLRenderingContext;
17358     readonly ACTIVE_ATTRIBUTES: GLenum;
17359     readonly ACTIVE_TEXTURE: GLenum;
17360     readonly ACTIVE_UNIFORMS: GLenum;
17361     readonly ALIASED_LINE_WIDTH_RANGE: GLenum;
17362     readonly ALIASED_POINT_SIZE_RANGE: GLenum;
17363     readonly ALPHA: GLenum;
17364     readonly ALPHA_BITS: GLenum;
17365     readonly ALWAYS: GLenum;
17366     readonly ARRAY_BUFFER: GLenum;
17367     readonly ARRAY_BUFFER_BINDING: GLenum;
17368     readonly ATTACHED_SHADERS: GLenum;
17369     readonly BACK: GLenum;
17370     readonly BLEND: GLenum;
17371     readonly BLEND_COLOR: GLenum;
17372     readonly BLEND_DST_ALPHA: GLenum;
17373     readonly BLEND_DST_RGB: GLenum;
17374     readonly BLEND_EQUATION: GLenum;
17375     readonly BLEND_EQUATION_ALPHA: GLenum;
17376     readonly BLEND_EQUATION_RGB: GLenum;
17377     readonly BLEND_SRC_ALPHA: GLenum;
17378     readonly BLEND_SRC_RGB: GLenum;
17379     readonly BLUE_BITS: GLenum;
17380     readonly BOOL: GLenum;
17381     readonly BOOL_VEC2: GLenum;
17382     readonly BOOL_VEC3: GLenum;
17383     readonly BOOL_VEC4: GLenum;
17384     readonly BROWSER_DEFAULT_WEBGL: GLenum;
17385     readonly BUFFER_SIZE: GLenum;
17386     readonly BUFFER_USAGE: GLenum;
17387     readonly BYTE: GLenum;
17388     readonly CCW: GLenum;
17389     readonly CLAMP_TO_EDGE: GLenum;
17390     readonly COLOR_ATTACHMENT0: GLenum;
17391     readonly COLOR_BUFFER_BIT: GLenum;
17392     readonly COLOR_CLEAR_VALUE: GLenum;
17393     readonly COLOR_WRITEMASK: GLenum;
17394     readonly COMPILE_STATUS: GLenum;
17395     readonly COMPRESSED_TEXTURE_FORMATS: GLenum;
17396     readonly CONSTANT_ALPHA: GLenum;
17397     readonly CONSTANT_COLOR: GLenum;
17398     readonly CONTEXT_LOST_WEBGL: GLenum;
17399     readonly CULL_FACE: GLenum;
17400     readonly CULL_FACE_MODE: GLenum;
17401     readonly CURRENT_PROGRAM: GLenum;
17402     readonly CURRENT_VERTEX_ATTRIB: GLenum;
17403     readonly CW: GLenum;
17404     readonly DECR: GLenum;
17405     readonly DECR_WRAP: GLenum;
17406     readonly DELETE_STATUS: GLenum;
17407     readonly DEPTH_ATTACHMENT: GLenum;
17408     readonly DEPTH_BITS: GLenum;
17409     readonly DEPTH_BUFFER_BIT: GLenum;
17410     readonly DEPTH_CLEAR_VALUE: GLenum;
17411     readonly DEPTH_COMPONENT: GLenum;
17412     readonly DEPTH_COMPONENT16: GLenum;
17413     readonly DEPTH_FUNC: GLenum;
17414     readonly DEPTH_RANGE: GLenum;
17415     readonly DEPTH_STENCIL: GLenum;
17416     readonly DEPTH_STENCIL_ATTACHMENT: GLenum;
17417     readonly DEPTH_TEST: GLenum;
17418     readonly DEPTH_WRITEMASK: GLenum;
17419     readonly DITHER: GLenum;
17420     readonly DONT_CARE: GLenum;
17421     readonly DST_ALPHA: GLenum;
17422     readonly DST_COLOR: GLenum;
17423     readonly DYNAMIC_DRAW: GLenum;
17424     readonly ELEMENT_ARRAY_BUFFER: GLenum;
17425     readonly ELEMENT_ARRAY_BUFFER_BINDING: GLenum;
17426     readonly EQUAL: GLenum;
17427     readonly FASTEST: GLenum;
17428     readonly FLOAT: GLenum;
17429     readonly FLOAT_MAT2: GLenum;
17430     readonly FLOAT_MAT3: GLenum;
17431     readonly FLOAT_MAT4: GLenum;
17432     readonly FLOAT_VEC2: GLenum;
17433     readonly FLOAT_VEC3: GLenum;
17434     readonly FLOAT_VEC4: GLenum;
17435     readonly FRAGMENT_SHADER: GLenum;
17436     readonly FRAMEBUFFER: GLenum;
17437     readonly FRAMEBUFFER_ATTACHMENT_OBJECT_NAME: GLenum;
17438     readonly FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE: GLenum;
17439     readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE: GLenum;
17440     readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL: GLenum;
17441     readonly FRAMEBUFFER_BINDING: GLenum;
17442     readonly FRAMEBUFFER_COMPLETE: GLenum;
17443     readonly FRAMEBUFFER_INCOMPLETE_ATTACHMENT: GLenum;
17444     readonly FRAMEBUFFER_INCOMPLETE_DIMENSIONS: GLenum;
17445     readonly FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: GLenum;
17446     readonly FRAMEBUFFER_UNSUPPORTED: GLenum;
17447     readonly FRONT: GLenum;
17448     readonly FRONT_AND_BACK: GLenum;
17449     readonly FRONT_FACE: GLenum;
17450     readonly FUNC_ADD: GLenum;
17451     readonly FUNC_REVERSE_SUBTRACT: GLenum;
17452     readonly FUNC_SUBTRACT: GLenum;
17453     readonly GENERATE_MIPMAP_HINT: GLenum;
17454     readonly GEQUAL: GLenum;
17455     readonly GREATER: GLenum;
17456     readonly GREEN_BITS: GLenum;
17457     readonly HIGH_FLOAT: GLenum;
17458     readonly HIGH_INT: GLenum;
17459     readonly IMPLEMENTATION_COLOR_READ_FORMAT: GLenum;
17460     readonly IMPLEMENTATION_COLOR_READ_TYPE: GLenum;
17461     readonly INCR: GLenum;
17462     readonly INCR_WRAP: GLenum;
17463     readonly INT: GLenum;
17464     readonly INT_VEC2: GLenum;
17465     readonly INT_VEC3: GLenum;
17466     readonly INT_VEC4: GLenum;
17467     readonly INVALID_ENUM: GLenum;
17468     readonly INVALID_FRAMEBUFFER_OPERATION: GLenum;
17469     readonly INVALID_OPERATION: GLenum;
17470     readonly INVALID_VALUE: GLenum;
17471     readonly INVERT: GLenum;
17472     readonly KEEP: GLenum;
17473     readonly LEQUAL: GLenum;
17474     readonly LESS: GLenum;
17475     readonly LINEAR: GLenum;
17476     readonly LINEAR_MIPMAP_LINEAR: GLenum;
17477     readonly LINEAR_MIPMAP_NEAREST: GLenum;
17478     readonly LINES: GLenum;
17479     readonly LINE_LOOP: GLenum;
17480     readonly LINE_STRIP: GLenum;
17481     readonly LINE_WIDTH: GLenum;
17482     readonly LINK_STATUS: GLenum;
17483     readonly LOW_FLOAT: GLenum;
17484     readonly LOW_INT: GLenum;
17485     readonly LUMINANCE: GLenum;
17486     readonly LUMINANCE_ALPHA: GLenum;
17487     readonly MAX_COMBINED_TEXTURE_IMAGE_UNITS: GLenum;
17488     readonly MAX_CUBE_MAP_TEXTURE_SIZE: GLenum;
17489     readonly MAX_FRAGMENT_UNIFORM_VECTORS: GLenum;
17490     readonly MAX_RENDERBUFFER_SIZE: GLenum;
17491     readonly MAX_TEXTURE_IMAGE_UNITS: GLenum;
17492     readonly MAX_TEXTURE_SIZE: GLenum;
17493     readonly MAX_VARYING_VECTORS: GLenum;
17494     readonly MAX_VERTEX_ATTRIBS: GLenum;
17495     readonly MAX_VERTEX_TEXTURE_IMAGE_UNITS: GLenum;
17496     readonly MAX_VERTEX_UNIFORM_VECTORS: GLenum;
17497     readonly MAX_VIEWPORT_DIMS: GLenum;
17498     readonly MEDIUM_FLOAT: GLenum;
17499     readonly MEDIUM_INT: GLenum;
17500     readonly MIRRORED_REPEAT: GLenum;
17501     readonly NEAREST: GLenum;
17502     readonly NEAREST_MIPMAP_LINEAR: GLenum;
17503     readonly NEAREST_MIPMAP_NEAREST: GLenum;
17504     readonly NEVER: GLenum;
17505     readonly NICEST: GLenum;
17506     readonly NONE: GLenum;
17507     readonly NOTEQUAL: GLenum;
17508     readonly NO_ERROR: GLenum;
17509     readonly ONE: GLenum;
17510     readonly ONE_MINUS_CONSTANT_ALPHA: GLenum;
17511     readonly ONE_MINUS_CONSTANT_COLOR: GLenum;
17512     readonly ONE_MINUS_DST_ALPHA: GLenum;
17513     readonly ONE_MINUS_DST_COLOR: GLenum;
17514     readonly ONE_MINUS_SRC_ALPHA: GLenum;
17515     readonly ONE_MINUS_SRC_COLOR: GLenum;
17516     readonly OUT_OF_MEMORY: GLenum;
17517     readonly PACK_ALIGNMENT: GLenum;
17518     readonly POINTS: GLenum;
17519     readonly POLYGON_OFFSET_FACTOR: GLenum;
17520     readonly POLYGON_OFFSET_FILL: GLenum;
17521     readonly POLYGON_OFFSET_UNITS: GLenum;
17522     readonly RED_BITS: GLenum;
17523     readonly RENDERBUFFER: GLenum;
17524     readonly RENDERBUFFER_ALPHA_SIZE: GLenum;
17525     readonly RENDERBUFFER_BINDING: GLenum;
17526     readonly RENDERBUFFER_BLUE_SIZE: GLenum;
17527     readonly RENDERBUFFER_DEPTH_SIZE: GLenum;
17528     readonly RENDERBUFFER_GREEN_SIZE: GLenum;
17529     readonly RENDERBUFFER_HEIGHT: GLenum;
17530     readonly RENDERBUFFER_INTERNAL_FORMAT: GLenum;
17531     readonly RENDERBUFFER_RED_SIZE: GLenum;
17532     readonly RENDERBUFFER_STENCIL_SIZE: GLenum;
17533     readonly RENDERBUFFER_WIDTH: GLenum;
17534     readonly RENDERER: GLenum;
17535     readonly REPEAT: GLenum;
17536     readonly REPLACE: GLenum;
17537     readonly RGB: GLenum;
17538     readonly RGB565: GLenum;
17539     readonly RGB5_A1: GLenum;
17540     readonly RGBA: GLenum;
17541     readonly RGBA4: GLenum;
17542     readonly SAMPLER_2D: GLenum;
17543     readonly SAMPLER_CUBE: GLenum;
17544     readonly SAMPLES: GLenum;
17545     readonly SAMPLE_ALPHA_TO_COVERAGE: GLenum;
17546     readonly SAMPLE_BUFFERS: GLenum;
17547     readonly SAMPLE_COVERAGE: GLenum;
17548     readonly SAMPLE_COVERAGE_INVERT: GLenum;
17549     readonly SAMPLE_COVERAGE_VALUE: GLenum;
17550     readonly SCISSOR_BOX: GLenum;
17551     readonly SCISSOR_TEST: GLenum;
17552     readonly SHADER_TYPE: GLenum;
17553     readonly SHADING_LANGUAGE_VERSION: GLenum;
17554     readonly SHORT: GLenum;
17555     readonly SRC_ALPHA: GLenum;
17556     readonly SRC_ALPHA_SATURATE: GLenum;
17557     readonly SRC_COLOR: GLenum;
17558     readonly STATIC_DRAW: GLenum;
17559     readonly STENCIL_ATTACHMENT: GLenum;
17560     readonly STENCIL_BACK_FAIL: GLenum;
17561     readonly STENCIL_BACK_FUNC: GLenum;
17562     readonly STENCIL_BACK_PASS_DEPTH_FAIL: GLenum;
17563     readonly STENCIL_BACK_PASS_DEPTH_PASS: GLenum;
17564     readonly STENCIL_BACK_REF: GLenum;
17565     readonly STENCIL_BACK_VALUE_MASK: GLenum;
17566     readonly STENCIL_BACK_WRITEMASK: GLenum;
17567     readonly STENCIL_BITS: GLenum;
17568     readonly STENCIL_BUFFER_BIT: GLenum;
17569     readonly STENCIL_CLEAR_VALUE: GLenum;
17570     readonly STENCIL_FAIL: GLenum;
17571     readonly STENCIL_FUNC: GLenum;
17572     readonly STENCIL_INDEX8: GLenum;
17573     readonly STENCIL_PASS_DEPTH_FAIL: GLenum;
17574     readonly STENCIL_PASS_DEPTH_PASS: GLenum;
17575     readonly STENCIL_REF: GLenum;
17576     readonly STENCIL_TEST: GLenum;
17577     readonly STENCIL_VALUE_MASK: GLenum;
17578     readonly STENCIL_WRITEMASK: GLenum;
17579     readonly STREAM_DRAW: GLenum;
17580     readonly SUBPIXEL_BITS: GLenum;
17581     readonly TEXTURE: GLenum;
17582     readonly TEXTURE0: GLenum;
17583     readonly TEXTURE1: GLenum;
17584     readonly TEXTURE10: GLenum;
17585     readonly TEXTURE11: GLenum;
17586     readonly TEXTURE12: GLenum;
17587     readonly TEXTURE13: GLenum;
17588     readonly TEXTURE14: GLenum;
17589     readonly TEXTURE15: GLenum;
17590     readonly TEXTURE16: GLenum;
17591     readonly TEXTURE17: GLenum;
17592     readonly TEXTURE18: GLenum;
17593     readonly TEXTURE19: GLenum;
17594     readonly TEXTURE2: GLenum;
17595     readonly TEXTURE20: GLenum;
17596     readonly TEXTURE21: GLenum;
17597     readonly TEXTURE22: GLenum;
17598     readonly TEXTURE23: GLenum;
17599     readonly TEXTURE24: GLenum;
17600     readonly TEXTURE25: GLenum;
17601     readonly TEXTURE26: GLenum;
17602     readonly TEXTURE27: GLenum;
17603     readonly TEXTURE28: GLenum;
17604     readonly TEXTURE29: GLenum;
17605     readonly TEXTURE3: GLenum;
17606     readonly TEXTURE30: GLenum;
17607     readonly TEXTURE31: GLenum;
17608     readonly TEXTURE4: GLenum;
17609     readonly TEXTURE5: GLenum;
17610     readonly TEXTURE6: GLenum;
17611     readonly TEXTURE7: GLenum;
17612     readonly TEXTURE8: GLenum;
17613     readonly TEXTURE9: GLenum;
17614     readonly TEXTURE_2D: GLenum;
17615     readonly TEXTURE_BINDING_2D: GLenum;
17616     readonly TEXTURE_BINDING_CUBE_MAP: GLenum;
17617     readonly TEXTURE_CUBE_MAP: GLenum;
17618     readonly TEXTURE_CUBE_MAP_NEGATIVE_X: GLenum;
17619     readonly TEXTURE_CUBE_MAP_NEGATIVE_Y: GLenum;
17620     readonly TEXTURE_CUBE_MAP_NEGATIVE_Z: GLenum;
17621     readonly TEXTURE_CUBE_MAP_POSITIVE_X: GLenum;
17622     readonly TEXTURE_CUBE_MAP_POSITIVE_Y: GLenum;
17623     readonly TEXTURE_CUBE_MAP_POSITIVE_Z: GLenum;
17624     readonly TEXTURE_MAG_FILTER: GLenum;
17625     readonly TEXTURE_MIN_FILTER: GLenum;
17626     readonly TEXTURE_WRAP_S: GLenum;
17627     readonly TEXTURE_WRAP_T: GLenum;
17628     readonly TRIANGLES: GLenum;
17629     readonly TRIANGLE_FAN: GLenum;
17630     readonly TRIANGLE_STRIP: GLenum;
17631     readonly UNPACK_ALIGNMENT: GLenum;
17632     readonly UNPACK_COLORSPACE_CONVERSION_WEBGL: GLenum;
17633     readonly UNPACK_FLIP_Y_WEBGL: GLenum;
17634     readonly UNPACK_PREMULTIPLY_ALPHA_WEBGL: GLenum;
17635     readonly UNSIGNED_BYTE: GLenum;
17636     readonly UNSIGNED_INT: GLenum;
17637     readonly UNSIGNED_SHORT: GLenum;
17638     readonly UNSIGNED_SHORT_4_4_4_4: GLenum;
17639     readonly UNSIGNED_SHORT_5_5_5_1: GLenum;
17640     readonly UNSIGNED_SHORT_5_6_5: GLenum;
17641     readonly VALIDATE_STATUS: GLenum;
17642     readonly VENDOR: GLenum;
17643     readonly VERSION: GLenum;
17644     readonly VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: GLenum;
17645     readonly VERTEX_ATTRIB_ARRAY_ENABLED: GLenum;
17646     readonly VERTEX_ATTRIB_ARRAY_NORMALIZED: GLenum;
17647     readonly VERTEX_ATTRIB_ARRAY_POINTER: GLenum;
17648     readonly VERTEX_ATTRIB_ARRAY_SIZE: GLenum;
17649     readonly VERTEX_ATTRIB_ARRAY_STRIDE: GLenum;
17650     readonly VERTEX_ATTRIB_ARRAY_TYPE: GLenum;
17651     readonly VERTEX_SHADER: GLenum;
17652     readonly VIEWPORT: GLenum;
17653     readonly ZERO: GLenum;
17654 };
17655
17656 interface WebGLRenderingContextBase {
17657     readonly canvas: HTMLCanvasElement | OffscreenCanvas;
17658     readonly drawingBufferHeight: GLsizei;
17659     readonly drawingBufferWidth: GLsizei;
17660     activeTexture(texture: GLenum): void;
17661     attachShader(program: WebGLProgram, shader: WebGLShader): void;
17662     bindAttribLocation(program: WebGLProgram, index: GLuint, name: string): void;
17663     bindBuffer(target: GLenum, buffer: WebGLBuffer | null): void;
17664     bindFramebuffer(target: GLenum, framebuffer: WebGLFramebuffer | null): void;
17665     bindRenderbuffer(target: GLenum, renderbuffer: WebGLRenderbuffer | null): void;
17666     bindTexture(target: GLenum, texture: WebGLTexture | null): void;
17667     blendColor(red: GLclampf, green: GLclampf, blue: GLclampf, alpha: GLclampf): void;
17668     blendEquation(mode: GLenum): void;
17669     blendEquationSeparate(modeRGB: GLenum, modeAlpha: GLenum): void;
17670     blendFunc(sfactor: GLenum, dfactor: GLenum): void;
17671     blendFuncSeparate(srcRGB: GLenum, dstRGB: GLenum, srcAlpha: GLenum, dstAlpha: GLenum): void;
17672     checkFramebufferStatus(target: GLenum): GLenum;
17673     clear(mask: GLbitfield): void;
17674     clearColor(red: GLclampf, green: GLclampf, blue: GLclampf, alpha: GLclampf): void;
17675     clearDepth(depth: GLclampf): void;
17676     clearStencil(s: GLint): void;
17677     colorMask(red: GLboolean, green: GLboolean, blue: GLboolean, alpha: GLboolean): void;
17678     compileShader(shader: WebGLShader): void;
17679     copyTexImage2D(target: GLenum, level: GLint, internalformat: GLenum, x: GLint, y: GLint, width: GLsizei, height: GLsizei, border: GLint): void;
17680     copyTexSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, x: GLint, y: GLint, width: GLsizei, height: GLsizei): void;
17681     createBuffer(): WebGLBuffer | null;
17682     createFramebuffer(): WebGLFramebuffer | null;
17683     createProgram(): WebGLProgram | null;
17684     createRenderbuffer(): WebGLRenderbuffer | null;
17685     createShader(type: GLenum): WebGLShader | null;
17686     createTexture(): WebGLTexture | null;
17687     cullFace(mode: GLenum): void;
17688     deleteBuffer(buffer: WebGLBuffer | null): void;
17689     deleteFramebuffer(framebuffer: WebGLFramebuffer | null): void;
17690     deleteProgram(program: WebGLProgram | null): void;
17691     deleteRenderbuffer(renderbuffer: WebGLRenderbuffer | null): void;
17692     deleteShader(shader: WebGLShader | null): void;
17693     deleteTexture(texture: WebGLTexture | null): void;
17694     depthFunc(func: GLenum): void;
17695     depthMask(flag: GLboolean): void;
17696     depthRange(zNear: GLclampf, zFar: GLclampf): void;
17697     detachShader(program: WebGLProgram, shader: WebGLShader): void;
17698     disable(cap: GLenum): void;
17699     disableVertexAttribArray(index: GLuint): void;
17700     drawArrays(mode: GLenum, first: GLint, count: GLsizei): void;
17701     drawElements(mode: GLenum, count: GLsizei, type: GLenum, offset: GLintptr): void;
17702     enable(cap: GLenum): void;
17703     enableVertexAttribArray(index: GLuint): void;
17704     finish(): void;
17705     flush(): void;
17706     framebufferRenderbuffer(target: GLenum, attachment: GLenum, renderbuffertarget: GLenum, renderbuffer: WebGLRenderbuffer | null): void;
17707     framebufferTexture2D(target: GLenum, attachment: GLenum, textarget: GLenum, texture: WebGLTexture | null, level: GLint): void;
17708     frontFace(mode: GLenum): void;
17709     generateMipmap(target: GLenum): void;
17710     getActiveAttrib(program: WebGLProgram, index: GLuint): WebGLActiveInfo | null;
17711     getActiveUniform(program: WebGLProgram, index: GLuint): WebGLActiveInfo | null;
17712     getAttachedShaders(program: WebGLProgram): WebGLShader[] | null;
17713     getAttribLocation(program: WebGLProgram, name: string): GLint;
17714     getBufferParameter(target: GLenum, pname: GLenum): any;
17715     getContextAttributes(): WebGLContextAttributes | null;
17716     getError(): GLenum;
17717     getExtension(extensionName: "EXT_blend_minmax"): EXT_blend_minmax | null;
17718     getExtension(extensionName: "EXT_texture_filter_anisotropic"): EXT_texture_filter_anisotropic | null;
17719     getExtension(extensionName: "EXT_frag_depth"): EXT_frag_depth | null;
17720     getExtension(extensionName: "EXT_shader_texture_lod"): EXT_shader_texture_lod | null;
17721     getExtension(extensionName: "EXT_sRGB"): EXT_sRGB | null;
17722     getExtension(extensionName: "OES_vertex_array_object"): OES_vertex_array_object | null;
17723     getExtension(extensionName: "WEBGL_color_buffer_float"): WEBGL_color_buffer_float | null;
17724     getExtension(extensionName: "WEBGL_compressed_texture_astc"): WEBGL_compressed_texture_astc | null;
17725     getExtension(extensionName: "WEBGL_compressed_texture_s3tc_srgb"): WEBGL_compressed_texture_s3tc_srgb | null;
17726     getExtension(extensionName: "WEBGL_debug_shaders"): WEBGL_debug_shaders | null;
17727     getExtension(extensionName: "WEBGL_draw_buffers"): WEBGL_draw_buffers | null;
17728     getExtension(extensionName: "WEBGL_lose_context"): WEBGL_lose_context | null;
17729     getExtension(extensionName: "WEBGL_depth_texture"): WEBGL_depth_texture | null;
17730     getExtension(extensionName: "WEBGL_debug_renderer_info"): WEBGL_debug_renderer_info | null;
17731     getExtension(extensionName: "WEBGL_compressed_texture_s3tc"): WEBGL_compressed_texture_s3tc | null;
17732     getExtension(extensionName: "OES_texture_half_float_linear"): OES_texture_half_float_linear | null;
17733     getExtension(extensionName: "OES_texture_half_float"): OES_texture_half_float | null;
17734     getExtension(extensionName: "OES_texture_float_linear"): OES_texture_float_linear | null;
17735     getExtension(extensionName: "OES_texture_float"): OES_texture_float | null;
17736     getExtension(extensionName: "OES_standard_derivatives"): OES_standard_derivatives | null;
17737     getExtension(extensionName: "OES_element_index_uint"): OES_element_index_uint | null;
17738     getExtension(extensionName: "ANGLE_instanced_arrays"): ANGLE_instanced_arrays | null;
17739     getExtension(extensionName: string): any;
17740     getFramebufferAttachmentParameter(target: GLenum, attachment: GLenum, pname: GLenum): any;
17741     getParameter(pname: GLenum): any;
17742     getProgramInfoLog(program: WebGLProgram): string | null;
17743     getProgramParameter(program: WebGLProgram, pname: GLenum): any;
17744     getRenderbufferParameter(target: GLenum, pname: GLenum): any;
17745     getShaderInfoLog(shader: WebGLShader): string | null;
17746     getShaderParameter(shader: WebGLShader, pname: GLenum): any;
17747     getShaderPrecisionFormat(shadertype: GLenum, precisiontype: GLenum): WebGLShaderPrecisionFormat | null;
17748     getShaderSource(shader: WebGLShader): string | null;
17749     getSupportedExtensions(): string[] | null;
17750     getTexParameter(target: GLenum, pname: GLenum): any;
17751     getUniform(program: WebGLProgram, location: WebGLUniformLocation): any;
17752     getUniformLocation(program: WebGLProgram, name: string): WebGLUniformLocation | null;
17753     getVertexAttrib(index: GLuint, pname: GLenum): any;
17754     getVertexAttribOffset(index: GLuint, pname: GLenum): GLintptr;
17755     hint(target: GLenum, mode: GLenum): void;
17756     isBuffer(buffer: WebGLBuffer | null): GLboolean;
17757     isContextLost(): boolean;
17758     isEnabled(cap: GLenum): GLboolean;
17759     isFramebuffer(framebuffer: WebGLFramebuffer | null): GLboolean;
17760     isProgram(program: WebGLProgram | null): GLboolean;
17761     isRenderbuffer(renderbuffer: WebGLRenderbuffer | null): GLboolean;
17762     isShader(shader: WebGLShader | null): GLboolean;
17763     isTexture(texture: WebGLTexture | null): GLboolean;
17764     lineWidth(width: GLfloat): void;
17765     linkProgram(program: WebGLProgram): void;
17766     pixelStorei(pname: GLenum, param: GLint | GLboolean): void;
17767     polygonOffset(factor: GLfloat, units: GLfloat): void;
17768     renderbufferStorage(target: GLenum, internalformat: GLenum, width: GLsizei, height: GLsizei): void;
17769     sampleCoverage(value: GLclampf, invert: GLboolean): void;
17770     scissor(x: GLint, y: GLint, width: GLsizei, height: GLsizei): void;
17771     shaderSource(shader: WebGLShader, source: string): void;
17772     stencilFunc(func: GLenum, ref: GLint, mask: GLuint): void;
17773     stencilFuncSeparate(face: GLenum, func: GLenum, ref: GLint, mask: GLuint): void;
17774     stencilMask(mask: GLuint): void;
17775     stencilMaskSeparate(face: GLenum, mask: GLuint): void;
17776     stencilOp(fail: GLenum, zfail: GLenum, zpass: GLenum): void;
17777     stencilOpSeparate(face: GLenum, fail: GLenum, zfail: GLenum, zpass: GLenum): void;
17778     texParameterf(target: GLenum, pname: GLenum, param: GLfloat): void;
17779     texParameteri(target: GLenum, pname: GLenum, param: GLint): void;
17780     uniform1f(location: WebGLUniformLocation | null, x: GLfloat): void;
17781     uniform1i(location: WebGLUniformLocation | null, x: GLint): void;
17782     uniform2f(location: WebGLUniformLocation | null, x: GLfloat, y: GLfloat): void;
17783     uniform2i(location: WebGLUniformLocation | null, x: GLint, y: GLint): void;
17784     uniform3f(location: WebGLUniformLocation | null, x: GLfloat, y: GLfloat, z: GLfloat): void;
17785     uniform3i(location: WebGLUniformLocation | null, x: GLint, y: GLint, z: GLint): void;
17786     uniform4f(location: WebGLUniformLocation | null, x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat): void;
17787     uniform4i(location: WebGLUniformLocation | null, x: GLint, y: GLint, z: GLint, w: GLint): void;
17788     useProgram(program: WebGLProgram | null): void;
17789     validateProgram(program: WebGLProgram): void;
17790     vertexAttrib1f(index: GLuint, x: GLfloat): void;
17791     vertexAttrib1fv(index: GLuint, values: Float32List): void;
17792     vertexAttrib2f(index: GLuint, x: GLfloat, y: GLfloat): void;
17793     vertexAttrib2fv(index: GLuint, values: Float32List): void;
17794     vertexAttrib3f(index: GLuint, x: GLfloat, y: GLfloat, z: GLfloat): void;
17795     vertexAttrib3fv(index: GLuint, values: Float32List): void;
17796     vertexAttrib4f(index: GLuint, x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat): void;
17797     vertexAttrib4fv(index: GLuint, values: Float32List): void;
17798     vertexAttribPointer(index: GLuint, size: GLint, type: GLenum, normalized: GLboolean, stride: GLsizei, offset: GLintptr): void;
17799     viewport(x: GLint, y: GLint, width: GLsizei, height: GLsizei): void;
17800     readonly ACTIVE_ATTRIBUTES: GLenum;
17801     readonly ACTIVE_TEXTURE: GLenum;
17802     readonly ACTIVE_UNIFORMS: GLenum;
17803     readonly ALIASED_LINE_WIDTH_RANGE: GLenum;
17804     readonly ALIASED_POINT_SIZE_RANGE: GLenum;
17805     readonly ALPHA: GLenum;
17806     readonly ALPHA_BITS: GLenum;
17807     readonly ALWAYS: GLenum;
17808     readonly ARRAY_BUFFER: GLenum;
17809     readonly ARRAY_BUFFER_BINDING: GLenum;
17810     readonly ATTACHED_SHADERS: GLenum;
17811     readonly BACK: GLenum;
17812     readonly BLEND: GLenum;
17813     readonly BLEND_COLOR: GLenum;
17814     readonly BLEND_DST_ALPHA: GLenum;
17815     readonly BLEND_DST_RGB: GLenum;
17816     readonly BLEND_EQUATION: GLenum;
17817     readonly BLEND_EQUATION_ALPHA: GLenum;
17818     readonly BLEND_EQUATION_RGB: GLenum;
17819     readonly BLEND_SRC_ALPHA: GLenum;
17820     readonly BLEND_SRC_RGB: GLenum;
17821     readonly BLUE_BITS: GLenum;
17822     readonly BOOL: GLenum;
17823     readonly BOOL_VEC2: GLenum;
17824     readonly BOOL_VEC3: GLenum;
17825     readonly BOOL_VEC4: GLenum;
17826     readonly BROWSER_DEFAULT_WEBGL: GLenum;
17827     readonly BUFFER_SIZE: GLenum;
17828     readonly BUFFER_USAGE: GLenum;
17829     readonly BYTE: GLenum;
17830     readonly CCW: GLenum;
17831     readonly CLAMP_TO_EDGE: GLenum;
17832     readonly COLOR_ATTACHMENT0: GLenum;
17833     readonly COLOR_BUFFER_BIT: GLenum;
17834     readonly COLOR_CLEAR_VALUE: GLenum;
17835     readonly COLOR_WRITEMASK: GLenum;
17836     readonly COMPILE_STATUS: GLenum;
17837     readonly COMPRESSED_TEXTURE_FORMATS: GLenum;
17838     readonly CONSTANT_ALPHA: GLenum;
17839     readonly CONSTANT_COLOR: GLenum;
17840     readonly CONTEXT_LOST_WEBGL: GLenum;
17841     readonly CULL_FACE: GLenum;
17842     readonly CULL_FACE_MODE: GLenum;
17843     readonly CURRENT_PROGRAM: GLenum;
17844     readonly CURRENT_VERTEX_ATTRIB: GLenum;
17845     readonly CW: GLenum;
17846     readonly DECR: GLenum;
17847     readonly DECR_WRAP: GLenum;
17848     readonly DELETE_STATUS: GLenum;
17849     readonly DEPTH_ATTACHMENT: GLenum;
17850     readonly DEPTH_BITS: GLenum;
17851     readonly DEPTH_BUFFER_BIT: GLenum;
17852     readonly DEPTH_CLEAR_VALUE: GLenum;
17853     readonly DEPTH_COMPONENT: GLenum;
17854     readonly DEPTH_COMPONENT16: GLenum;
17855     readonly DEPTH_FUNC: GLenum;
17856     readonly DEPTH_RANGE: GLenum;
17857     readonly DEPTH_STENCIL: GLenum;
17858     readonly DEPTH_STENCIL_ATTACHMENT: GLenum;
17859     readonly DEPTH_TEST: GLenum;
17860     readonly DEPTH_WRITEMASK: GLenum;
17861     readonly DITHER: GLenum;
17862     readonly DONT_CARE: GLenum;
17863     readonly DST_ALPHA: GLenum;
17864     readonly DST_COLOR: GLenum;
17865     readonly DYNAMIC_DRAW: GLenum;
17866     readonly ELEMENT_ARRAY_BUFFER: GLenum;
17867     readonly ELEMENT_ARRAY_BUFFER_BINDING: GLenum;
17868     readonly EQUAL: GLenum;
17869     readonly FASTEST: GLenum;
17870     readonly FLOAT: GLenum;
17871     readonly FLOAT_MAT2: GLenum;
17872     readonly FLOAT_MAT3: GLenum;
17873     readonly FLOAT_MAT4: GLenum;
17874     readonly FLOAT_VEC2: GLenum;
17875     readonly FLOAT_VEC3: GLenum;
17876     readonly FLOAT_VEC4: GLenum;
17877     readonly FRAGMENT_SHADER: GLenum;
17878     readonly FRAMEBUFFER: GLenum;
17879     readonly FRAMEBUFFER_ATTACHMENT_OBJECT_NAME: GLenum;
17880     readonly FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE: GLenum;
17881     readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE: GLenum;
17882     readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL: GLenum;
17883     readonly FRAMEBUFFER_BINDING: GLenum;
17884     readonly FRAMEBUFFER_COMPLETE: GLenum;
17885     readonly FRAMEBUFFER_INCOMPLETE_ATTACHMENT: GLenum;
17886     readonly FRAMEBUFFER_INCOMPLETE_DIMENSIONS: GLenum;
17887     readonly FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: GLenum;
17888     readonly FRAMEBUFFER_UNSUPPORTED: GLenum;
17889     readonly FRONT: GLenum;
17890     readonly FRONT_AND_BACK: GLenum;
17891     readonly FRONT_FACE: GLenum;
17892     readonly FUNC_ADD: GLenum;
17893     readonly FUNC_REVERSE_SUBTRACT: GLenum;
17894     readonly FUNC_SUBTRACT: GLenum;
17895     readonly GENERATE_MIPMAP_HINT: GLenum;
17896     readonly GEQUAL: GLenum;
17897     readonly GREATER: GLenum;
17898     readonly GREEN_BITS: GLenum;
17899     readonly HIGH_FLOAT: GLenum;
17900     readonly HIGH_INT: GLenum;
17901     readonly IMPLEMENTATION_COLOR_READ_FORMAT: GLenum;
17902     readonly IMPLEMENTATION_COLOR_READ_TYPE: GLenum;
17903     readonly INCR: GLenum;
17904     readonly INCR_WRAP: GLenum;
17905     readonly INT: GLenum;
17906     readonly INT_VEC2: GLenum;
17907     readonly INT_VEC3: GLenum;
17908     readonly INT_VEC4: GLenum;
17909     readonly INVALID_ENUM: GLenum;
17910     readonly INVALID_FRAMEBUFFER_OPERATION: GLenum;
17911     readonly INVALID_OPERATION: GLenum;
17912     readonly INVALID_VALUE: GLenum;
17913     readonly INVERT: GLenum;
17914     readonly KEEP: GLenum;
17915     readonly LEQUAL: GLenum;
17916     readonly LESS: GLenum;
17917     readonly LINEAR: GLenum;
17918     readonly LINEAR_MIPMAP_LINEAR: GLenum;
17919     readonly LINEAR_MIPMAP_NEAREST: GLenum;
17920     readonly LINES: GLenum;
17921     readonly LINE_LOOP: GLenum;
17922     readonly LINE_STRIP: GLenum;
17923     readonly LINE_WIDTH: GLenum;
17924     readonly LINK_STATUS: GLenum;
17925     readonly LOW_FLOAT: GLenum;
17926     readonly LOW_INT: GLenum;
17927     readonly LUMINANCE: GLenum;
17928     readonly LUMINANCE_ALPHA: GLenum;
17929     readonly MAX_COMBINED_TEXTURE_IMAGE_UNITS: GLenum;
17930     readonly MAX_CUBE_MAP_TEXTURE_SIZE: GLenum;
17931     readonly MAX_FRAGMENT_UNIFORM_VECTORS: GLenum;
17932     readonly MAX_RENDERBUFFER_SIZE: GLenum;
17933     readonly MAX_TEXTURE_IMAGE_UNITS: GLenum;
17934     readonly MAX_TEXTURE_SIZE: GLenum;
17935     readonly MAX_VARYING_VECTORS: GLenum;
17936     readonly MAX_VERTEX_ATTRIBS: GLenum;
17937     readonly MAX_VERTEX_TEXTURE_IMAGE_UNITS: GLenum;
17938     readonly MAX_VERTEX_UNIFORM_VECTORS: GLenum;
17939     readonly MAX_VIEWPORT_DIMS: GLenum;
17940     readonly MEDIUM_FLOAT: GLenum;
17941     readonly MEDIUM_INT: GLenum;
17942     readonly MIRRORED_REPEAT: GLenum;
17943     readonly NEAREST: GLenum;
17944     readonly NEAREST_MIPMAP_LINEAR: GLenum;
17945     readonly NEAREST_MIPMAP_NEAREST: GLenum;
17946     readonly NEVER: GLenum;
17947     readonly NICEST: GLenum;
17948     readonly NONE: GLenum;
17949     readonly NOTEQUAL: GLenum;
17950     readonly NO_ERROR: GLenum;
17951     readonly ONE: GLenum;
17952     readonly ONE_MINUS_CONSTANT_ALPHA: GLenum;
17953     readonly ONE_MINUS_CONSTANT_COLOR: GLenum;
17954     readonly ONE_MINUS_DST_ALPHA: GLenum;
17955     readonly ONE_MINUS_DST_COLOR: GLenum;
17956     readonly ONE_MINUS_SRC_ALPHA: GLenum;
17957     readonly ONE_MINUS_SRC_COLOR: GLenum;
17958     readonly OUT_OF_MEMORY: GLenum;
17959     readonly PACK_ALIGNMENT: GLenum;
17960     readonly POINTS: GLenum;
17961     readonly POLYGON_OFFSET_FACTOR: GLenum;
17962     readonly POLYGON_OFFSET_FILL: GLenum;
17963     readonly POLYGON_OFFSET_UNITS: GLenum;
17964     readonly RED_BITS: GLenum;
17965     readonly RENDERBUFFER: GLenum;
17966     readonly RENDERBUFFER_ALPHA_SIZE: GLenum;
17967     readonly RENDERBUFFER_BINDING: GLenum;
17968     readonly RENDERBUFFER_BLUE_SIZE: GLenum;
17969     readonly RENDERBUFFER_DEPTH_SIZE: GLenum;
17970     readonly RENDERBUFFER_GREEN_SIZE: GLenum;
17971     readonly RENDERBUFFER_HEIGHT: GLenum;
17972     readonly RENDERBUFFER_INTERNAL_FORMAT: GLenum;
17973     readonly RENDERBUFFER_RED_SIZE: GLenum;
17974     readonly RENDERBUFFER_STENCIL_SIZE: GLenum;
17975     readonly RENDERBUFFER_WIDTH: GLenum;
17976     readonly RENDERER: GLenum;
17977     readonly REPEAT: GLenum;
17978     readonly REPLACE: GLenum;
17979     readonly RGB: GLenum;
17980     readonly RGB565: GLenum;
17981     readonly RGB5_A1: GLenum;
17982     readonly RGBA: GLenum;
17983     readonly RGBA4: GLenum;
17984     readonly SAMPLER_2D: GLenum;
17985     readonly SAMPLER_CUBE: GLenum;
17986     readonly SAMPLES: GLenum;
17987     readonly SAMPLE_ALPHA_TO_COVERAGE: GLenum;
17988     readonly SAMPLE_BUFFERS: GLenum;
17989     readonly SAMPLE_COVERAGE: GLenum;
17990     readonly SAMPLE_COVERAGE_INVERT: GLenum;
17991     readonly SAMPLE_COVERAGE_VALUE: GLenum;
17992     readonly SCISSOR_BOX: GLenum;
17993     readonly SCISSOR_TEST: GLenum;
17994     readonly SHADER_TYPE: GLenum;
17995     readonly SHADING_LANGUAGE_VERSION: GLenum;
17996     readonly SHORT: GLenum;
17997     readonly SRC_ALPHA: GLenum;
17998     readonly SRC_ALPHA_SATURATE: GLenum;
17999     readonly SRC_COLOR: GLenum;
18000     readonly STATIC_DRAW: GLenum;
18001     readonly STENCIL_ATTACHMENT: GLenum;
18002     readonly STENCIL_BACK_FAIL: GLenum;
18003     readonly STENCIL_BACK_FUNC: GLenum;
18004     readonly STENCIL_BACK_PASS_DEPTH_FAIL: GLenum;
18005     readonly STENCIL_BACK_PASS_DEPTH_PASS: GLenum;
18006     readonly STENCIL_BACK_REF: GLenum;
18007     readonly STENCIL_BACK_VALUE_MASK: GLenum;
18008     readonly STENCIL_BACK_WRITEMASK: GLenum;
18009     readonly STENCIL_BITS: GLenum;
18010     readonly STENCIL_BUFFER_BIT: GLenum;
18011     readonly STENCIL_CLEAR_VALUE: GLenum;
18012     readonly STENCIL_FAIL: GLenum;
18013     readonly STENCIL_FUNC: GLenum;
18014     readonly STENCIL_INDEX8: GLenum;
18015     readonly STENCIL_PASS_DEPTH_FAIL: GLenum;
18016     readonly STENCIL_PASS_DEPTH_PASS: GLenum;
18017     readonly STENCIL_REF: GLenum;
18018     readonly STENCIL_TEST: GLenum;
18019     readonly STENCIL_VALUE_MASK: GLenum;
18020     readonly STENCIL_WRITEMASK: GLenum;
18021     readonly STREAM_DRAW: GLenum;
18022     readonly SUBPIXEL_BITS: GLenum;
18023     readonly TEXTURE: GLenum;
18024     readonly TEXTURE0: GLenum;
18025     readonly TEXTURE1: GLenum;
18026     readonly TEXTURE10: GLenum;
18027     readonly TEXTURE11: GLenum;
18028     readonly TEXTURE12: GLenum;
18029     readonly TEXTURE13: GLenum;
18030     readonly TEXTURE14: GLenum;
18031     readonly TEXTURE15: GLenum;
18032     readonly TEXTURE16: GLenum;
18033     readonly TEXTURE17: GLenum;
18034     readonly TEXTURE18: GLenum;
18035     readonly TEXTURE19: GLenum;
18036     readonly TEXTURE2: GLenum;
18037     readonly TEXTURE20: GLenum;
18038     readonly TEXTURE21: GLenum;
18039     readonly TEXTURE22: GLenum;
18040     readonly TEXTURE23: GLenum;
18041     readonly TEXTURE24: GLenum;
18042     readonly TEXTURE25: GLenum;
18043     readonly TEXTURE26: GLenum;
18044     readonly TEXTURE27: GLenum;
18045     readonly TEXTURE28: GLenum;
18046     readonly TEXTURE29: GLenum;
18047     readonly TEXTURE3: GLenum;
18048     readonly TEXTURE30: GLenum;
18049     readonly TEXTURE31: GLenum;
18050     readonly TEXTURE4: GLenum;
18051     readonly TEXTURE5: GLenum;
18052     readonly TEXTURE6: GLenum;
18053     readonly TEXTURE7: GLenum;
18054     readonly TEXTURE8: GLenum;
18055     readonly TEXTURE9: GLenum;
18056     readonly TEXTURE_2D: GLenum;
18057     readonly TEXTURE_BINDING_2D: GLenum;
18058     readonly TEXTURE_BINDING_CUBE_MAP: GLenum;
18059     readonly TEXTURE_CUBE_MAP: GLenum;
18060     readonly TEXTURE_CUBE_MAP_NEGATIVE_X: GLenum;
18061     readonly TEXTURE_CUBE_MAP_NEGATIVE_Y: GLenum;
18062     readonly TEXTURE_CUBE_MAP_NEGATIVE_Z: GLenum;
18063     readonly TEXTURE_CUBE_MAP_POSITIVE_X: GLenum;
18064     readonly TEXTURE_CUBE_MAP_POSITIVE_Y: GLenum;
18065     readonly TEXTURE_CUBE_MAP_POSITIVE_Z: GLenum;
18066     readonly TEXTURE_MAG_FILTER: GLenum;
18067     readonly TEXTURE_MIN_FILTER: GLenum;
18068     readonly TEXTURE_WRAP_S: GLenum;
18069     readonly TEXTURE_WRAP_T: GLenum;
18070     readonly TRIANGLES: GLenum;
18071     readonly TRIANGLE_FAN: GLenum;
18072     readonly TRIANGLE_STRIP: GLenum;
18073     readonly UNPACK_ALIGNMENT: GLenum;
18074     readonly UNPACK_COLORSPACE_CONVERSION_WEBGL: GLenum;
18075     readonly UNPACK_FLIP_Y_WEBGL: GLenum;
18076     readonly UNPACK_PREMULTIPLY_ALPHA_WEBGL: GLenum;
18077     readonly UNSIGNED_BYTE: GLenum;
18078     readonly UNSIGNED_INT: GLenum;
18079     readonly UNSIGNED_SHORT: GLenum;
18080     readonly UNSIGNED_SHORT_4_4_4_4: GLenum;
18081     readonly UNSIGNED_SHORT_5_5_5_1: GLenum;
18082     readonly UNSIGNED_SHORT_5_6_5: GLenum;
18083     readonly VALIDATE_STATUS: GLenum;
18084     readonly VENDOR: GLenum;
18085     readonly VERSION: GLenum;
18086     readonly VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: GLenum;
18087     readonly VERTEX_ATTRIB_ARRAY_ENABLED: GLenum;
18088     readonly VERTEX_ATTRIB_ARRAY_NORMALIZED: GLenum;
18089     readonly VERTEX_ATTRIB_ARRAY_POINTER: GLenum;
18090     readonly VERTEX_ATTRIB_ARRAY_SIZE: GLenum;
18091     readonly VERTEX_ATTRIB_ARRAY_STRIDE: GLenum;
18092     readonly VERTEX_ATTRIB_ARRAY_TYPE: GLenum;
18093     readonly VERTEX_SHADER: GLenum;
18094     readonly VIEWPORT: GLenum;
18095     readonly ZERO: GLenum;
18096 }
18097
18098 interface WebGLRenderingContextOverloads {
18099     bufferData(target: GLenum, size: GLsizeiptr, usage: GLenum): void;
18100     bufferData(target: GLenum, data: BufferSource | null, usage: GLenum): void;
18101     bufferSubData(target: GLenum, offset: GLintptr, data: BufferSource): void;
18102     compressedTexImage2D(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, border: GLint, data: ArrayBufferView): void;
18103     compressedTexSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, data: ArrayBufferView): void;
18104     readPixels(x: GLint, y: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, pixels: ArrayBufferView | null): void;
18105     texImage2D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, border: GLint, format: GLenum, type: GLenum, pixels: ArrayBufferView | null): void;
18106     texImage2D(target: GLenum, level: GLint, internalformat: GLint, format: GLenum, type: GLenum, source: TexImageSource): void;
18107     texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, pixels: ArrayBufferView | null): void;
18108     texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, format: GLenum, type: GLenum, source: TexImageSource): void;
18109     uniform1fv(location: WebGLUniformLocation | null, v: Float32List): void;
18110     uniform1iv(location: WebGLUniformLocation | null, v: Int32List): void;
18111     uniform2fv(location: WebGLUniformLocation | null, v: Float32List): void;
18112     uniform2iv(location: WebGLUniformLocation | null, v: Int32List): void;
18113     uniform3fv(location: WebGLUniformLocation | null, v: Float32List): void;
18114     uniform3iv(location: WebGLUniformLocation | null, v: Int32List): void;
18115     uniform4fv(location: WebGLUniformLocation | null, v: Float32List): void;
18116     uniform4iv(location: WebGLUniformLocation | null, v: Int32List): void;
18117     uniformMatrix2fv(location: WebGLUniformLocation | null, transpose: GLboolean, value: Float32List): void;
18118     uniformMatrix3fv(location: WebGLUniformLocation | null, transpose: GLboolean, value: Float32List): void;
18119     uniformMatrix4fv(location: WebGLUniformLocation | null, transpose: GLboolean, value: Float32List): void;
18120 }
18121
18122 interface WebGLSampler extends WebGLObject {
18123 }
18124
18125 declare var WebGLSampler: {
18126     prototype: WebGLSampler;
18127     new(): WebGLSampler;
18128 };
18129
18130 /** 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. */
18131 interface WebGLShader extends WebGLObject {
18132 }
18133
18134 declare var WebGLShader: {
18135     prototype: WebGLShader;
18136     new(): WebGLShader;
18137 };
18138
18139 /** Part of the WebGL API and represents the information returned by calling the WebGLRenderingContext.getShaderPrecisionFormat() method. */
18140 interface WebGLShaderPrecisionFormat {
18141     readonly precision: GLint;
18142     readonly rangeMax: GLint;
18143     readonly rangeMin: GLint;
18144 }
18145
18146 declare var WebGLShaderPrecisionFormat: {
18147     prototype: WebGLShaderPrecisionFormat;
18148     new(): WebGLShaderPrecisionFormat;
18149 };
18150
18151 interface WebGLSync extends WebGLObject {
18152 }
18153
18154 declare var WebGLSync: {
18155     prototype: WebGLSync;
18156     new(): WebGLSync;
18157 };
18158
18159 /** Part of the WebGL API and represents an opaque texture object providing storage and state for texturing operations. */
18160 interface WebGLTexture extends WebGLObject {
18161 }
18162
18163 declare var WebGLTexture: {
18164     prototype: WebGLTexture;
18165     new(): WebGLTexture;
18166 };
18167
18168 interface WebGLTransformFeedback extends WebGLObject {
18169 }
18170
18171 declare var WebGLTransformFeedback: {
18172     prototype: WebGLTransformFeedback;
18173     new(): WebGLTransformFeedback;
18174 };
18175
18176 /** Part of the WebGL API and represents the location of a uniform variable in a shader program. */
18177 interface WebGLUniformLocation {
18178 }
18179
18180 declare var WebGLUniformLocation: {
18181     prototype: WebGLUniformLocation;
18182     new(): WebGLUniformLocation;
18183 };
18184
18185 interface WebGLVertexArrayObject extends WebGLObject {
18186 }
18187
18188 declare var WebGLVertexArrayObject: {
18189     prototype: WebGLVertexArrayObject;
18190     new(): WebGLVertexArrayObject;
18191 };
18192
18193 interface WebGLVertexArrayObjectOES extends WebGLObject {
18194 }
18195
18196 interface WebKitPoint {
18197     x: number;
18198     y: number;
18199 }
18200
18201 declare var WebKitPoint: {
18202     prototype: WebKitPoint;
18203     new(x?: number, y?: number): WebKitPoint;
18204 };
18205
18206 interface WebSocketEventMap {
18207     "close": CloseEvent;
18208     "error": Event;
18209     "message": MessageEvent;
18210     "open": Event;
18211 }
18212
18213 /** Provides the API for creating and managing a WebSocket connection to a server, as well as for sending and receiving data on the connection. */
18214 interface WebSocket extends EventTarget {
18215     /**
18216      * Returns a string that indicates how binary data from the WebSocket object is exposed to scripts:
18217      *
18218      * Can be set, to change how binary data is returned. The default is "blob".
18219      */
18220     binaryType: BinaryType;
18221     /**
18222      * 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.
18223      *
18224      * 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.)
18225      */
18226     readonly bufferedAmount: number;
18227     /**
18228      * Returns the extensions selected by the server, if any.
18229      */
18230     readonly extensions: string;
18231     onclose: ((this: WebSocket, ev: CloseEvent) => any) | null;
18232     onerror: ((this: WebSocket, ev: Event) => any) | null;
18233     onmessage: ((this: WebSocket, ev: MessageEvent) => any) | null;
18234     onopen: ((this: WebSocket, ev: Event) => any) | null;
18235     /**
18236      * 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.
18237      */
18238     readonly protocol: string;
18239     /**
18240      * Returns the state of the WebSocket object's connection. It can have the values described below.
18241      */
18242     readonly readyState: number;
18243     /**
18244      * Returns the URL that was used to establish the WebSocket connection.
18245      */
18246     readonly url: string;
18247     /**
18248      * Closes the WebSocket connection, optionally using code as the the WebSocket connection close code and reason as the the WebSocket connection close reason.
18249      */
18250     close(code?: number, reason?: string): void;
18251     /**
18252      * Transmits data using the WebSocket connection. data can be a string, a Blob, an ArrayBuffer, or an ArrayBufferView.
18253      */
18254     send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void;
18255     readonly CLOSED: number;
18256     readonly CLOSING: number;
18257     readonly CONNECTING: number;
18258     readonly OPEN: number;
18259     addEventListener<K extends keyof WebSocketEventMap>(type: K, listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
18260     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
18261     removeEventListener<K extends keyof WebSocketEventMap>(type: K, listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
18262     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
18263 }
18264
18265 declare var WebSocket: {
18266     prototype: WebSocket;
18267     new(url: string, protocols?: string | string[]): WebSocket;
18268     readonly CLOSED: number;
18269     readonly CLOSING: number;
18270     readonly CONNECTING: number;
18271     readonly OPEN: number;
18272 };
18273
18274 /** Events that occur due to the user moving a mouse wheel or similar input device. */
18275 interface WheelEvent extends MouseEvent {
18276     readonly deltaMode: number;
18277     readonly deltaX: number;
18278     readonly deltaY: number;
18279     readonly deltaZ: number;
18280     readonly DOM_DELTA_LINE: number;
18281     readonly DOM_DELTA_PAGE: number;
18282     readonly DOM_DELTA_PIXEL: number;
18283 }
18284
18285 declare var WheelEvent: {
18286     prototype: WheelEvent;
18287     new(type: string, eventInitDict?: WheelEventInit): WheelEvent;
18288     readonly DOM_DELTA_LINE: number;
18289     readonly DOM_DELTA_PAGE: number;
18290     readonly DOM_DELTA_PIXEL: number;
18291 };
18292
18293 interface WindowEventMap extends GlobalEventHandlersEventMap, WindowEventHandlersEventMap {
18294     "abort": UIEvent;
18295     "afterprint": Event;
18296     "beforeprint": Event;
18297     "beforeunload": BeforeUnloadEvent;
18298     "blur": FocusEvent;
18299     "canplay": Event;
18300     "canplaythrough": Event;
18301     "change": Event;
18302     "click": MouseEvent;
18303     "compassneedscalibration": Event;
18304     "contextmenu": MouseEvent;
18305     "dblclick": MouseEvent;
18306     "devicelight": DeviceLightEvent;
18307     "devicemotion": DeviceMotionEvent;
18308     "deviceorientation": DeviceOrientationEvent;
18309     "deviceorientationabsolute": DeviceOrientationEvent;
18310     "drag": DragEvent;
18311     "dragend": DragEvent;
18312     "dragenter": DragEvent;
18313     "dragleave": DragEvent;
18314     "dragover": DragEvent;
18315     "dragstart": DragEvent;
18316     "drop": DragEvent;
18317     "durationchange": Event;
18318     "emptied": Event;
18319     "ended": Event;
18320     "error": ErrorEvent;
18321     "focus": FocusEvent;
18322     "hashchange": HashChangeEvent;
18323     "input": Event;
18324     "invalid": Event;
18325     "keydown": KeyboardEvent;
18326     "keypress": KeyboardEvent;
18327     "keyup": KeyboardEvent;
18328     "load": Event;
18329     "loadeddata": Event;
18330     "loadedmetadata": Event;
18331     "loadstart": Event;
18332     "message": MessageEvent;
18333     "mousedown": MouseEvent;
18334     "mouseenter": MouseEvent;
18335     "mouseleave": MouseEvent;
18336     "mousemove": MouseEvent;
18337     "mouseout": MouseEvent;
18338     "mouseover": MouseEvent;
18339     "mouseup": MouseEvent;
18340     "mousewheel": Event;
18341     "MSGestureChange": Event;
18342     "MSGestureDoubleTap": Event;
18343     "MSGestureEnd": Event;
18344     "MSGestureHold": Event;
18345     "MSGestureStart": Event;
18346     "MSGestureTap": Event;
18347     "MSInertiaStart": Event;
18348     "MSPointerCancel": Event;
18349     "MSPointerDown": Event;
18350     "MSPointerEnter": Event;
18351     "MSPointerLeave": Event;
18352     "MSPointerMove": Event;
18353     "MSPointerOut": Event;
18354     "MSPointerOver": Event;
18355     "MSPointerUp": Event;
18356     "offline": Event;
18357     "online": Event;
18358     "orientationchange": Event;
18359     "pagehide": PageTransitionEvent;
18360     "pageshow": PageTransitionEvent;
18361     "pause": Event;
18362     "play": Event;
18363     "playing": Event;
18364     "popstate": PopStateEvent;
18365     "progress": ProgressEvent<Window>;
18366     "ratechange": Event;
18367     "readystatechange": ProgressEvent<Window>;
18368     "reset": Event;
18369     "resize": UIEvent;
18370     "scroll": Event;
18371     "seeked": Event;
18372     "seeking": Event;
18373     "select": Event;
18374     "stalled": Event;
18375     "storage": StorageEvent;
18376     "submit": Event;
18377     "suspend": Event;
18378     "timeupdate": Event;
18379     "unload": Event;
18380     "volumechange": Event;
18381     "vrdisplayactivate": Event;
18382     "vrdisplayblur": Event;
18383     "vrdisplayconnect": Event;
18384     "vrdisplaydeactivate": Event;
18385     "vrdisplaydisconnect": Event;
18386     "vrdisplayfocus": Event;
18387     "vrdisplaypointerrestricted": Event;
18388     "vrdisplaypointerunrestricted": Event;
18389     "vrdisplaypresentchange": Event;
18390     "waiting": Event;
18391 }
18392
18393 /** A window containing a DOM document; the document property points to the DOM document loaded in that window. */
18394 interface Window extends EventTarget, AnimationFrameProvider, GlobalEventHandlers, WindowEventHandlers, WindowLocalStorage, WindowOrWorkerGlobalScope, WindowSessionStorage {
18395     readonly applicationCache: ApplicationCache;
18396     readonly clientInformation: Navigator;
18397     readonly closed: boolean;
18398     customElements: CustomElementRegistry;
18399     defaultStatus: string;
18400     readonly devicePixelRatio: number;
18401     readonly doNotTrack: string;
18402     readonly document: Document;
18403     /** @deprecated */
18404     readonly event: Event | undefined;
18405     /** @deprecated */
18406     readonly external: External;
18407     readonly frameElement: Element;
18408     readonly frames: Window;
18409     readonly history: History;
18410     readonly innerHeight: number;
18411     readonly innerWidth: number;
18412     readonly length: number;
18413     location: Location;
18414     readonly locationbar: BarProp;
18415     readonly menubar: BarProp;
18416     readonly msContentScript: ExtensionScriptApis;
18417     name: string;
18418     readonly navigator: Navigator;
18419     offscreenBuffering: string | boolean;
18420     oncompassneedscalibration: ((this: Window, ev: Event) => any) | null;
18421     ondevicelight: ((this: Window, ev: DeviceLightEvent) => any) | null;
18422     ondevicemotion: ((this: Window, ev: DeviceMotionEvent) => any) | null;
18423     ondeviceorientation: ((this: Window, ev: DeviceOrientationEvent) => any) | null;
18424     ondeviceorientationabsolute: ((this: Window, ev: DeviceOrientationEvent) => any) | null;
18425     onmousewheel: ((this: Window, ev: Event) => any) | null;
18426     onmsgesturechange: ((this: Window, ev: Event) => any) | null;
18427     onmsgesturedoubletap: ((this: Window, ev: Event) => any) | null;
18428     onmsgestureend: ((this: Window, ev: Event) => any) | null;
18429     onmsgesturehold: ((this: Window, ev: Event) => any) | null;
18430     onmsgesturestart: ((this: Window, ev: Event) => any) | null;
18431     onmsgesturetap: ((this: Window, ev: Event) => any) | null;
18432     onmsinertiastart: ((this: Window, ev: Event) => any) | null;
18433     onmspointercancel: ((this: Window, ev: Event) => any) | null;
18434     onmspointerdown: ((this: Window, ev: Event) => any) | null;
18435     onmspointerenter: ((this: Window, ev: Event) => any) | null;
18436     onmspointerleave: ((this: Window, ev: Event) => any) | null;
18437     onmspointermove: ((this: Window, ev: Event) => any) | null;
18438     onmspointerout: ((this: Window, ev: Event) => any) | null;
18439     onmspointerover: ((this: Window, ev: Event) => any) | null;
18440     onmspointerup: ((this: Window, ev: Event) => any) | null;
18441     /** @deprecated */
18442     onorientationchange: ((this: Window, ev: Event) => any) | null;
18443     onreadystatechange: ((this: Window, ev: ProgressEvent<Window>) => any) | null;
18444     onvrdisplayactivate: ((this: Window, ev: Event) => any) | null;
18445     onvrdisplayblur: ((this: Window, ev: Event) => any) | null;
18446     onvrdisplayconnect: ((this: Window, ev: Event) => any) | null;
18447     onvrdisplaydeactivate: ((this: Window, ev: Event) => any) | null;
18448     onvrdisplaydisconnect: ((this: Window, ev: Event) => any) | null;
18449     onvrdisplayfocus: ((this: Window, ev: Event) => any) | null;
18450     onvrdisplaypointerrestricted: ((this: Window, ev: Event) => any) | null;
18451     onvrdisplaypointerunrestricted: ((this: Window, ev: Event) => any) | null;
18452     onvrdisplaypresentchange: ((this: Window, ev: Event) => any) | null;
18453     opener: any;
18454     /** @deprecated */
18455     readonly orientation: string | number;
18456     readonly outerHeight: number;
18457     readonly outerWidth: number;
18458     readonly pageXOffset: number;
18459     readonly pageYOffset: number;
18460     readonly parent: Window;
18461     readonly personalbar: BarProp;
18462     readonly screen: Screen;
18463     readonly screenLeft: number;
18464     readonly screenTop: number;
18465     readonly screenX: number;
18466     readonly screenY: number;
18467     readonly scrollX: number;
18468     readonly scrollY: number;
18469     readonly scrollbars: BarProp;
18470     readonly self: Window & typeof globalThis;
18471     readonly speechSynthesis: SpeechSynthesis;
18472     status: string;
18473     readonly statusbar: BarProp;
18474     readonly styleMedia: StyleMedia;
18475     readonly toolbar: BarProp;
18476     readonly top: Window;
18477     readonly window: Window & typeof globalThis;
18478     alert(message?: any): void;
18479     blur(): void;
18480     /** @deprecated */
18481     captureEvents(): void;
18482     close(): void;
18483     confirm(message?: string): boolean;
18484     departFocus(navigationReason: NavigationReason, origin: FocusNavigationOrigin): void;
18485     focus(): void;
18486     getComputedStyle(elt: Element, pseudoElt?: string | null): CSSStyleDeclaration;
18487     getMatchedCSSRules(elt: Element, pseudoElt?: string | null): CSSRuleList;
18488     getSelection(): Selection | null;
18489     matchMedia(query: string): MediaQueryList;
18490     moveBy(x: number, y: number): void;
18491     moveTo(x: number, y: number): void;
18492     msWriteProfilerMark(profilerMarkName: string): void;
18493     open(url?: string, target?: string, features?: string, replace?: boolean): Window | null;
18494     postMessage(message: any, targetOrigin: string, transfer?: Transferable[]): void;
18495     print(): void;
18496     prompt(message?: string, _default?: string): string | null;
18497     /** @deprecated */
18498     releaseEvents(): void;
18499     resizeBy(x: number, y: number): void;
18500     resizeTo(x: number, y: number): void;
18501     scroll(options?: ScrollToOptions): void;
18502     scroll(x: number, y: number): void;
18503     scrollBy(options?: ScrollToOptions): void;
18504     scrollBy(x: number, y: number): void;
18505     scrollTo(options?: ScrollToOptions): void;
18506     scrollTo(x: number, y: number): void;
18507     stop(): void;
18508     webkitCancelAnimationFrame(handle: number): void;
18509     webkitConvertPointFromNodeToPage(node: Node, pt: WebKitPoint): WebKitPoint;
18510     webkitConvertPointFromPageToNode(node: Node, pt: WebKitPoint): WebKitPoint;
18511     webkitRequestAnimationFrame(callback: FrameRequestCallback): number;
18512     addEventListener<K extends keyof WindowEventMap>(type: K, listener: (this: Window, ev: WindowEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
18513     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
18514     removeEventListener<K extends keyof WindowEventMap>(type: K, listener: (this: Window, ev: WindowEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
18515     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
18516     [index: number]: Window;
18517 }
18518
18519 declare var Window: {
18520     prototype: Window;
18521     new(): Window;
18522 };
18523
18524 interface WindowEventHandlersEventMap {
18525     "afterprint": Event;
18526     "beforeprint": Event;
18527     "beforeunload": BeforeUnloadEvent;
18528     "hashchange": HashChangeEvent;
18529     "languagechange": Event;
18530     "message": MessageEvent;
18531     "messageerror": MessageEvent;
18532     "offline": Event;
18533     "online": Event;
18534     "pagehide": PageTransitionEvent;
18535     "pageshow": PageTransitionEvent;
18536     "popstate": PopStateEvent;
18537     "rejectionhandled": PromiseRejectionEvent;
18538     "storage": StorageEvent;
18539     "unhandledrejection": PromiseRejectionEvent;
18540     "unload": Event;
18541 }
18542
18543 interface WindowEventHandlers {
18544     onafterprint: ((this: WindowEventHandlers, ev: Event) => any) | null;
18545     onbeforeprint: ((this: WindowEventHandlers, ev: Event) => any) | null;
18546     onbeforeunload: ((this: WindowEventHandlers, ev: BeforeUnloadEvent) => any) | null;
18547     onhashchange: ((this: WindowEventHandlers, ev: HashChangeEvent) => any) | null;
18548     onlanguagechange: ((this: WindowEventHandlers, ev: Event) => any) | null;
18549     onmessage: ((this: WindowEventHandlers, ev: MessageEvent) => any) | null;
18550     onmessageerror: ((this: WindowEventHandlers, ev: MessageEvent) => any) | null;
18551     onoffline: ((this: WindowEventHandlers, ev: Event) => any) | null;
18552     ononline: ((this: WindowEventHandlers, ev: Event) => any) | null;
18553     onpagehide: ((this: WindowEventHandlers, ev: PageTransitionEvent) => any) | null;
18554     onpageshow: ((this: WindowEventHandlers, ev: PageTransitionEvent) => any) | null;
18555     onpopstate: ((this: WindowEventHandlers, ev: PopStateEvent) => any) | null;
18556     onrejectionhandled: ((this: WindowEventHandlers, ev: PromiseRejectionEvent) => any) | null;
18557     onstorage: ((this: WindowEventHandlers, ev: StorageEvent) => any) | null;
18558     onunhandledrejection: ((this: WindowEventHandlers, ev: PromiseRejectionEvent) => any) | null;
18559     onunload: ((this: WindowEventHandlers, ev: Event) => any) | null;
18560     addEventListener<K extends keyof WindowEventHandlersEventMap>(type: K, listener: (this: WindowEventHandlers, ev: WindowEventHandlersEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
18561     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
18562     removeEventListener<K extends keyof WindowEventHandlersEventMap>(type: K, listener: (this: WindowEventHandlers, ev: WindowEventHandlersEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
18563     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
18564 }
18565
18566 interface WindowLocalStorage {
18567     readonly localStorage: Storage;
18568 }
18569
18570 interface WindowOrWorkerGlobalScope {
18571     readonly caches: CacheStorage;
18572     readonly crypto: Crypto;
18573     readonly indexedDB: IDBFactory;
18574     readonly isSecureContext: boolean;
18575     readonly origin: string;
18576     readonly performance: Performance;
18577     atob(data: string): string;
18578     btoa(data: string): string;
18579     clearInterval(handle?: number): void;
18580     clearTimeout(handle?: number): void;
18581     createImageBitmap(image: ImageBitmapSource, options?: ImageBitmapOptions): Promise<ImageBitmap>;
18582     createImageBitmap(image: ImageBitmapSource, sx: number, sy: number, sw: number, sh: number, options?: ImageBitmapOptions): Promise<ImageBitmap>;
18583     fetch(input: RequestInfo, init?: RequestInit): Promise<Response>;
18584     queueMicrotask(callback: VoidFunction): void;
18585     setInterval(handler: TimerHandler, timeout?: number, ...arguments: any[]): number;
18586     setTimeout(handler: TimerHandler, timeout?: number, ...arguments: any[]): number;
18587 }
18588
18589 interface WindowSessionStorage {
18590     readonly sessionStorage: Storage;
18591 }
18592
18593 interface WorkerEventMap extends AbstractWorkerEventMap {
18594     "message": MessageEvent;
18595     "messageerror": MessageEvent;
18596 }
18597
18598 /** 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. */
18599 interface Worker extends EventTarget, AbstractWorker {
18600     onmessage: ((this: Worker, ev: MessageEvent) => any) | null;
18601     onmessageerror: ((this: Worker, ev: MessageEvent) => any) | null;
18602     /**
18603      * 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.
18604      */
18605     postMessage(message: any, transfer: Transferable[]): void;
18606     postMessage(message: any, options?: PostMessageOptions): void;
18607     /**
18608      * Aborts worker's associated global environment.
18609      */
18610     terminate(): void;
18611     addEventListener<K extends keyof WorkerEventMap>(type: K, listener: (this: Worker, ev: WorkerEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
18612     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
18613     removeEventListener<K extends keyof WorkerEventMap>(type: K, listener: (this: Worker, ev: WorkerEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
18614     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
18615 }
18616
18617 declare var Worker: {
18618     prototype: Worker;
18619     new(stringUrl: string | URL, options?: WorkerOptions): Worker;
18620 };
18621
18622 interface Worklet {
18623     addModule(moduleURL: string, options?: WorkletOptions): Promise<void>;
18624 }
18625
18626 declare var Worklet: {
18627     prototype: Worklet;
18628     new(): Worklet;
18629 };
18630
18631 /** 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. */
18632 interface WritableStream<W = any> {
18633     readonly locked: boolean;
18634     abort(reason?: any): Promise<void>;
18635     getWriter(): WritableStreamDefaultWriter<W>;
18636 }
18637
18638 declare var WritableStream: {
18639     prototype: WritableStream;
18640     new<W = any>(underlyingSink?: UnderlyingSink<W>, strategy?: QueuingStrategy<W>): WritableStream<W>;
18641 };
18642
18643 /** 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. */
18644 interface WritableStreamDefaultController {
18645     error(error?: any): void;
18646 }
18647
18648 /** 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. */
18649 interface WritableStreamDefaultWriter<W = any> {
18650     readonly closed: Promise<void>;
18651     readonly desiredSize: number | null;
18652     readonly ready: Promise<void>;
18653     abort(reason?: any): Promise<void>;
18654     close(): Promise<void>;
18655     releaseLock(): void;
18656     write(chunk: W): Promise<void>;
18657 }
18658
18659 /** 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. */
18660 interface XMLDocument extends Document {
18661     addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: XMLDocument, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
18662     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
18663     removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: XMLDocument, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
18664     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
18665 }
18666
18667 declare var XMLDocument: {
18668     prototype: XMLDocument;
18669     new(): XMLDocument;
18670 };
18671
18672 interface XMLHttpRequestEventMap extends XMLHttpRequestEventTargetEventMap {
18673     "readystatechange": Event;
18674 }
18675
18676 /** 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. */
18677 interface XMLHttpRequest extends XMLHttpRequestEventTarget {
18678     onreadystatechange: ((this: XMLHttpRequest, ev: Event) => any) | null;
18679     /**
18680      * Returns client's state.
18681      */
18682     readonly readyState: number;
18683     /**
18684      * Returns the response's body.
18685      */
18686     readonly response: any;
18687     /**
18688      * Returns the text response.
18689      *
18690      * Throws an "InvalidStateError" DOMException if responseType is not the empty string or "text".
18691      */
18692     readonly responseText: string;
18693     /**
18694      * Returns the response type.
18695      *
18696      * Can be set to change the response type. Values are: the empty string (default), "arraybuffer", "blob", "document", "json", and "text".
18697      *
18698      * When set: setting to "document" is ignored if current global object is not a Window object.
18699      *
18700      * When set: throws an "InvalidStateError" DOMException if state is loading or done.
18701      *
18702      * When set: throws an "InvalidAccessError" DOMException if the synchronous flag is set and current global object is a Window object.
18703      */
18704     responseType: XMLHttpRequestResponseType;
18705     readonly responseURL: string;
18706     /**
18707      * Returns the document response.
18708      *
18709      * Throws an "InvalidStateError" DOMException if responseType is not the empty string or "document".
18710      */
18711     readonly responseXML: Document | null;
18712     readonly status: number;
18713     readonly statusText: string;
18714     /**
18715      * Can be set to a time in milliseconds. When set to a non-zero value will cause fetching to terminate after the given time has passed. When the time has passed, the request has not yet completed, and the synchronous flag is unset, a timeout event will then be dispatched, or a "TimeoutError" DOMException will be thrown otherwise (for the send() method).
18716      *
18717      * When set: throws an "InvalidAccessError" DOMException if the synchronous flag is set and current global object is a Window object.
18718      */
18719     timeout: number;
18720     /**
18721      * Returns the associated XMLHttpRequestUpload object. It can be used to gather transmission information when data is transferred to a server.
18722      */
18723     readonly upload: XMLHttpRequestUpload;
18724     /**
18725      * 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.
18726      *
18727      * When set: throws an "InvalidStateError" DOMException if state is not unsent or opened, or if the send() flag is set.
18728      */
18729     withCredentials: boolean;
18730     /**
18731      * Cancels any network activity.
18732      */
18733     abort(): void;
18734     getAllResponseHeaders(): string;
18735     getResponseHeader(name: string): string | null;
18736     /**
18737      * Sets the request method, request URL, and synchronous flag.
18738      *
18739      * Throws a "SyntaxError" DOMException if either method is not a valid HTTP method or url cannot be parsed.
18740      *
18741      * Throws a "SecurityError" DOMException if method is a case-insensitive match for `CONNECT`, `TRACE`, or `TRACK`.
18742      *
18743      * 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.
18744      */
18745     open(method: string, url: string): void;
18746     open(method: string, url: string, async: boolean, username?: string | null, password?: string | null): void;
18747     /**
18748      * Acts as if the `Content-Type` header value for response is mime. (It does not actually change the header though.)
18749      *
18750      * Throws an "InvalidStateError" DOMException if state is loading or done.
18751      */
18752     overrideMimeType(mime: string): void;
18753     /**
18754      * Initiates the request. The body argument provides the request body, if any, and is ignored if the request method is GET or HEAD.
18755      *
18756      * Throws an "InvalidStateError" DOMException if either state is not opened or the send() flag is set.
18757      */
18758     send(body?: Document | BodyInit | null): void;
18759     /**
18760      * Combines a header in author request headers.
18761      *
18762      * Throws an "InvalidStateError" DOMException if either state is not opened or the send() flag is set.
18763      *
18764      * Throws a "SyntaxError" DOMException if name is not a header name or if value is not a header value.
18765      */
18766     setRequestHeader(name: string, value: string): void;
18767     readonly DONE: number;
18768     readonly HEADERS_RECEIVED: number;
18769     readonly LOADING: number;
18770     readonly OPENED: number;
18771     readonly UNSENT: number;
18772     addEventListener<K extends keyof XMLHttpRequestEventMap>(type: K, listener: (this: XMLHttpRequest, ev: XMLHttpRequestEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
18773     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
18774     removeEventListener<K extends keyof XMLHttpRequestEventMap>(type: K, listener: (this: XMLHttpRequest, ev: XMLHttpRequestEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
18775     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
18776 }
18777
18778 declare var XMLHttpRequest: {
18779     prototype: XMLHttpRequest;
18780     new(): XMLHttpRequest;
18781     readonly DONE: number;
18782     readonly HEADERS_RECEIVED: number;
18783     readonly LOADING: number;
18784     readonly OPENED: number;
18785     readonly UNSENT: number;
18786 };
18787
18788 interface XMLHttpRequestEventTargetEventMap {
18789     "abort": ProgressEvent<XMLHttpRequestEventTarget>;
18790     "error": ProgressEvent<XMLHttpRequestEventTarget>;
18791     "load": ProgressEvent<XMLHttpRequestEventTarget>;
18792     "loadend": ProgressEvent<XMLHttpRequestEventTarget>;
18793     "loadstart": ProgressEvent<XMLHttpRequestEventTarget>;
18794     "progress": ProgressEvent<XMLHttpRequestEventTarget>;
18795     "timeout": ProgressEvent<XMLHttpRequestEventTarget>;
18796 }
18797
18798 interface XMLHttpRequestEventTarget extends EventTarget {
18799     onabort: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
18800     onerror: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
18801     onload: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
18802     onloadend: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
18803     onloadstart: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
18804     onprogress: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
18805     ontimeout: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
18806     addEventListener<K extends keyof XMLHttpRequestEventTargetEventMap>(type: K, listener: (this: XMLHttpRequestEventTarget, ev: XMLHttpRequestEventTargetEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
18807     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
18808     removeEventListener<K extends keyof XMLHttpRequestEventTargetEventMap>(type: K, listener: (this: XMLHttpRequestEventTarget, ev: XMLHttpRequestEventTargetEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
18809     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
18810 }
18811
18812 declare var XMLHttpRequestEventTarget: {
18813     prototype: XMLHttpRequestEventTarget;
18814     new(): XMLHttpRequestEventTarget;
18815 };
18816
18817 interface XMLHttpRequestUpload extends XMLHttpRequestEventTarget {
18818     addEventListener<K extends keyof XMLHttpRequestEventTargetEventMap>(type: K, listener: (this: XMLHttpRequestUpload, ev: XMLHttpRequestEventTargetEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
18819     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
18820     removeEventListener<K extends keyof XMLHttpRequestEventTargetEventMap>(type: K, listener: (this: XMLHttpRequestUpload, ev: XMLHttpRequestEventTargetEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
18821     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
18822 }
18823
18824 declare var XMLHttpRequestUpload: {
18825     prototype: XMLHttpRequestUpload;
18826     new(): XMLHttpRequestUpload;
18827 };
18828
18829 /** Provides the serializeToString() method to construct an XML string representing a DOM tree. */
18830 interface XMLSerializer {
18831     serializeToString(root: Node): string;
18832 }
18833
18834 declare var XMLSerializer: {
18835     prototype: XMLSerializer;
18836     new(): XMLSerializer;
18837 };
18838
18839 /** The XPathEvaluator interface allows to compile and evaluate XPath expressions. */
18840 interface XPathEvaluator extends XPathEvaluatorBase {
18841 }
18842
18843 declare var XPathEvaluator: {
18844     prototype: XPathEvaluator;
18845     new(): XPathEvaluator;
18846 };
18847
18848 interface XPathEvaluatorBase {
18849     createExpression(expression: string, resolver?: XPathNSResolver | null): XPathExpression;
18850     createNSResolver(nodeResolver: Node): XPathNSResolver;
18851     evaluate(expression: string, contextNode: Node, resolver?: XPathNSResolver | null, type?: number, result?: XPathResult | null): XPathResult;
18852 }
18853
18854 /** This interface is a compiled XPath expression that can be evaluated on a document or specific node to return information its DOM tree. */
18855 interface XPathExpression {
18856     evaluate(contextNode: Node, type?: number, result?: XPathResult | null): XPathResult;
18857 }
18858
18859 declare var XPathExpression: {
18860     prototype: XPathExpression;
18861     new(): XPathExpression;
18862 };
18863
18864 /** The results generated by evaluating an XPath expression within the context of a given node. */
18865 interface XPathResult {
18866     readonly booleanValue: boolean;
18867     readonly invalidIteratorState: boolean;
18868     readonly numberValue: number;
18869     readonly resultType: number;
18870     readonly singleNodeValue: Node | null;
18871     readonly snapshotLength: number;
18872     readonly stringValue: string;
18873     iterateNext(): Node | null;
18874     snapshotItem(index: number): Node | null;
18875     readonly ANY_TYPE: number;
18876     readonly ANY_UNORDERED_NODE_TYPE: number;
18877     readonly BOOLEAN_TYPE: number;
18878     readonly FIRST_ORDERED_NODE_TYPE: number;
18879     readonly NUMBER_TYPE: number;
18880     readonly ORDERED_NODE_ITERATOR_TYPE: number;
18881     readonly ORDERED_NODE_SNAPSHOT_TYPE: number;
18882     readonly STRING_TYPE: number;
18883     readonly UNORDERED_NODE_ITERATOR_TYPE: number;
18884     readonly UNORDERED_NODE_SNAPSHOT_TYPE: number;
18885 }
18886
18887 declare var XPathResult: {
18888     prototype: XPathResult;
18889     new(): XPathResult;
18890     readonly ANY_TYPE: number;
18891     readonly ANY_UNORDERED_NODE_TYPE: number;
18892     readonly BOOLEAN_TYPE: number;
18893     readonly FIRST_ORDERED_NODE_TYPE: number;
18894     readonly NUMBER_TYPE: number;
18895     readonly ORDERED_NODE_ITERATOR_TYPE: number;
18896     readonly ORDERED_NODE_SNAPSHOT_TYPE: number;
18897     readonly STRING_TYPE: number;
18898     readonly UNORDERED_NODE_ITERATOR_TYPE: number;
18899     readonly UNORDERED_NODE_SNAPSHOT_TYPE: number;
18900 };
18901
18902 /** 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. */
18903 interface XSLTProcessor {
18904     clearParameters(): void;
18905     getParameter(namespaceURI: string, localName: string): any;
18906     importStylesheet(style: Node): void;
18907     removeParameter(namespaceURI: string, localName: string): void;
18908     reset(): void;
18909     setParameter(namespaceURI: string, localName: string, value: any): void;
18910     transformToDocument(source: Node): Document;
18911     transformToFragment(source: Node, document: Document): DocumentFragment;
18912 }
18913
18914 declare var XSLTProcessor: {
18915     prototype: XSLTProcessor;
18916     new(): XSLTProcessor;
18917 };
18918
18919 interface webkitRTCPeerConnection extends RTCPeerConnection {
18920     addEventListener<K extends keyof RTCPeerConnectionEventMap>(type: K, listener: (this: webkitRTCPeerConnection, ev: RTCPeerConnectionEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
18921     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
18922     removeEventListener<K extends keyof RTCPeerConnectionEventMap>(type: K, listener: (this: webkitRTCPeerConnection, ev: RTCPeerConnectionEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
18923     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
18924 }
18925
18926 declare var webkitRTCPeerConnection: {
18927     prototype: webkitRTCPeerConnection;
18928     new(configuration: RTCConfiguration): webkitRTCPeerConnection;
18929 };
18930
18931 declare type EventListenerOrEventListenerObject = EventListener | EventListenerObject;
18932
18933 interface Console {
18934     memory: any;
18935     assert(condition?: boolean, ...data: any[]): void;
18936     clear(): void;
18937     count(label?: string): void;
18938     countReset(label?: string): void;
18939     debug(...data: any[]): void;
18940     dir(item?: any, options?: any): void;
18941     dirxml(...data: any[]): void;
18942     error(...data: any[]): void;
18943     exception(message?: string, ...optionalParams: any[]): void;
18944     group(...data: any[]): void;
18945     groupCollapsed(...data: any[]): void;
18946     groupEnd(): void;
18947     info(...data: any[]): void;
18948     log(...data: any[]): void;
18949     table(tabularData?: any, properties?: string[]): void;
18950     time(label?: string): void;
18951     timeEnd(label?: string): void;
18952     timeLog(label?: string, ...data: any[]): void;
18953     timeStamp(label?: string): void;
18954     trace(...data: any[]): void;
18955     warn(...data: any[]): void;
18956 }
18957
18958 declare var console: Console;
18959
18960 /** Holds useful CSS-related methods. No object with this interface are implemented: it contains only static methods and therefore is a utilitarian interface. */
18961 declare namespace CSS {
18962     function escape(ident: string): string;
18963     function supports(property: string, value: string): boolean;
18964     function supports(conditionText: string): boolean;
18965 }
18966
18967 declare namespace WebAssembly {
18968     interface CompileError {
18969     }
18970
18971     var CompileError: {
18972         prototype: CompileError;
18973         new(): CompileError;
18974     };
18975
18976     interface Global {
18977         value: any;
18978         valueOf(): any;
18979     }
18980
18981     var Global: {
18982         prototype: Global;
18983         new(descriptor: GlobalDescriptor, v?: any): Global;
18984     };
18985
18986     interface Instance {
18987         readonly exports: Exports;
18988     }
18989
18990     var Instance: {
18991         prototype: Instance;
18992         new(module: Module, importObject?: Imports): Instance;
18993     };
18994
18995     interface LinkError {
18996     }
18997
18998     var LinkError: {
18999         prototype: LinkError;
19000         new(): LinkError;
19001     };
19002
19003     interface Memory {
19004         readonly buffer: ArrayBuffer;
19005         grow(delta: number): number;
19006     }
19007
19008     var Memory: {
19009         prototype: Memory;
19010         new(descriptor: MemoryDescriptor): Memory;
19011     };
19012
19013     interface Module {
19014     }
19015
19016     var Module: {
19017         prototype: Module;
19018         new(bytes: BufferSource): Module;
19019         customSections(moduleObject: Module, sectionName: string): ArrayBuffer[];
19020         exports(moduleObject: Module): ModuleExportDescriptor[];
19021         imports(moduleObject: Module): ModuleImportDescriptor[];
19022     };
19023
19024     interface RuntimeError {
19025     }
19026
19027     var RuntimeError: {
19028         prototype: RuntimeError;
19029         new(): RuntimeError;
19030     };
19031
19032     interface Table {
19033         readonly length: number;
19034         get(index: number): Function | null;
19035         grow(delta: number): number;
19036         set(index: number, value: Function | null): void;
19037     }
19038
19039     var Table: {
19040         prototype: Table;
19041         new(descriptor: TableDescriptor): Table;
19042     };
19043
19044     interface GlobalDescriptor {
19045         mutable?: boolean;
19046         value: ValueType;
19047     }
19048
19049     interface MemoryDescriptor {
19050         initial: number;
19051         maximum?: number;
19052     }
19053
19054     interface ModuleExportDescriptor {
19055         kind: ImportExportKind;
19056         name: string;
19057     }
19058
19059     interface ModuleImportDescriptor {
19060         kind: ImportExportKind;
19061         module: string;
19062         name: string;
19063     }
19064
19065     interface TableDescriptor {
19066         element: TableKind;
19067         initial: number;
19068         maximum?: number;
19069     }
19070
19071     interface WebAssemblyInstantiatedSource {
19072         instance: Instance;
19073         module: Module;
19074     }
19075
19076     type ImportExportKind = "function" | "global" | "memory" | "table";
19077     type TableKind = "anyfunc";
19078     type ValueType = "f32" | "f64" | "i32" | "i64";
19079     type ExportValue = Function | Global | Memory | Table;
19080     type Exports = Record<string, ExportValue>;
19081     type ImportValue = ExportValue | number;
19082     type ModuleImports = Record<string, ImportValue>;
19083     type Imports = Record<string, ModuleImports>;
19084     function compile(bytes: BufferSource): Promise<Module>;
19085     function compileStreaming(source: Response | Promise<Response>): Promise<Module>;
19086     function instantiate(bytes: BufferSource, importObject?: Imports): Promise<WebAssemblyInstantiatedSource>;
19087     function instantiate(moduleObject: Module, importObject?: Imports): Promise<Instance>;
19088     function instantiateStreaming(response: Response | PromiseLike<Response>, importObject?: Imports): Promise<WebAssemblyInstantiatedSource>;
19089     function validate(bytes: BufferSource): boolean;
19090 }
19091
19092 interface BlobCallback {
19093     (blob: Blob | null): void;
19094 }
19095
19096 interface CustomElementConstructor {
19097     new (...params: any[]): HTMLElement;
19098 }
19099
19100 interface DecodeErrorCallback {
19101     (error: DOMException): void;
19102 }
19103
19104 interface DecodeSuccessCallback {
19105     (decodedData: AudioBuffer): void;
19106 }
19107
19108 interface EventHandlerNonNull {
19109     (event: Event): any;
19110 }
19111
19112 interface ForEachCallback {
19113     (keyId: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer | null, status: MediaKeyStatus): void;
19114 }
19115
19116 interface FrameRequestCallback {
19117     (time: number): void;
19118 }
19119
19120 interface FunctionStringCallback {
19121     (data: string): void;
19122 }
19123
19124 interface IntersectionObserverCallback {
19125     (entries: IntersectionObserverEntry[], observer: IntersectionObserver): void;
19126 }
19127
19128 interface MSLaunchUriCallback {
19129     (): void;
19130 }
19131
19132 interface MutationCallback {
19133     (mutations: MutationRecord[], observer: MutationObserver): void;
19134 }
19135
19136 interface NavigatorUserMediaErrorCallback {
19137     (error: MediaStreamError): void;
19138 }
19139
19140 interface NavigatorUserMediaSuccessCallback {
19141     (stream: MediaStream): void;
19142 }
19143
19144 interface NotificationPermissionCallback {
19145     (permission: NotificationPermission): void;
19146 }
19147
19148 interface OnBeforeUnloadEventHandlerNonNull {
19149     (event: Event): string | null;
19150 }
19151
19152 interface OnErrorEventHandlerNonNull {
19153     (event: Event | string, source?: string, lineno?: number, colno?: number, error?: Error): any;
19154 }
19155
19156 interface PerformanceObserverCallback {
19157     (entries: PerformanceObserverEntryList, observer: PerformanceObserver): void;
19158 }
19159
19160 interface PositionCallback {
19161     (position: Position): void;
19162 }
19163
19164 interface PositionErrorCallback {
19165     (positionError: PositionError): void;
19166 }
19167
19168 interface QueuingStrategySizeCallback<T = any> {
19169     (chunk: T): number;
19170 }
19171
19172 interface RTCPeerConnectionErrorCallback {
19173     (error: DOMException): void;
19174 }
19175
19176 interface RTCSessionDescriptionCallback {
19177     (description: RTCSessionDescriptionInit): void;
19178 }
19179
19180 interface RTCStatsCallback {
19181     (report: RTCStatsReport): void;
19182 }
19183
19184 interface ReadableByteStreamControllerCallback {
19185     (controller: ReadableByteStreamController): void | PromiseLike<void>;
19186 }
19187
19188 interface ReadableStreamDefaultControllerCallback<R> {
19189     (controller: ReadableStreamDefaultController<R>): void | PromiseLike<void>;
19190 }
19191
19192 interface ReadableStreamErrorCallback {
19193     (reason: any): void | PromiseLike<void>;
19194 }
19195
19196 interface TransformStreamDefaultControllerCallback<O> {
19197     (controller: TransformStreamDefaultController<O>): void | PromiseLike<void>;
19198 }
19199
19200 interface TransformStreamDefaultControllerTransformCallback<I, O> {
19201     (chunk: I, controller: TransformStreamDefaultController<O>): void | PromiseLike<void>;
19202 }
19203
19204 interface VoidFunction {
19205     (): void;
19206 }
19207
19208 interface WritableStreamDefaultControllerCloseCallback {
19209     (): void | PromiseLike<void>;
19210 }
19211
19212 interface WritableStreamDefaultControllerStartCallback {
19213     (controller: WritableStreamDefaultController): void | PromiseLike<void>;
19214 }
19215
19216 interface WritableStreamDefaultControllerWriteCallback<W> {
19217     (chunk: W, controller: WritableStreamDefaultController): void | PromiseLike<void>;
19218 }
19219
19220 interface WritableStreamErrorCallback {
19221     (reason: any): void | PromiseLike<void>;
19222 }
19223
19224 interface HTMLElementTagNameMap {
19225     "a": HTMLAnchorElement;
19226     "abbr": HTMLElement;
19227     "address": HTMLElement;
19228     "applet": HTMLAppletElement;
19229     "area": HTMLAreaElement;
19230     "article": HTMLElement;
19231     "aside": HTMLElement;
19232     "audio": HTMLAudioElement;
19233     "b": HTMLElement;
19234     "base": HTMLBaseElement;
19235     "basefont": HTMLBaseFontElement;
19236     "bdi": HTMLElement;
19237     "bdo": HTMLElement;
19238     "blockquote": HTMLQuoteElement;
19239     "body": HTMLBodyElement;
19240     "br": HTMLBRElement;
19241     "button": HTMLButtonElement;
19242     "canvas": HTMLCanvasElement;
19243     "caption": HTMLTableCaptionElement;
19244     "cite": HTMLElement;
19245     "code": HTMLElement;
19246     "col": HTMLTableColElement;
19247     "colgroup": HTMLTableColElement;
19248     "data": HTMLDataElement;
19249     "datalist": HTMLDataListElement;
19250     "dd": HTMLElement;
19251     "del": HTMLModElement;
19252     "details": HTMLDetailsElement;
19253     "dfn": HTMLElement;
19254     "dialog": HTMLDialogElement;
19255     "dir": HTMLDirectoryElement;
19256     "div": HTMLDivElement;
19257     "dl": HTMLDListElement;
19258     "dt": HTMLElement;
19259     "em": HTMLElement;
19260     "embed": HTMLEmbedElement;
19261     "fieldset": HTMLFieldSetElement;
19262     "figcaption": HTMLElement;
19263     "figure": HTMLElement;
19264     "font": HTMLFontElement;
19265     "footer": HTMLElement;
19266     "form": HTMLFormElement;
19267     "frame": HTMLFrameElement;
19268     "frameset": HTMLFrameSetElement;
19269     "h1": HTMLHeadingElement;
19270     "h2": HTMLHeadingElement;
19271     "h3": HTMLHeadingElement;
19272     "h4": HTMLHeadingElement;
19273     "h5": HTMLHeadingElement;
19274     "h6": HTMLHeadingElement;
19275     "head": HTMLHeadElement;
19276     "header": HTMLElement;
19277     "hgroup": HTMLElement;
19278     "hr": HTMLHRElement;
19279     "html": HTMLHtmlElement;
19280     "i": HTMLElement;
19281     "iframe": HTMLIFrameElement;
19282     "img": HTMLImageElement;
19283     "input": HTMLInputElement;
19284     "ins": HTMLModElement;
19285     "kbd": HTMLElement;
19286     "label": HTMLLabelElement;
19287     "legend": HTMLLegendElement;
19288     "li": HTMLLIElement;
19289     "link": HTMLLinkElement;
19290     "main": HTMLElement;
19291     "map": HTMLMapElement;
19292     "mark": HTMLElement;
19293     "marquee": HTMLMarqueeElement;
19294     "menu": HTMLMenuElement;
19295     "meta": HTMLMetaElement;
19296     "meter": HTMLMeterElement;
19297     "nav": HTMLElement;
19298     "noscript": HTMLElement;
19299     "object": HTMLObjectElement;
19300     "ol": HTMLOListElement;
19301     "optgroup": HTMLOptGroupElement;
19302     "option": HTMLOptionElement;
19303     "output": HTMLOutputElement;
19304     "p": HTMLParagraphElement;
19305     "param": HTMLParamElement;
19306     "picture": HTMLPictureElement;
19307     "pre": HTMLPreElement;
19308     "progress": HTMLProgressElement;
19309     "q": HTMLQuoteElement;
19310     "rp": HTMLElement;
19311     "rt": HTMLElement;
19312     "ruby": HTMLElement;
19313     "s": HTMLElement;
19314     "samp": HTMLElement;
19315     "script": HTMLScriptElement;
19316     "section": HTMLElement;
19317     "select": HTMLSelectElement;
19318     "slot": HTMLSlotElement;
19319     "small": HTMLElement;
19320     "source": HTMLSourceElement;
19321     "span": HTMLSpanElement;
19322     "strong": HTMLElement;
19323     "style": HTMLStyleElement;
19324     "sub": HTMLElement;
19325     "summary": HTMLElement;
19326     "sup": HTMLElement;
19327     "table": HTMLTableElement;
19328     "tbody": HTMLTableSectionElement;
19329     "td": HTMLTableDataCellElement;
19330     "template": HTMLTemplateElement;
19331     "textarea": HTMLTextAreaElement;
19332     "tfoot": HTMLTableSectionElement;
19333     "th": HTMLTableHeaderCellElement;
19334     "thead": HTMLTableSectionElement;
19335     "time": HTMLTimeElement;
19336     "title": HTMLTitleElement;
19337     "tr": HTMLTableRowElement;
19338     "track": HTMLTrackElement;
19339     "u": HTMLElement;
19340     "ul": HTMLUListElement;
19341     "var": HTMLElement;
19342     "video": HTMLVideoElement;
19343     "wbr": HTMLElement;
19344 }
19345
19346 interface HTMLElementDeprecatedTagNameMap {
19347     "listing": HTMLPreElement;
19348     "xmp": HTMLPreElement;
19349 }
19350
19351 interface SVGElementTagNameMap {
19352     "a": SVGAElement;
19353     "circle": SVGCircleElement;
19354     "clipPath": SVGClipPathElement;
19355     "defs": SVGDefsElement;
19356     "desc": SVGDescElement;
19357     "ellipse": SVGEllipseElement;
19358     "feBlend": SVGFEBlendElement;
19359     "feColorMatrix": SVGFEColorMatrixElement;
19360     "feComponentTransfer": SVGFEComponentTransferElement;
19361     "feComposite": SVGFECompositeElement;
19362     "feConvolveMatrix": SVGFEConvolveMatrixElement;
19363     "feDiffuseLighting": SVGFEDiffuseLightingElement;
19364     "feDisplacementMap": SVGFEDisplacementMapElement;
19365     "feDistantLight": SVGFEDistantLightElement;
19366     "feFlood": SVGFEFloodElement;
19367     "feFuncA": SVGFEFuncAElement;
19368     "feFuncB": SVGFEFuncBElement;
19369     "feFuncG": SVGFEFuncGElement;
19370     "feFuncR": SVGFEFuncRElement;
19371     "feGaussianBlur": SVGFEGaussianBlurElement;
19372     "feImage": SVGFEImageElement;
19373     "feMerge": SVGFEMergeElement;
19374     "feMergeNode": SVGFEMergeNodeElement;
19375     "feMorphology": SVGFEMorphologyElement;
19376     "feOffset": SVGFEOffsetElement;
19377     "fePointLight": SVGFEPointLightElement;
19378     "feSpecularLighting": SVGFESpecularLightingElement;
19379     "feSpotLight": SVGFESpotLightElement;
19380     "feTile": SVGFETileElement;
19381     "feTurbulence": SVGFETurbulenceElement;
19382     "filter": SVGFilterElement;
19383     "foreignObject": SVGForeignObjectElement;
19384     "g": SVGGElement;
19385     "image": SVGImageElement;
19386     "line": SVGLineElement;
19387     "linearGradient": SVGLinearGradientElement;
19388     "marker": SVGMarkerElement;
19389     "mask": SVGMaskElement;
19390     "metadata": SVGMetadataElement;
19391     "path": SVGPathElement;
19392     "pattern": SVGPatternElement;
19393     "polygon": SVGPolygonElement;
19394     "polyline": SVGPolylineElement;
19395     "radialGradient": SVGRadialGradientElement;
19396     "rect": SVGRectElement;
19397     "script": SVGScriptElement;
19398     "stop": SVGStopElement;
19399     "style": SVGStyleElement;
19400     "svg": SVGSVGElement;
19401     "switch": SVGSwitchElement;
19402     "symbol": SVGSymbolElement;
19403     "text": SVGTextElement;
19404     "textPath": SVGTextPathElement;
19405     "title": SVGTitleElement;
19406     "tspan": SVGTSpanElement;
19407     "use": SVGUseElement;
19408     "view": SVGViewElement;
19409 }
19410
19411 /** @deprecated Directly use HTMLElementTagNameMap or SVGElementTagNameMap as appropriate, instead. */
19412 type ElementTagNameMap = HTMLElementTagNameMap & Pick<SVGElementTagNameMap, Exclude<keyof SVGElementTagNameMap, keyof HTMLElementTagNameMap>>;
19413
19414 declare var Audio: {
19415     new(src?: string): HTMLAudioElement;
19416 };
19417 declare var Image: {
19418     new(width?: number, height?: number): HTMLImageElement;
19419 };
19420 declare var Option: {
19421     new(text?: string, value?: string, defaultSelected?: boolean, selected?: boolean): HTMLOptionElement;
19422 };
19423 declare var applicationCache: ApplicationCache;
19424 declare var clientInformation: Navigator;
19425 declare var closed: boolean;
19426 declare var customElements: CustomElementRegistry;
19427 declare var defaultStatus: string;
19428 declare var devicePixelRatio: number;
19429 declare var doNotTrack: string;
19430 declare var document: Document;
19431 /** @deprecated */
19432 declare var event: Event | undefined;
19433 /** @deprecated */
19434 declare var external: External;
19435 declare var frameElement: Element;
19436 declare var frames: Window;
19437 declare var history: History;
19438 declare var innerHeight: number;
19439 declare var innerWidth: number;
19440 declare var length: number;
19441 declare var location: Location;
19442 declare var locationbar: BarProp;
19443 declare var menubar: BarProp;
19444 declare var msContentScript: ExtensionScriptApis;
19445 declare const name: never;
19446 declare var navigator: Navigator;
19447 declare var offscreenBuffering: string | boolean;
19448 declare var oncompassneedscalibration: ((this: Window, ev: Event) => any) | null;
19449 declare var ondevicelight: ((this: Window, ev: DeviceLightEvent) => any) | null;
19450 declare var ondevicemotion: ((this: Window, ev: DeviceMotionEvent) => any) | null;
19451 declare var ondeviceorientation: ((this: Window, ev: DeviceOrientationEvent) => any) | null;
19452 declare var ondeviceorientationabsolute: ((this: Window, ev: DeviceOrientationEvent) => any) | null;
19453 declare var onmousewheel: ((this: Window, ev: Event) => any) | null;
19454 declare var onmsgesturechange: ((this: Window, ev: Event) => any) | null;
19455 declare var onmsgesturedoubletap: ((this: Window, ev: Event) => any) | null;
19456 declare var onmsgestureend: ((this: Window, ev: Event) => any) | null;
19457 declare var onmsgesturehold: ((this: Window, ev: Event) => any) | null;
19458 declare var onmsgesturestart: ((this: Window, ev: Event) => any) | null;
19459 declare var onmsgesturetap: ((this: Window, ev: Event) => any) | null;
19460 declare var onmsinertiastart: ((this: Window, ev: Event) => any) | null;
19461 declare var onmspointercancel: ((this: Window, ev: Event) => any) | null;
19462 declare var onmspointerdown: ((this: Window, ev: Event) => any) | null;
19463 declare var onmspointerenter: ((this: Window, ev: Event) => any) | null;
19464 declare var onmspointerleave: ((this: Window, ev: Event) => any) | null;
19465 declare var onmspointermove: ((this: Window, ev: Event) => any) | null;
19466 declare var onmspointerout: ((this: Window, ev: Event) => any) | null;
19467 declare var onmspointerover: ((this: Window, ev: Event) => any) | null;
19468 declare var onmspointerup: ((this: Window, ev: Event) => any) | null;
19469 /** @deprecated */
19470 declare var onorientationchange: ((this: Window, ev: Event) => any) | null;
19471 declare var onreadystatechange: ((this: Window, ev: ProgressEvent<Window>) => any) | null;
19472 declare var onvrdisplayactivate: ((this: Window, ev: Event) => any) | null;
19473 declare var onvrdisplayblur: ((this: Window, ev: Event) => any) | null;
19474 declare var onvrdisplayconnect: ((this: Window, ev: Event) => any) | null;
19475 declare var onvrdisplaydeactivate: ((this: Window, ev: Event) => any) | null;
19476 declare var onvrdisplaydisconnect: ((this: Window, ev: Event) => any) | null;
19477 declare var onvrdisplayfocus: ((this: Window, ev: Event) => any) | null;
19478 declare var onvrdisplaypointerrestricted: ((this: Window, ev: Event) => any) | null;
19479 declare var onvrdisplaypointerunrestricted: ((this: Window, ev: Event) => any) | null;
19480 declare var onvrdisplaypresentchange: ((this: Window, ev: Event) => any) | null;
19481 declare var opener: any;
19482 /** @deprecated */
19483 declare var orientation: string | number;
19484 declare var outerHeight: number;
19485 declare var outerWidth: number;
19486 declare var pageXOffset: number;
19487 declare var pageYOffset: number;
19488 declare var parent: Window;
19489 declare var personalbar: BarProp;
19490 declare var screen: Screen;
19491 declare var screenLeft: number;
19492 declare var screenTop: number;
19493 declare var screenX: number;
19494 declare var screenY: number;
19495 declare var scrollX: number;
19496 declare var scrollY: number;
19497 declare var scrollbars: BarProp;
19498 declare var self: Window & typeof globalThis;
19499 declare var speechSynthesis: SpeechSynthesis;
19500 declare var status: string;
19501 declare var statusbar: BarProp;
19502 declare var styleMedia: StyleMedia;
19503 declare var toolbar: BarProp;
19504 declare var top: Window;
19505 declare var window: Window & typeof globalThis;
19506 declare function alert(message?: any): void;
19507 declare function blur(): void;
19508 /** @deprecated */
19509 declare function captureEvents(): void;
19510 declare function close(): void;
19511 declare function confirm(message?: string): boolean;
19512 declare function departFocus(navigationReason: NavigationReason, origin: FocusNavigationOrigin): void;
19513 declare function focus(): void;
19514 declare function getComputedStyle(elt: Element, pseudoElt?: string | null): CSSStyleDeclaration;
19515 declare function getMatchedCSSRules(elt: Element, pseudoElt?: string | null): CSSRuleList;
19516 declare function getSelection(): Selection | null;
19517 declare function matchMedia(query: string): MediaQueryList;
19518 declare function moveBy(x: number, y: number): void;
19519 declare function moveTo(x: number, y: number): void;
19520 declare function msWriteProfilerMark(profilerMarkName: string): void;
19521 declare function open(url?: string, target?: string, features?: string, replace?: boolean): Window | null;
19522 declare function postMessage(message: any, targetOrigin: string, transfer?: Transferable[]): void;
19523 declare function print(): void;
19524 declare function prompt(message?: string, _default?: string): string | null;
19525 /** @deprecated */
19526 declare function releaseEvents(): void;
19527 declare function resizeBy(x: number, y: number): void;
19528 declare function resizeTo(x: number, y: number): void;
19529 declare function scroll(options?: ScrollToOptions): void;
19530 declare function scroll(x: number, y: number): void;
19531 declare function scrollBy(options?: ScrollToOptions): void;
19532 declare function scrollBy(x: number, y: number): void;
19533 declare function scrollTo(options?: ScrollToOptions): void;
19534 declare function scrollTo(x: number, y: number): void;
19535 declare function stop(): void;
19536 declare function webkitCancelAnimationFrame(handle: number): void;
19537 declare function webkitConvertPointFromNodeToPage(node: Node, pt: WebKitPoint): WebKitPoint;
19538 declare function webkitConvertPointFromPageToNode(node: Node, pt: WebKitPoint): WebKitPoint;
19539 declare function webkitRequestAnimationFrame(callback: FrameRequestCallback): number;
19540 declare function toString(): string;
19541 /**
19542  * 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.
19543  */
19544 declare function dispatchEvent(event: Event): boolean;
19545 declare var sessionStorage: Storage;
19546 declare var localStorage: Storage;
19547 /**
19548  * Fires when the user aborts the download.
19549  * @param ev The event.
19550  */
19551 declare var onabort: ((this: Window, ev: UIEvent) => any) | null;
19552 declare var onanimationcancel: ((this: Window, ev: AnimationEvent) => any) | null;
19553 declare var onanimationend: ((this: Window, ev: AnimationEvent) => any) | null;
19554 declare var onanimationiteration: ((this: Window, ev: AnimationEvent) => any) | null;
19555 declare var onanimationstart: ((this: Window, ev: AnimationEvent) => any) | null;
19556 declare var onauxclick: ((this: Window, ev: MouseEvent) => any) | null;
19557 /**
19558  * Fires when the object loses the input focus.
19559  * @param ev The focus event.
19560  */
19561 declare var onblur: ((this: Window, ev: FocusEvent) => any) | null;
19562 declare var oncancel: ((this: Window, ev: Event) => any) | null;
19563 /**
19564  * Occurs when playback is possible, but would require further buffering.
19565  * @param ev The event.
19566  */
19567 declare var oncanplay: ((this: Window, ev: Event) => any) | null;
19568 declare var oncanplaythrough: ((this: Window, ev: Event) => any) | null;
19569 /**
19570  * Fires when the contents of the object or selection have changed.
19571  * @param ev The event.
19572  */
19573 declare var onchange: ((this: Window, ev: Event) => any) | null;
19574 /**
19575  * Fires when the user clicks the left mouse button on the object
19576  * @param ev The mouse event.
19577  */
19578 declare var onclick: ((this: Window, ev: MouseEvent) => any) | null;
19579 declare var onclose: ((this: Window, ev: Event) => any) | null;
19580 /**
19581  * Fires when the user clicks the right mouse button in the client area, opening the context menu.
19582  * @param ev The mouse event.
19583  */
19584 declare var oncontextmenu: ((this: Window, ev: MouseEvent) => any) | null;
19585 declare var oncuechange: ((this: Window, ev: Event) => any) | null;
19586 /**
19587  * Fires when the user double-clicks the object.
19588  * @param ev The mouse event.
19589  */
19590 declare var ondblclick: ((this: Window, ev: MouseEvent) => any) | null;
19591 /**
19592  * Fires on the source object continuously during a drag operation.
19593  * @param ev The event.
19594  */
19595 declare var ondrag: ((this: Window, ev: DragEvent) => any) | null;
19596 /**
19597  * Fires on the source object when the user releases the mouse at the close of a drag operation.
19598  * @param ev The event.
19599  */
19600 declare var ondragend: ((this: Window, ev: DragEvent) => any) | null;
19601 /**
19602  * Fires on the target element when the user drags the object to a valid drop target.
19603  * @param ev The drag event.
19604  */
19605 declare var ondragenter: ((this: Window, ev: DragEvent) => any) | null;
19606 declare var ondragexit: ((this: Window, ev: Event) => any) | null;
19607 /**
19608  * Fires on the target object when the user moves the mouse out of a valid drop target during a drag operation.
19609  * @param ev The drag event.
19610  */
19611 declare var ondragleave: ((this: Window, ev: DragEvent) => any) | null;
19612 /**
19613  * Fires on the target element continuously while the user drags the object over a valid drop target.
19614  * @param ev The event.
19615  */
19616 declare var ondragover: ((this: Window, ev: DragEvent) => any) | null;
19617 /**
19618  * Fires on the source object when the user starts to drag a text selection or selected object.
19619  * @param ev The event.
19620  */
19621 declare var ondragstart: ((this: Window, ev: DragEvent) => any) | null;
19622 declare var ondrop: ((this: Window, ev: DragEvent) => any) | null;
19623 /**
19624  * Occurs when the duration attribute is updated.
19625  * @param ev The event.
19626  */
19627 declare var ondurationchange: ((this: Window, ev: Event) => any) | null;
19628 /**
19629  * Occurs when the media element is reset to its initial state.
19630  * @param ev The event.
19631  */
19632 declare var onemptied: ((this: Window, ev: Event) => any) | null;
19633 /**
19634  * Occurs when the end of playback is reached.
19635  * @param ev The event
19636  */
19637 declare var onended: ((this: Window, ev: Event) => any) | null;
19638 /**
19639  * Fires when an error occurs during object loading.
19640  * @param ev The event.
19641  */
19642 declare var onerror: OnErrorEventHandler;
19643 /**
19644  * Fires when the object receives focus.
19645  * @param ev The event.
19646  */
19647 declare var onfocus: ((this: Window, ev: FocusEvent) => any) | null;
19648 declare var ongotpointercapture: ((this: Window, ev: PointerEvent) => any) | null;
19649 declare var oninput: ((this: Window, ev: Event) => any) | null;
19650 declare var oninvalid: ((this: Window, ev: Event) => any) | null;
19651 /**
19652  * Fires when the user presses a key.
19653  * @param ev The keyboard event
19654  */
19655 declare var onkeydown: ((this: Window, ev: KeyboardEvent) => any) | null;
19656 /**
19657  * Fires when the user presses an alphanumeric key.
19658  * @param ev The event.
19659  */
19660 declare var onkeypress: ((this: Window, ev: KeyboardEvent) => any) | null;
19661 /**
19662  * Fires when the user releases a key.
19663  * @param ev The keyboard event
19664  */
19665 declare var onkeyup: ((this: Window, ev: KeyboardEvent) => any) | null;
19666 /**
19667  * Fires immediately after the browser loads the object.
19668  * @param ev The event.
19669  */
19670 declare var onload: ((this: Window, ev: Event) => any) | null;
19671 /**
19672  * Occurs when media data is loaded at the current playback position.
19673  * @param ev The event.
19674  */
19675 declare var onloadeddata: ((this: Window, ev: Event) => any) | null;
19676 /**
19677  * Occurs when the duration and dimensions of the media have been determined.
19678  * @param ev The event.
19679  */
19680 declare var onloadedmetadata: ((this: Window, ev: Event) => any) | null;
19681 /**
19682  * Occurs when Internet Explorer begins looking for media data.
19683  * @param ev The event.
19684  */
19685 declare var onloadstart: ((this: Window, ev: Event) => any) | null;
19686 declare var onlostpointercapture: ((this: Window, ev: PointerEvent) => any) | null;
19687 /**
19688  * Fires when the user clicks the object with either mouse button.
19689  * @param ev The mouse event.
19690  */
19691 declare var onmousedown: ((this: Window, ev: MouseEvent) => any) | null;
19692 declare var onmouseenter: ((this: Window, ev: MouseEvent) => any) | null;
19693 declare var onmouseleave: ((this: Window, ev: MouseEvent) => any) | null;
19694 /**
19695  * Fires when the user moves the mouse over the object.
19696  * @param ev The mouse event.
19697  */
19698 declare var onmousemove: ((this: Window, ev: MouseEvent) => any) | null;
19699 /**
19700  * Fires when the user moves the mouse pointer outside the boundaries of the object.
19701  * @param ev The mouse event.
19702  */
19703 declare var onmouseout: ((this: Window, ev: MouseEvent) => any) | null;
19704 /**
19705  * Fires when the user moves the mouse pointer into the object.
19706  * @param ev The mouse event.
19707  */
19708 declare var onmouseover: ((this: Window, ev: MouseEvent) => any) | null;
19709 /**
19710  * Fires when the user releases a mouse button while the mouse is over the object.
19711  * @param ev The mouse event.
19712  */
19713 declare var onmouseup: ((this: Window, ev: MouseEvent) => any) | null;
19714 /**
19715  * Occurs when playback is paused.
19716  * @param ev The event.
19717  */
19718 declare var onpause: ((this: Window, ev: Event) => any) | null;
19719 /**
19720  * Occurs when the play method is requested.
19721  * @param ev The event.
19722  */
19723 declare var onplay: ((this: Window, ev: Event) => any) | null;
19724 /**
19725  * Occurs when the audio or video has started playing.
19726  * @param ev The event.
19727  */
19728 declare var onplaying: ((this: Window, ev: Event) => any) | null;
19729 declare var onpointercancel: ((this: Window, ev: PointerEvent) => any) | null;
19730 declare var onpointerdown: ((this: Window, ev: PointerEvent) => any) | null;
19731 declare var onpointerenter: ((this: Window, ev: PointerEvent) => any) | null;
19732 declare var onpointerleave: ((this: Window, ev: PointerEvent) => any) | null;
19733 declare var onpointermove: ((this: Window, ev: PointerEvent) => any) | null;
19734 declare var onpointerout: ((this: Window, ev: PointerEvent) => any) | null;
19735 declare var onpointerover: ((this: Window, ev: PointerEvent) => any) | null;
19736 declare var onpointerup: ((this: Window, ev: PointerEvent) => any) | null;
19737 /**
19738  * Occurs to indicate progress while downloading media data.
19739  * @param ev The event.
19740  */
19741 declare var onprogress: ((this: Window, ev: ProgressEvent) => any) | null;
19742 /**
19743  * Occurs when the playback rate is increased or decreased.
19744  * @param ev The event.
19745  */
19746 declare var onratechange: ((this: Window, ev: Event) => any) | null;
19747 /**
19748  * Fires when the user resets a form.
19749  * @param ev The event.
19750  */
19751 declare var onreset: ((this: Window, ev: Event) => any) | null;
19752 declare var onresize: ((this: Window, ev: UIEvent) => any) | null;
19753 /**
19754  * Fires when the user repositions the scroll box in the scroll bar on the object.
19755  * @param ev The event.
19756  */
19757 declare var onscroll: ((this: Window, ev: Event) => any) | null;
19758 declare var onsecuritypolicyviolation: ((this: Window, ev: SecurityPolicyViolationEvent) => any) | null;
19759 /**
19760  * Occurs when the seek operation ends.
19761  * @param ev The event.
19762  */
19763 declare var onseeked: ((this: Window, ev: Event) => any) | null;
19764 /**
19765  * Occurs when the current playback position is moved.
19766  * @param ev The event.
19767  */
19768 declare var onseeking: ((this: Window, ev: Event) => any) | null;
19769 /**
19770  * Fires when the current selection changes.
19771  * @param ev The event.
19772  */
19773 declare var onselect: ((this: Window, ev: Event) => any) | null;
19774 declare var onselectionchange: ((this: Window, ev: Event) => any) | null;
19775 declare var onselectstart: ((this: Window, ev: Event) => any) | null;
19776 /**
19777  * Occurs when the download has stopped.
19778  * @param ev The event.
19779  */
19780 declare var onstalled: ((this: Window, ev: Event) => any) | null;
19781 declare var onsubmit: ((this: Window, ev: Event) => any) | null;
19782 /**
19783  * Occurs if the load operation has been intentionally halted.
19784  * @param ev The event.
19785  */
19786 declare var onsuspend: ((this: Window, ev: Event) => any) | null;
19787 /**
19788  * Occurs to indicate the current playback position.
19789  * @param ev The event.
19790  */
19791 declare var ontimeupdate: ((this: Window, ev: Event) => any) | null;
19792 declare var ontoggle: ((this: Window, ev: Event) => any) | null;
19793 declare var ontouchcancel: ((this: Window, ev: TouchEvent) => any) | null | undefined;
19794 declare var ontouchend: ((this: Window, ev: TouchEvent) => any) | null | undefined;
19795 declare var ontouchmove: ((this: Window, ev: TouchEvent) => any) | null | undefined;
19796 declare var ontouchstart: ((this: Window, ev: TouchEvent) => any) | null | undefined;
19797 declare var ontransitioncancel: ((this: Window, ev: TransitionEvent) => any) | null;
19798 declare var ontransitionend: ((this: Window, ev: TransitionEvent) => any) | null;
19799 declare var ontransitionrun: ((this: Window, ev: TransitionEvent) => any) | null;
19800 declare var ontransitionstart: ((this: Window, ev: TransitionEvent) => any) | null;
19801 /**
19802  * Occurs when the volume is changed, or playback is muted or unmuted.
19803  * @param ev The event.
19804  */
19805 declare var onvolumechange: ((this: Window, ev: Event) => any) | null;
19806 /**
19807  * Occurs when playback stops because the next frame of a video resource is not available.
19808  * @param ev The event.
19809  */
19810 declare var onwaiting: ((this: Window, ev: Event) => any) | null;
19811 declare var onwheel: ((this: Window, ev: WheelEvent) => any) | null;
19812 declare function cancelAnimationFrame(handle: number): void;
19813 declare function requestAnimationFrame(callback: FrameRequestCallback): number;
19814 declare var caches: CacheStorage;
19815 declare var crypto: Crypto;
19816 declare var indexedDB: IDBFactory;
19817 declare var isSecureContext: boolean;
19818 declare var origin: string;
19819 declare var performance: Performance;
19820 declare function atob(data: string): string;
19821 declare function btoa(data: string): string;
19822 declare function clearInterval(handle?: number): void;
19823 declare function clearTimeout(handle?: number): void;
19824 declare function createImageBitmap(image: ImageBitmapSource, options?: ImageBitmapOptions): Promise<ImageBitmap>;
19825 declare function createImageBitmap(image: ImageBitmapSource, sx: number, sy: number, sw: number, sh: number, options?: ImageBitmapOptions): Promise<ImageBitmap>;
19826 declare function fetch(input: RequestInfo, init?: RequestInit): Promise<Response>;
19827 declare function queueMicrotask(callback: VoidFunction): void;
19828 declare function setInterval(handler: TimerHandler, timeout?: number, ...arguments: any[]): number;
19829 declare function setTimeout(handler: TimerHandler, timeout?: number, ...arguments: any[]): number;
19830 declare var onafterprint: ((this: Window, ev: Event) => any) | null;
19831 declare var onbeforeprint: ((this: Window, ev: Event) => any) | null;
19832 declare var onbeforeunload: ((this: Window, ev: BeforeUnloadEvent) => any) | null;
19833 declare var onhashchange: ((this: Window, ev: HashChangeEvent) => any) | null;
19834 declare var onlanguagechange: ((this: Window, ev: Event) => any) | null;
19835 declare var onmessage: ((this: Window, ev: MessageEvent) => any) | null;
19836 declare var onmessageerror: ((this: Window, ev: MessageEvent) => any) | null;
19837 declare var onoffline: ((this: Window, ev: Event) => any) | null;
19838 declare var ononline: ((this: Window, ev: Event) => any) | null;
19839 declare var onpagehide: ((this: Window, ev: PageTransitionEvent) => any) | null;
19840 declare var onpageshow: ((this: Window, ev: PageTransitionEvent) => any) | null;
19841 declare var onpopstate: ((this: Window, ev: PopStateEvent) => any) | null;
19842 declare var onrejectionhandled: ((this: Window, ev: PromiseRejectionEvent) => any) | null;
19843 declare var onstorage: ((this: Window, ev: StorageEvent) => any) | null;
19844 declare var onunhandledrejection: ((this: Window, ev: PromiseRejectionEvent) => any) | null;
19845 declare var onunload: ((this: Window, ev: Event) => any) | null;
19846 declare function addEventListener<K extends keyof WindowEventMap>(type: K, listener: (this: Window, ev: WindowEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
19847 declare function addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
19848 declare function removeEventListener<K extends keyof WindowEventMap>(type: K, listener: (this: Window, ev: WindowEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
19849 declare function removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
19850 type HeadersInit = Headers | string[][] | Record<string, string>;
19851 type BodyInit = Blob | BufferSource | FormData | URLSearchParams | ReadableStream<Uint8Array> | string;
19852 type RequestInfo = Request | string;
19853 type BlobPart = BufferSource | Blob | string;
19854 type DOMHighResTimeStamp = number;
19855 type RenderingContext = CanvasRenderingContext2D | ImageBitmapRenderingContext | WebGLRenderingContext | WebGL2RenderingContext;
19856 type HTMLOrSVGImageElement = HTMLImageElement | SVGImageElement;
19857 type CanvasImageSource = HTMLOrSVGImageElement | HTMLVideoElement | HTMLCanvasElement | ImageBitmap | OffscreenCanvas;
19858 type OffscreenRenderingContext = OffscreenCanvasRenderingContext2D | ImageBitmapRenderingContext | WebGLRenderingContext | WebGL2RenderingContext;
19859 type MessageEventSource = WindowProxy | MessagePort | ServiceWorker;
19860 type HTMLOrSVGScriptElement = HTMLScriptElement | SVGScriptElement;
19861 type ImageBitmapSource = CanvasImageSource | Blob | ImageData;
19862 type MediaProvider = MediaStream | MediaSource | Blob;
19863 type OnErrorEventHandler = OnErrorEventHandlerNonNull | null;
19864 type OnBeforeUnloadEventHandler = OnBeforeUnloadEventHandlerNonNull | null;
19865 type TimerHandler = string | Function;
19866 type ConstrainULong = number | ConstrainULongRange;
19867 type ConstrainDouble = number | ConstrainDoubleRange;
19868 type ConstrainBoolean = boolean | ConstrainBooleanParameters;
19869 type ConstrainDOMString = string | string[] | ConstrainDOMStringParameters;
19870 type PerformanceEntryList = PerformanceEntry[];
19871 type ReadableStreamReadResult<T> = ReadableStreamReadValueResult<T> | ReadableStreamReadDoneResult<T>;
19872 type VibratePattern = number | number[];
19873 type COSEAlgorithmIdentifier = number;
19874 type AuthenticatorSelectionList = AAGUID[];
19875 type AAGUID = BufferSource;
19876 type AuthenticationExtensionsSupported = string[];
19877 type UvmEntry = number[];
19878 type UvmEntries = UvmEntry[];
19879 type AlgorithmIdentifier = string | Algorithm;
19880 type HashAlgorithmIdentifier = AlgorithmIdentifier;
19881 type BigInteger = Uint8Array;
19882 type NamedCurve = string;
19883 type GLenum = number;
19884 type GLboolean = boolean;
19885 type GLbitfield = number;
19886 type GLint = number;
19887 type GLsizei = number;
19888 type GLintptr = number;
19889 type GLsizeiptr = number;
19890 type GLuint = number;
19891 type GLfloat = number;
19892 type GLclampf = number;
19893 type TexImageSource = ImageBitmap | ImageData | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement | OffscreenCanvas;
19894 type Float32List = Float32Array | GLfloat[];
19895 type Int32List = Int32Array | GLint[];
19896 type GLint64 = number;
19897 type GLuint64 = number;
19898 type Uint32List = Uint32Array | GLuint[];
19899 type BufferSource = ArrayBufferView | ArrayBuffer;
19900 type DOMTimeStamp = number;
19901 type LineAndPositionSetting = number | AutoKeyword;
19902 type FormDataEntryValue = File | string;
19903 type InsertPosition = "beforebegin" | "afterbegin" | "beforeend" | "afterend";
19904 type IDBValidKey = number | string | Date | BufferSource | IDBArrayKey;
19905 type MutationRecordType = "attributes" | "characterData" | "childList";
19906 type IDBKeyPath = string;
19907 type Transferable = ArrayBuffer | MessagePort | ImageBitmap | OffscreenCanvas;
19908 type RTCIceGatherCandidate = RTCIceCandidateDictionary | RTCIceCandidateComplete;
19909 type RTCTransport = RTCDtlsTransport | RTCSrtpSdesTransport;
19910 /** @deprecated */
19911 type MouseWheelEvent = WheelEvent;
19912 type WindowProxy = Window;
19913 type AlignSetting = "center" | "end" | "left" | "right" | "start";
19914 type AnimationPlayState = "finished" | "idle" | "paused" | "running";
19915 type AppendMode = "segments" | "sequence";
19916 type AttestationConveyancePreference = "direct" | "indirect" | "none";
19917 type AudioContextLatencyCategory = "balanced" | "interactive" | "playback";
19918 type AudioContextState = "closed" | "running" | "suspended";
19919 type AuthenticatorAttachment = "cross-platform" | "platform";
19920 type AuthenticatorTransport = "ble" | "internal" | "nfc" | "usb";
19921 type AutoKeyword = "auto";
19922 type AutomationRate = "a-rate" | "k-rate";
19923 type BinaryType = "arraybuffer" | "blob";
19924 type BiquadFilterType = "allpass" | "bandpass" | "highpass" | "highshelf" | "lowpass" | "lowshelf" | "notch" | "peaking";
19925 type CanPlayTypeResult = "" | "maybe" | "probably";
19926 type CanvasDirection = "inherit" | "ltr" | "rtl";
19927 type CanvasFillRule = "evenodd" | "nonzero";
19928 type CanvasLineCap = "butt" | "round" | "square";
19929 type CanvasLineJoin = "bevel" | "miter" | "round";
19930 type CanvasTextAlign = "center" | "end" | "left" | "right" | "start";
19931 type CanvasTextBaseline = "alphabetic" | "bottom" | "hanging" | "ideographic" | "middle" | "top";
19932 type ChannelCountMode = "clamped-max" | "explicit" | "max";
19933 type ChannelInterpretation = "discrete" | "speakers";
19934 type ClientTypes = "all" | "sharedworker" | "window" | "worker";
19935 type ColorSpaceConversion = "default" | "none";
19936 type CompositeOperation = "accumulate" | "add" | "replace";
19937 type CompositeOperationOrAuto = "accumulate" | "add" | "auto" | "replace";
19938 type CredentialMediationRequirement = "optional" | "required" | "silent";
19939 type DirectionSetting = "" | "lr" | "rl";
19940 type DisplayCaptureSurfaceType = "application" | "browser" | "monitor" | "window";
19941 type DistanceModelType = "exponential" | "inverse" | "linear";
19942 type DocumentReadyState = "complete" | "interactive" | "loading";
19943 type EndOfStreamError = "decode" | "network";
19944 type EndingType = "native" | "transparent";
19945 type FillMode = "auto" | "backwards" | "both" | "forwards" | "none";
19946 type FullscreenNavigationUI = "auto" | "hide" | "show";
19947 type GamepadHand = "" | "left" | "right";
19948 type GamepadHapticActuatorType = "vibration";
19949 type GamepadMappingType = "" | "standard";
19950 type IDBCursorDirection = "next" | "nextunique" | "prev" | "prevunique";
19951 type IDBRequestReadyState = "done" | "pending";
19952 type IDBTransactionMode = "readonly" | "readwrite" | "versionchange";
19953 type ImageOrientation = "flipY" | "none";
19954 type ImageSmoothingQuality = "high" | "low" | "medium";
19955 type IterationCompositeOperation = "accumulate" | "replace";
19956 type KeyFormat = "jwk" | "pkcs8" | "raw" | "spki";
19957 type KeyType = "private" | "public" | "secret";
19958 type KeyUsage = "decrypt" | "deriveBits" | "deriveKey" | "encrypt" | "sign" | "unwrapKey" | "verify" | "wrapKey";
19959 type LineAlignSetting = "center" | "end" | "start";
19960 type ListeningState = "active" | "disambiguation" | "inactive";
19961 type MSCredentialType = "FIDO_2_0";
19962 type MSTransportType = "BT" | "Embedded" | "NFC" | "USB";
19963 type MSWebViewPermissionState = "allow" | "defer" | "deny" | "unknown";
19964 type MSWebViewPermissionType = "geolocation" | "media" | "pointerlock" | "unlimitedIndexedDBQuota" | "webnotifications";
19965 type MediaDeviceKind = "audioinput" | "audiooutput" | "videoinput";
19966 type MediaKeyMessageType = "individualization-request" | "license-release" | "license-renewal" | "license-request";
19967 type MediaKeySessionType = "persistent-license" | "temporary";
19968 type MediaKeyStatus = "expired" | "internal-error" | "output-downscaled" | "output-restricted" | "released" | "status-pending" | "usable";
19969 type MediaKeysRequirement = "not-allowed" | "optional" | "required";
19970 type MediaStreamTrackState = "ended" | "live";
19971 type NavigationReason = "down" | "left" | "right" | "up";
19972 type NavigationType = "back_forward" | "navigate" | "prerender" | "reload";
19973 type NotificationDirection = "auto" | "ltr" | "rtl";
19974 type NotificationPermission = "default" | "denied" | "granted";
19975 type OffscreenRenderingContextId = "2d" | "bitmaprenderer" | "webgl" | "webgl2";
19976 type OrientationLockType = "any" | "landscape" | "landscape-primary" | "landscape-secondary" | "natural" | "portrait" | "portrait-primary" | "portrait-secondary";
19977 type OrientationType = "landscape-primary" | "landscape-secondary" | "portrait-primary" | "portrait-secondary";
19978 type OscillatorType = "custom" | "sawtooth" | "sine" | "square" | "triangle";
19979 type OverSampleType = "2x" | "4x" | "none";
19980 type PanningModelType = "HRTF" | "equalpower";
19981 type PaymentComplete = "fail" | "success" | "unknown";
19982 type PaymentShippingType = "delivery" | "pickup" | "shipping";
19983 type PermissionName = "accelerometer" | "ambient-light-sensor" | "background-sync" | "bluetooth" | "camera" | "clipboard" | "device-info" | "geolocation" | "gyroscope" | "magnetometer" | "microphone" | "midi" | "notifications" | "persistent-storage" | "push" | "speaker";
19984 type PermissionState = "denied" | "granted" | "prompt";
19985 type PlaybackDirection = "alternate" | "alternate-reverse" | "normal" | "reverse";
19986 type PositionAlignSetting = "auto" | "center" | "line-left" | "line-right";
19987 type PremultiplyAlpha = "default" | "none" | "premultiply";
19988 type PublicKeyCredentialType = "public-key";
19989 type PushEncryptionKeyName = "auth" | "p256dh";
19990 type PushPermissionState = "denied" | "granted" | "prompt";
19991 type RTCBundlePolicy = "balanced" | "max-bundle" | "max-compat";
19992 type RTCDataChannelState = "closed" | "closing" | "connecting" | "open";
19993 type RTCDegradationPreference = "balanced" | "maintain-framerate" | "maintain-resolution";
19994 type RTCDtlsRole = "auto" | "client" | "server";
19995 type RTCDtlsTransportState = "closed" | "connected" | "connecting" | "failed" | "new";
19996 type RTCDtxStatus = "disabled" | "enabled";
19997 type RTCErrorDetailType = "data-channel-failure" | "dtls-failure" | "fingerprint-failure" | "hardware-encoder-error" | "hardware-encoder-not-available" | "idp-bad-script-failure" | "idp-execution-failure" | "idp-load-failure" | "idp-need-login" | "idp-timeout" | "idp-tls-failure" | "idp-token-expired" | "idp-token-invalid" | "sctp-failure" | "sdp-syntax-error";
19998 type RTCIceCandidateType = "host" | "prflx" | "relay" | "srflx";
19999 type RTCIceComponent = "rtcp" | "rtp";
20000 type RTCIceConnectionState = "checking" | "closed" | "completed" | "connected" | "disconnected" | "failed" | "new";
20001 type RTCIceCredentialType = "oauth" | "password";
20002 type RTCIceGatherPolicy = "all" | "nohost" | "relay";
20003 type RTCIceGathererState = "complete" | "gathering" | "new";
20004 type RTCIceGatheringState = "complete" | "gathering" | "new";
20005 type RTCIceProtocol = "tcp" | "udp";
20006 type RTCIceRole = "controlled" | "controlling" | "unknown";
20007 type RTCIceTcpCandidateType = "active" | "passive" | "so";
20008 type RTCIceTransportPolicy = "all" | "relay";
20009 type RTCIceTransportState = "checking" | "closed" | "completed" | "connected" | "disconnected" | "failed" | "new";
20010 type RTCPeerConnectionState = "closed" | "connected" | "connecting" | "disconnected" | "failed" | "new";
20011 type RTCPriorityType = "high" | "low" | "medium" | "very-low";
20012 type RTCRtcpMuxPolicy = "negotiate" | "require";
20013 type RTCRtpTransceiverDirection = "inactive" | "recvonly" | "sendonly" | "sendrecv" | "stopped";
20014 type RTCSctpTransportState = "closed" | "connected" | "connecting";
20015 type RTCSdpType = "answer" | "offer" | "pranswer" | "rollback";
20016 type RTCSignalingState = "closed" | "have-local-offer" | "have-local-pranswer" | "have-remote-offer" | "have-remote-pranswer" | "stable";
20017 type RTCStatsIceCandidatePairState = "cancelled" | "failed" | "frozen" | "inprogress" | "succeeded" | "waiting";
20018 type RTCStatsIceCandidateType = "host" | "peerreflexive" | "relayed" | "serverreflexive";
20019 type RTCStatsType = "candidatepair" | "datachannel" | "inboundrtp" | "localcandidate" | "outboundrtp" | "remotecandidate" | "session" | "track" | "transport";
20020 type ReadyState = "closed" | "ended" | "open";
20021 type ReferrerPolicy = "" | "no-referrer" | "no-referrer-when-downgrade" | "origin" | "origin-when-cross-origin" | "same-origin" | "strict-origin" | "strict-origin-when-cross-origin" | "unsafe-url";
20022 type RequestCache = "default" | "force-cache" | "no-cache" | "no-store" | "only-if-cached" | "reload";
20023 type RequestCredentials = "include" | "omit" | "same-origin";
20024 type RequestDestination = "" | "audio" | "audioworklet" | "document" | "embed" | "font" | "image" | "manifest" | "object" | "paintworklet" | "report" | "script" | "sharedworker" | "style" | "track" | "video" | "worker" | "xslt";
20025 type RequestMode = "cors" | "navigate" | "no-cors" | "same-origin";
20026 type RequestRedirect = "error" | "follow" | "manual";
20027 type ResizeQuality = "high" | "low" | "medium" | "pixelated";
20028 type ResponseType = "basic" | "cors" | "default" | "error" | "opaque" | "opaqueredirect";
20029 type ScopedCredentialType = "ScopedCred";
20030 type ScrollBehavior = "auto" | "smooth";
20031 type ScrollLogicalPosition = "center" | "end" | "nearest" | "start";
20032 type ScrollRestoration = "auto" | "manual";
20033 type ScrollSetting = "" | "up";
20034 type SelectionMode = "end" | "preserve" | "select" | "start";
20035 type ServiceWorkerState = "activated" | "activating" | "installed" | "installing" | "parsed" | "redundant";
20036 type ServiceWorkerUpdateViaCache = "all" | "imports" | "none";
20037 type ShadowRootMode = "closed" | "open";
20038 type SpeechSynthesisErrorCode = "audio-busy" | "audio-hardware" | "canceled" | "interrupted" | "invalid-argument" | "language-unavailable" | "network" | "not-allowed" | "synthesis-failed" | "synthesis-unavailable" | "text-too-long" | "voice-unavailable";
20039 type SupportedType = "application/xhtml+xml" | "application/xml" | "image/svg+xml" | "text/html" | "text/xml";
20040 type TextTrackKind = "captions" | "chapters" | "descriptions" | "metadata" | "subtitles";
20041 type TextTrackMode = "disabled" | "hidden" | "showing";
20042 type TouchType = "direct" | "stylus";
20043 type Transport = "ble" | "nfc" | "usb";
20044 type UserVerificationRequirement = "discouraged" | "preferred" | "required";
20045 type VRDisplayEventReason = "mounted" | "navigation" | "requested" | "unmounted";
20046 type VideoFacingModeEnum = "environment" | "left" | "right" | "user";
20047 type VisibilityState = "hidden" | "visible";
20048 type WebGLPowerPreference = "default" | "high-performance" | "low-power";
20049 type WorkerType = "classic" | "module";
20050 type XMLHttpRequestResponseType = "" | "arraybuffer" | "blob" | "document" | "json" | "text";