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
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.
12 See the Apache Version 2.0 License for specific language governing permissions
13 and limitations under the License.
14 ***************************************************************************** */
18 /// <reference no-default-lib="true"/>
\r
21 /////////////////////////////
23 /////////////////////////////
30 rpDisplayName: string;
33 interface AddEventListenerOptions extends EventListenerOptions {
38 interface AesCbcParams extends Algorithm {
39 iv: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;
42 interface AesCtrParams extends Algorithm {
43 counter: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;
47 interface AesDerivedKeyParams extends Algorithm {
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;
57 interface AesKeyAlgorithm extends KeyAlgorithm {
61 interface AesKeyGenParams extends Algorithm {
69 interface AnalyserOptions extends AudioNodeOptions {
73 smoothingTimeConstant?: number;
76 interface AnimationEventInit extends EventInit {
77 animationName?: string;
79 pseudoElement?: string;
82 interface AnimationPlaybackEventInit extends EventInit {
83 currentTime?: number | null;
84 timelineTime?: number | null;
87 interface AssertionOptions {
88 allowList?: ScopedCredentialDescriptor[];
89 extensions?: WebAuthnExtensions;
91 timeoutSeconds?: number;
94 interface AssignedNodesOptions {
98 interface AudioBufferOptions {
100 numberOfChannels?: number;
104 interface AudioBufferSourceOptions {
105 buffer?: AudioBuffer | null;
110 playbackRate?: number;
113 interface AudioContextInfo {
114 currentTime?: number;
118 interface AudioContextOptions {
119 latencyHint?: AudioContextLatencyCategory | number;
123 interface AudioNodeOptions {
124 channelCount?: number;
125 channelCountMode?: ChannelCountMode;
126 channelInterpretation?: ChannelInterpretation;
129 interface AudioParamDescriptor {
130 automationRate?: AutomationRate;
131 defaultValue?: number;
137 interface AudioProcessingEventInit extends EventInit {
138 inputBuffer: AudioBuffer;
139 outputBuffer: AudioBuffer;
140 playbackTime: number;
143 interface AudioTimestamp {
144 contextTime?: number;
145 performanceTime?: number;
148 interface AudioWorkletNodeOptions extends AudioNodeOptions {
149 numberOfInputs?: number;
150 numberOfOutputs?: number;
151 outputChannelCount?: number[];
152 parameterData?: Record<string, number>;
153 processorOptions?: any;
156 interface AuthenticationExtensionsClientInputs {
158 authnSel?: AuthenticatorSelectionList;
161 txAuthGeneric?: txAuthGenericArg;
162 txAuthSimple?: string;
167 interface AuthenticationExtensionsClientOutputs {
170 exts?: AuthenticationExtensionsSupported;
172 txAuthGeneric?: ArrayBuffer;
173 txAuthSimple?: string;
178 interface AuthenticatorSelectionCriteria {
179 authenticatorAttachment?: AuthenticatorAttachment;
180 requireResidentKey?: boolean;
181 userVerification?: UserVerificationRequirement;
184 interface BiquadFilterOptions extends AudioNodeOptions {
189 type?: BiquadFilterType;
192 interface BlobPropertyBag {
193 endings?: EndingType;
197 interface ByteLengthChunk {
201 interface CacheQueryOptions {
202 ignoreMethod?: boolean;
203 ignoreSearch?: boolean;
204 ignoreVary?: boolean;
207 interface CanvasRenderingContext2DSettings {
209 desynchronized?: boolean;
212 interface ChannelMergerOptions extends AudioNodeOptions {
213 numberOfInputs?: number;
216 interface ChannelSplitterOptions extends AudioNodeOptions {
217 numberOfOutputs?: number;
220 interface ClientData {
222 extensions?: WebAuthnExtensions;
223 hashAlg: string | Algorithm;
226 tokenBinding?: string;
229 interface ClientQueryOptions {
230 includeUncontrolled?: boolean;
234 interface ClipboardEventInit extends EventInit {
235 clipboardData?: DataTransfer | null;
238 interface CloseEventInit extends EventInit {
244 interface CompositionEventInit extends UIEventInit {
248 interface ComputedEffectTiming extends EffectTiming {
249 activeDuration?: number;
250 currentIteration?: number | null;
252 localTime?: number | null;
253 progress?: number | null;
256 interface ComputedKeyframe {
257 composite: CompositeOperationOrAuto;
258 computedOffset: number;
260 offset: number | null;
261 [property: string]: string | number | null | undefined;
264 interface ConfirmSiteSpecificExceptionsInformation extends ExceptionInformation {
265 arrayOfDomainStrings?: string[];
268 interface ConstantSourceOptions {
272 interface ConstrainBooleanParameters {
277 interface ConstrainDOMStringParameters {
278 exact?: string | string[];
279 ideal?: string | string[];
282 interface ConstrainDoubleRange extends DoubleRange {
287 interface ConstrainULongRange extends ULongRange {
292 interface ConstrainVideoFacingModeParameters {
293 exact?: VideoFacingModeEnum | VideoFacingModeEnum[];
294 ideal?: VideoFacingModeEnum | VideoFacingModeEnum[];
297 interface ConvolverOptions extends AudioNodeOptions {
298 buffer?: AudioBuffer | null;
299 disableNormalization?: boolean;
302 interface CredentialCreationOptions {
303 publicKey?: PublicKeyCredentialCreationOptions;
304 signal?: AbortSignal;
307 interface CredentialRequestOptions {
308 mediation?: CredentialMediationRequirement;
309 publicKey?: PublicKeyCredentialRequestOptions;
310 signal?: AbortSignal;
313 interface CustomEventInit<T = any> extends EventInit {
317 interface DOMMatrix2DInit {
332 interface DOMMatrixInit extends DOMMatrix2DInit {
346 interface DOMPointInit {
353 interface DOMQuadInit {
360 interface DOMRectInit {
367 interface DelayOptions extends AudioNodeOptions {
369 maxDelayTime?: number;
372 interface DeviceLightEventInit extends EventInit {
376 interface DeviceMotionEventAccelerationInit {
382 interface DeviceMotionEventInit extends EventInit {
383 acceleration?: DeviceMotionEventAccelerationInit;
384 accelerationIncludingGravity?: DeviceMotionEventAccelerationInit;
386 rotationRate?: DeviceMotionEventRotationRateInit;
389 interface DeviceMotionEventRotationRateInit {
390 alpha?: number | null;
391 beta?: number | null;
392 gamma?: number | null;
395 interface DeviceOrientationEventInit extends EventInit {
397 alpha?: number | null;
398 beta?: number | null;
399 gamma?: number | null;
402 interface DevicePermissionDescriptor extends PermissionDescriptor {
404 name: "camera" | "microphone" | "speaker";
407 interface DocumentTimelineOptions {
411 interface DoubleRange {
416 interface DragEventInit extends MouseEventInit {
417 dataTransfer?: DataTransfer | null;
420 interface DynamicsCompressorOptions extends AudioNodeOptions {
428 interface EcKeyAlgorithm extends KeyAlgorithm {
429 namedCurve: NamedCurve;
432 interface EcKeyGenParams extends Algorithm {
433 namedCurve: NamedCurve;
436 interface EcKeyImportParams extends Algorithm {
437 namedCurve: NamedCurve;
440 interface EcdhKeyDeriveParams extends Algorithm {
444 interface EcdsaParams extends Algorithm {
445 hash: HashAlgorithmIdentifier;
448 interface EffectTiming {
450 direction?: PlaybackDirection;
451 duration?: number | string;
455 iterationStart?: number;
459 interface ElementCreationOptions {
463 interface ElementDefinitionOptions {
467 interface ErrorEventInit extends EventInit {
475 interface EventInit {
477 cancelable?: boolean;
481 interface EventListenerOptions {
485 interface EventModifierInit extends UIEventInit {
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;
502 interface EventSourceInit {
503 withCredentials?: boolean;
506 interface ExceptionInformation {
507 domain?: string | null;
510 interface FilePropertyBag extends BlobPropertyBag {
511 lastModified?: number;
514 interface FocusEventInit extends UIEventInit {
515 relatedTarget?: EventTarget | null;
518 interface FocusNavigationEventInit extends EventInit {
519 navigationReason?: string | null;
520 originHeight?: number;
523 originWidth?: number;
526 interface FocusNavigationOrigin {
527 originHeight?: number;
530 originWidth?: number;
533 interface FocusOptions {
534 preventScroll?: boolean;
537 interface FullscreenOptions {
538 navigationUI?: FullscreenNavigationUI;
541 interface GainOptions extends AudioNodeOptions {
545 interface GamepadEventInit extends EventInit {
549 interface GetNotificationOptions {
553 interface GetRootNodeOptions {
557 interface HashChangeEventInit extends EventInit {
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;
568 interface HmacImportParams extends Algorithm {
569 hash: HashAlgorithmIdentifier;
573 interface HmacKeyAlgorithm extends KeyAlgorithm {
578 interface HmacKeyGenParams extends Algorithm {
579 hash: HashAlgorithmIdentifier;
583 interface IDBIndexParameters {
584 multiEntry?: boolean;
588 interface IDBObjectStoreParameters {
589 autoIncrement?: boolean;
590 keyPath?: string | string[] | null;
593 interface IDBVersionChangeEventInit extends EventInit {
594 newVersion?: number | null;
598 interface IIRFilterOptions extends AudioNodeOptions {
600 feedforward: number[];
603 interface ImageBitmapOptions {
604 colorSpaceConversion?: ColorSpaceConversion;
605 imageOrientation?: ImageOrientation;
606 premultiplyAlpha?: PremultiplyAlpha;
607 resizeHeight?: number;
608 resizeQuality?: ResizeQuality;
609 resizeWidth?: number;
612 interface ImageBitmapRenderingContextSettings {
616 interface ImageEncodeOptions {
621 interface InputEventInit extends UIEventInit {
622 data?: string | null;
624 isComposing?: boolean;
627 interface IntersectionObserverEntryInit {
628 boundingClientRect: DOMRectInit;
629 intersectionRatio: number;
630 intersectionRect: DOMRectInit;
631 isIntersecting: boolean;
632 rootBounds: DOMRectInit | null;
637 interface IntersectionObserverInit {
638 root?: Element | null;
640 threshold?: number | number[];
643 interface JsonWebKey {
655 oth?: RsaOtherPrimesInfo[];
664 interface KeyAlgorithm {
668 interface KeyboardEventInit extends EventModifierInit {
670 isComposing?: boolean;
677 composite?: CompositeOperationOrAuto;
679 offset?: number | null;
680 [property: string]: string | number | null | undefined;
683 interface KeyframeAnimationOptions extends KeyframeEffectOptions {
687 interface KeyframeEffectOptions extends EffectTiming {
688 composite?: CompositeOperation;
689 iterationComposite?: IterationCompositeOperation;
692 interface MediaElementAudioSourceOptions {
693 mediaElement: HTMLMediaElement;
696 interface MediaEncryptedEventInit extends EventInit {
697 initData?: ArrayBuffer | null;
698 initDataType?: string;
701 interface MediaKeyMessageEventInit extends EventInit {
702 message: ArrayBuffer;
703 messageType: MediaKeyMessageType;
706 interface MediaKeySystemConfiguration {
707 audioCapabilities?: MediaKeySystemMediaCapability[];
708 distinctiveIdentifier?: MediaKeysRequirement;
709 initDataTypes?: string[];
711 persistentState?: MediaKeysRequirement;
712 sessionTypes?: string[];
713 videoCapabilities?: MediaKeySystemMediaCapability[];
716 interface MediaKeySystemMediaCapability {
717 contentType?: string;
721 interface MediaQueryListEventInit extends EventInit {
726 interface MediaStreamAudioSourceOptions {
727 mediaStream: MediaStream;
730 interface MediaStreamConstraints {
731 audio?: boolean | MediaTrackConstraints;
732 peerIdentity?: string;
733 video?: boolean | MediaTrackConstraints;
736 interface MediaStreamErrorEventInit extends EventInit {
737 error?: MediaStreamError | null;
740 interface MediaStreamEventInit extends EventInit {
741 stream?: MediaStream;
744 interface MediaStreamTrackAudioSourceOptions {
745 mediaStreamTrack: MediaStreamTrack;
748 interface MediaStreamTrackEventInit extends EventInit {
749 track: MediaStreamTrack;
752 interface MediaTrackCapabilities {
753 aspectRatio?: DoubleRange;
754 autoGainControl?: boolean[];
755 channelCount?: ULongRange;
757 echoCancellation?: boolean[];
758 facingMode?: string[];
759 frameRate?: DoubleRange;
762 latency?: DoubleRange;
763 noiseSuppression?: boolean[];
764 resizeMode?: string[];
765 sampleRate?: ULongRange;
766 sampleSize?: ULongRange;
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;
788 interface MediaTrackConstraints extends MediaTrackConstraintSet {
789 advanced?: MediaTrackConstraintSet[];
792 interface MediaTrackSettings {
793 aspectRatio?: number;
794 autoGainControl?: boolean;
795 channelCount?: number;
797 echoCancellation?: boolean;
803 noiseSuppression?: boolean;
810 interface MediaTrackSupportedConstraints {
811 aspectRatio?: boolean;
812 autoGainControl?: boolean;
813 channelCount?: boolean;
815 echoCancellation?: boolean;
816 facingMode?: boolean;
821 noiseSuppression?: boolean;
822 resizeMode?: boolean;
823 sampleRate?: boolean;
824 sampleSize?: boolean;
828 interface MessageEventInit extends EventInit {
830 lastEventId?: string;
832 ports?: MessagePort[];
833 source?: MessageEventSource | null;
836 interface MidiPermissionDescriptor extends PermissionDescriptor {
841 interface MouseEventInit extends EventModifierInit {
848 relatedTarget?: EventTarget | null;
853 interface MultiCacheQueryOptions extends CacheQueryOptions {
857 interface MutationObserverInit {
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.
861 attributeFilter?: string[];
863 * Set to true if attributes is true or omitted and target's attribute value before the mutation needs to be recorded.
865 attributeOldValue?: boolean;
867 * Set to true if mutations to target's attributes are to be observed. Can be omitted if attributeOldValue or attributeFilter is specified.
869 attributes?: boolean;
871 * Set to true if mutations to target's data are to be observed. Can be omitted if characterDataOldValue is specified.
873 characterData?: boolean;
875 * Set to true if characterData is set to true or omitted and target's data before the mutation needs to be recorded.
877 characterDataOldValue?: boolean;
879 * Set to true if mutations to target's children are to be observed.
883 * Set to true if mutations to not just target, but also target's descendants are to be observed.
888 interface NavigationPreloadState {
890 headerValue?: string;
893 interface NotificationAction {
899 interface NotificationOptions {
900 actions?: NotificationAction[];
904 dir?: NotificationDirection;
909 requireInteraction?: boolean;
913 vibrate?: VibratePattern;
916 interface OfflineAudioCompletionEventInit extends EventInit {
917 renderedBuffer: AudioBuffer;
920 interface OfflineAudioContextOptions {
922 numberOfChannels?: number;
926 interface OptionalEffectTiming {
928 direction?: PlaybackDirection;
929 duration?: number | string;
933 iterationStart?: number;
937 interface OscillatorOptions extends AudioNodeOptions {
940 periodicWave?: PeriodicWave;
941 type?: OscillatorType;
944 interface PageTransitionEventInit extends EventInit {
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;
961 refDistance?: number;
962 rolloffFactor?: number;
965 interface PaymentCurrencyAmount {
967 currencySystem?: string;
971 interface PaymentDetailsBase {
972 displayItems?: PaymentItem[];
973 modifiers?: PaymentDetailsModifier[];
974 shippingOptions?: PaymentShippingOption[];
977 interface PaymentDetailsInit extends PaymentDetailsBase {
982 interface PaymentDetailsModifier {
983 additionalDisplayItems?: PaymentItem[];
985 supportedMethods: string | string[];
989 interface PaymentDetailsUpdate extends PaymentDetailsBase {
994 interface PaymentItem {
995 amount: PaymentCurrencyAmount;
1000 interface PaymentMethodData {
1002 supportedMethods: string | string[];
1005 interface PaymentOptions {
1006 requestPayerEmail?: boolean;
1007 requestPayerName?: boolean;
1008 requestPayerPhone?: boolean;
1009 requestShipping?: boolean;
1010 shippingType?: string;
1013 interface PaymentRequestUpdateEventInit extends EventInit {
1016 interface PaymentShippingOption {
1017 amount: PaymentCurrencyAmount;
1023 interface Pbkdf2Params extends Algorithm {
1024 hash: HashAlgorithmIdentifier;
1026 salt: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;
1029 interface PerformanceObserverInit {
1031 entryTypes?: string[];
1035 interface PeriodicWaveConstraints {
1036 disableNormalization?: boolean;
1039 interface PeriodicWaveOptions extends PeriodicWaveConstraints {
1040 imag?: number[] | Float32Array;
1041 real?: number[] | Float32Array;
1044 interface PermissionDescriptor {
1045 name: PermissionName;
1048 interface PipeOptions {
1049 preventAbort?: boolean;
1050 preventCancel?: boolean;
1051 preventClose?: boolean;
1052 signal?: AbortSignal;
1055 interface PointerEventInit extends MouseEventInit {
1057 isPrimary?: boolean;
1059 pointerType?: string;
1061 tangentialPressure?: number;
1068 interface PopStateEventInit extends EventInit {
1072 interface PositionOptions {
1073 enableHighAccuracy?: boolean;
1074 maximumAge?: number;
1078 interface PostMessageOptions {
1082 interface ProgressEventInit extends EventInit {
1083 lengthComputable?: boolean;
1088 interface PromiseRejectionEventInit extends EventInit {
1089 promise: Promise<any>;
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;
1100 interface PublicKeyCredentialCreationOptions {
1101 attestation?: AttestationConveyancePreference;
1102 authenticatorSelection?: AuthenticatorSelectionCriteria;
1103 challenge: BufferSource;
1104 excludeCredentials?: PublicKeyCredentialDescriptor[];
1105 extensions?: AuthenticationExtensionsClientInputs;
1106 pubKeyCredParams: PublicKeyCredentialParameters[];
1107 rp: PublicKeyCredentialRpEntity;
1109 user: PublicKeyCredentialUserEntity;
1112 interface PublicKeyCredentialDescriptor {
1114 transports?: AuthenticatorTransport[];
1115 type: PublicKeyCredentialType;
1118 interface PublicKeyCredentialEntity {
1123 interface PublicKeyCredentialParameters {
1124 alg: COSEAlgorithmIdentifier;
1125 type: PublicKeyCredentialType;
1128 interface PublicKeyCredentialRequestOptions {
1129 allowCredentials?: PublicKeyCredentialDescriptor[];
1130 challenge: BufferSource;
1131 extensions?: AuthenticationExtensionsClientInputs;
1134 userVerification?: UserVerificationRequirement;
1137 interface PublicKeyCredentialRpEntity extends PublicKeyCredentialEntity {
1141 interface PublicKeyCredentialUserEntity extends PublicKeyCredentialEntity {
1142 displayName: string;
1146 interface PushPermissionDescriptor extends PermissionDescriptor {
1148 userVisibleOnly?: boolean;
1151 interface PushSubscriptionJSON {
1153 expirationTime?: number | null;
1154 keys?: Record<string, string>;
1157 interface PushSubscriptionOptionsInit {
1158 applicationServerKey?: BufferSource | string | null;
1159 userVisibleOnly?: boolean;
1162 interface QueuingStrategy<T = any> {
1163 highWaterMark?: number;
1164 size?: QueuingStrategySizeCallback<T>;
1167 interface RTCAnswerOptions extends RTCOfferAnswerOptions {
1170 interface RTCCertificateExpiration {
1174 interface RTCConfiguration {
1175 bundlePolicy?: RTCBundlePolicy;
1176 certificates?: RTCCertificate[];
1177 iceCandidatePoolSize?: number;
1178 iceServers?: RTCIceServer[];
1179 iceTransportPolicy?: RTCIceTransportPolicy;
1180 peerIdentity?: string;
1181 rtcpMuxPolicy?: RTCRtcpMuxPolicy;
1184 interface RTCDTMFToneChangeEventInit extends EventInit {
1188 interface RTCDataChannelEventInit extends EventInit {
1189 channel: RTCDataChannel;
1192 interface RTCDataChannelInit {
1194 maxPacketLifeTime?: number;
1195 maxRetransmits?: number;
1196 negotiated?: boolean;
1198 priority?: RTCPriorityType;
1202 interface RTCDtlsFingerprint {
1207 interface RTCDtlsParameters {
1208 fingerprints?: RTCDtlsFingerprint[];
1212 interface RTCErrorEventInit extends EventInit {
1216 interface RTCErrorInit {
1217 errorDetail: RTCErrorDetailType;
1218 httpRequestStatusCode?: number;
1219 receivedAlert?: number;
1220 sctpCauseCode?: number;
1221 sdpLineNumber?: number;
1225 interface RTCIceCandidateAttributes extends RTCStats {
1226 addressSourceUrl?: string;
1227 candidateType?: RTCStatsIceCandidateType;
1229 portNumber?: number;
1234 interface RTCIceCandidateComplete {
1237 interface RTCIceCandidateDictionary {
1238 foundation?: string;
1240 msMTurnSessionId?: string;
1243 protocol?: RTCIceProtocol;
1244 relatedAddress?: string;
1245 relatedPort?: number;
1246 tcpType?: RTCIceTcpCandidateType;
1247 type?: RTCIceCandidateType;
1250 interface RTCIceCandidateInit {
1252 sdpMLineIndex?: number | null;
1253 sdpMid?: string | null;
1254 usernameFragment?: string | null;
1257 interface RTCIceCandidatePair {
1258 local?: RTCIceCandidate;
1259 remote?: RTCIceCandidate;
1262 interface RTCIceCandidatePairStats extends RTCStats {
1263 availableIncomingBitrate?: number;
1264 availableOutgoingBitrate?: number;
1265 bytesReceived?: number;
1267 localCandidateId?: string;
1268 nominated?: boolean;
1271 remoteCandidateId?: string;
1272 roundTripTime?: number;
1273 state?: RTCStatsIceCandidatePairState;
1274 transportId?: string;
1278 interface RTCIceGatherOptions {
1279 gatherPolicy?: RTCIceGatherPolicy;
1280 iceservers?: RTCIceServer[];
1283 interface RTCIceParameters {
1285 usernameFragment?: string;
1288 interface RTCIceServer {
1289 credential?: string | RTCOAuthCredential;
1290 credentialType?: RTCIceCredentialType;
1291 urls: string | string[];
1295 interface RTCIdentityProviderOptions {
1296 peerIdentity?: string;
1298 usernameHint?: string;
1301 interface RTCInboundRTPStreamStats extends RTCRTPStreamStats {
1302 bytesReceived?: number;
1303 fractionLost?: number;
1305 packetsLost?: number;
1306 packetsReceived?: number;
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;
1323 trackIdentifier?: string;
1326 interface RTCOAuthCredential {
1327 accessToken: string;
1331 interface RTCOfferAnswerOptions {
1332 voiceActivityDetection?: boolean;
1335 interface RTCOfferOptions extends RTCOfferAnswerOptions {
1336 iceRestart?: boolean;
1337 offerToReceiveAudio?: boolean;
1338 offerToReceiveVideo?: boolean;
1341 interface RTCOutboundRTPStreamStats extends RTCRTPStreamStats {
1343 packetsSent?: number;
1344 roundTripTime?: number;
1345 targetBitrate?: number;
1348 interface RTCPeerConnectionIceErrorEventInit extends EventInit {
1350 hostCandidate?: string;
1351 statusText?: string;
1355 interface RTCPeerConnectionIceEventInit extends EventInit {
1356 candidate?: RTCIceCandidate | null;
1357 url?: string | null;
1360 interface RTCRTPStreamStats extends RTCStats {
1361 associateStatsId?: string;
1365 mediaTrackId?: string;
1371 transportId?: string;
1374 interface RTCRtcpFeedback {
1379 interface RTCRtcpParameters {
1381 reducedSize?: boolean;
1384 interface RTCRtpCapabilities {
1385 codecs: RTCRtpCodecCapability[];
1386 headerExtensions: RTCRtpHeaderExtensionCapability[];
1389 interface RTCRtpCodecCapability {
1393 sdpFmtpLine?: string;
1396 interface RTCRtpCodecParameters {
1400 payloadType: number;
1401 sdpFmtpLine?: string;
1404 interface RTCRtpCodingParameters {
1408 interface RTCRtpContributingSource {
1409 audioLevel?: number;
1410 rtpTimestamp: number;
1415 interface RTCRtpDecodingParameters extends RTCRtpCodingParameters {
1418 interface RTCRtpEncodingParameters extends RTCRtpCodingParameters {
1420 codecPayloadType?: number;
1422 maxBitrate?: number;
1423 maxFramerate?: number;
1425 scaleResolutionDownBy?: number;
1428 interface RTCRtpFecParameters {
1433 interface RTCRtpHeaderExtension {
1435 preferredEncrypt?: boolean;
1436 preferredId?: number;
1440 interface RTCRtpHeaderExtensionCapability {
1444 interface RTCRtpHeaderExtensionParameters {
1445 encrypted?: boolean;
1450 interface RTCRtpParameters {
1451 codecs: RTCRtpCodecParameters[];
1452 headerExtensions: RTCRtpHeaderExtensionParameters[];
1453 rtcp: RTCRtcpParameters;
1456 interface RTCRtpReceiveParameters extends RTCRtpParameters {
1457 encodings: RTCRtpDecodingParameters[];
1460 interface RTCRtpRtxParameters {
1464 interface RTCRtpSendParameters extends RTCRtpParameters {
1465 degradationPreference?: RTCDegradationPreference;
1466 encodings: RTCRtpEncodingParameters[];
1467 priority?: RTCPriorityType;
1468 transactionId: string;
1471 interface RTCRtpSynchronizationSource extends RTCRtpContributingSource {
1472 voiceActivityFlag?: boolean;
1475 interface RTCRtpTransceiverInit {
1476 direction?: RTCRtpTransceiverDirection;
1477 sendEncodings?: RTCRtpEncodingParameters[];
1478 streams?: MediaStream[];
1481 interface RTCRtpUnhandled {
1483 payloadType?: number;
1487 interface RTCSessionDescriptionInit {
1492 interface RTCSrtpKeyParam {
1500 interface RTCSrtpSdesParameters {
1501 cryptoSuite?: string;
1502 keyParams?: RTCSrtpKeyParam[];
1503 sessionParams?: string[];
1507 interface RTCSsrcRange {
1512 interface RTCStats {
1518 interface RTCStatsEventInit extends EventInit {
1519 report: RTCStatsReport;
1522 interface RTCStatsReport {
1525 interface RTCTrackEventInit extends EventInit {
1526 receiver: RTCRtpReceiver;
1527 streams?: MediaStream[];
1528 track: MediaStreamTrack;
1529 transceiver: RTCRtpTransceiver;
1532 interface RTCTransportStats extends RTCStats {
1533 activeConnection?: boolean;
1534 bytesReceived?: number;
1536 localCertificateId?: string;
1537 remoteCertificateId?: string;
1538 rtcpTransportStatsId?: string;
1539 selectedCandidatePairId?: string;
1542 interface ReadableStreamReadDoneResult<T> {
1547 interface ReadableStreamReadValueResult<T> {
1552 interface RegistrationOptions {
1555 updateViaCache?: ServiceWorkerUpdateViaCache;
1558 interface RequestInit {
1560 * A BodyInit object or null to set request's body.
1562 body?: BodyInit | null;
1564 * A string indicating how the request will interact with the browser's cache to set request's cache.
1566 cache?: RequestCache;
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.
1570 credentials?: RequestCredentials;
1572 * A Headers object, an object literal, or an array of two-item arrays to set request's headers.
1574 headers?: HeadersInit;
1576 * A cryptographic hash of the resource to be fetched by request. Sets request's integrity.
1580 * A boolean to set request's keepalive.
1582 keepalive?: boolean;
1584 * A string to set request's method.
1588 * A string to indicate whether the request will use CORS, or will be restricted to same-origin URLs. Sets request's mode.
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.
1594 redirect?: RequestRedirect;
1596 * A string whose value is a same-origin URL, "about:client", or the empty string, to set request's referrer.
1600 * A referrer policy to set request's referrerPolicy.
1602 referrerPolicy?: ReferrerPolicy;
1604 * An AbortSignal to set request's signal.
1606 signal?: AbortSignal | null;
1608 * Can only be null. Used to disassociate request from any Window.
1613 interface ResponseInit {
1614 headers?: HeadersInit;
1616 statusText?: string;
1619 interface RsaHashedImportParams extends Algorithm {
1620 hash: HashAlgorithmIdentifier;
1623 interface RsaHashedKeyAlgorithm extends RsaKeyAlgorithm {
1627 interface RsaHashedKeyGenParams extends RsaKeyGenParams {
1628 hash: HashAlgorithmIdentifier;
1631 interface RsaKeyAlgorithm extends KeyAlgorithm {
1632 modulusLength: number;
1633 publicExponent: BigInteger;
1636 interface RsaKeyGenParams extends Algorithm {
1637 modulusLength: number;
1638 publicExponent: BigInteger;
1641 interface RsaOaepParams extends Algorithm {
1642 label?: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;
1645 interface RsaOtherPrimesInfo {
1651 interface RsaPssParams extends Algorithm {
1655 interface SVGBoundingBoxOptions {
1662 interface ScopedCredentialDescriptor {
1663 id: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer | null;
1664 transports?: Transport[];
1665 type: ScopedCredentialType;
1668 interface ScopedCredentialOptions {
1669 excludeList?: ScopedCredentialDescriptor[];
1670 extensions?: WebAuthnExtensions;
1672 timeoutSeconds?: number;
1675 interface ScopedCredentialParameters {
1676 algorithm: string | Algorithm;
1677 type: ScopedCredentialType;
1680 interface ScrollIntoViewOptions extends ScrollOptions {
1681 block?: ScrollLogicalPosition;
1682 inline?: ScrollLogicalPosition;
1685 interface ScrollOptions {
1686 behavior?: ScrollBehavior;
1689 interface ScrollToOptions extends ScrollOptions {
1694 interface SecurityPolicyViolationEventInit extends EventInit {
1695 blockedURI?: string;
1696 columnNumber?: number;
1697 documentURI?: string;
1698 effectiveDirective?: string;
1699 lineNumber?: number;
1700 originalPolicy?: string;
1702 sourceFile?: string;
1703 statusCode?: number;
1704 violatedDirective?: string;
1707 interface ServiceWorkerMessageEventInit extends EventInit {
1709 lastEventId?: string;
1711 ports?: MessagePort[] | null;
1712 source?: ServiceWorker | MessagePort | null;
1715 interface ShadowRootInit {
1716 delegatesFocus?: boolean;
1717 mode: ShadowRootMode;
1720 interface ShareData {
1726 interface SpeechSynthesisErrorEventInit extends SpeechSynthesisEventInit {
1727 error: SpeechSynthesisErrorCode;
1730 interface SpeechSynthesisEventInit extends EventInit {
1732 charLength?: number;
1733 elapsedTime?: number;
1735 utterance: SpeechSynthesisUtterance;
1738 interface StaticRangeInit {
1741 startContainer: Node;
1742 startOffset: number;
1745 interface StereoPannerOptions extends AudioNodeOptions {
1749 interface StorageEstimate {
1754 interface StorageEventInit extends EventInit {
1755 key?: string | null;
1756 newValue?: string | null;
1757 oldValue?: string | null;
1758 storageArea?: Storage | null;
1762 interface StoreExceptionsInformation extends ExceptionInformation {
1763 detailURI?: string | null;
1764 explanationString?: string | null;
1765 siteName?: string | null;
1768 interface StoreSiteSpecificExceptionsInformation extends StoreExceptionsInformation {
1769 arrayOfDomainStrings?: string[];
1772 interface TextDecodeOptions {
1776 interface TextDecoderOptions {
1778 ignoreBOM?: boolean;
1781 interface TextEncoderEncodeIntoResult {
1786 interface TouchEventInit extends EventModifierInit {
1787 changedTouches?: Touch[];
1788 targetTouches?: Touch[];
1792 interface TouchInit {
1793 altitudeAngle?: number;
1794 azimuthAngle?: number;
1803 rotationAngle?: number;
1806 target: EventTarget;
1807 touchType?: TouchType;
1810 interface TrackEventInit extends EventInit {
1811 track?: TextTrack | null;
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;
1822 interface TransitionEventInit extends EventInit {
1823 elapsedTime?: number;
1824 propertyName?: string;
1825 pseudoElement?: string;
1828 interface UIEventInit extends EventInit {
1830 view?: Window | null;
1833 interface ULongRange {
1838 interface UnderlyingByteSource {
1839 autoAllocateChunkSize?: number;
1840 cancel?: ReadableStreamErrorCallback;
1841 pull?: ReadableByteStreamControllerCallback;
1842 start?: ReadableByteStreamControllerCallback;
1846 interface UnderlyingSink<W = any> {
1847 abort?: WritableStreamErrorCallback;
1848 close?: WritableStreamDefaultControllerCloseCallback;
1849 start?: WritableStreamDefaultControllerStartCallback;
1851 write?: WritableStreamDefaultControllerWriteCallback<W>;
1854 interface UnderlyingSource<R = any> {
1855 cancel?: ReadableStreamErrorCallback;
1856 pull?: ReadableStreamDefaultControllerCallback<R>;
1857 start?: ReadableStreamDefaultControllerCallback<R>;
1861 interface VRDisplayEventInit extends EventInit {
1863 reason?: VRDisplayEventReason;
1867 leftBounds?: number[] | Float32Array | null;
1868 rightBounds?: number[] | Float32Array | null;
1869 source?: HTMLCanvasElement | null;
1872 interface VRStageParameters {
1873 sittingToStandingTransform?: Float32Array;
1878 interface WaveShaperOptions extends AudioNodeOptions {
1879 curve?: number[] | Float32Array;
1880 oversample?: OverSampleType;
1883 interface WebAuthnExtensions {
1886 interface WebGLContextAttributes {
1888 antialias?: boolean;
1890 desynchronized?: boolean;
1891 failIfMajorPerformanceCaveat?: boolean;
1892 powerPreference?: WebGLPowerPreference;
1893 premultipliedAlpha?: boolean;
1894 preserveDrawingBuffer?: boolean;
1898 interface WebGLContextEventInit extends EventInit {
1899 statusMessage?: string;
1902 interface WheelEventInit extends MouseEventInit {
1909 interface WorkerOptions {
1910 credentials?: RequestCredentials;
1915 interface WorkletOptions {
1916 credentials?: RequestCredentials;
1919 interface txAuthGenericArg {
1920 content: ArrayBuffer;
1921 contentType: string;
1924 interface EventListener {
1928 type XPathNSResolver = ((prefix: string | null) => string | null) | { lookupNamespaceURI(prefix: string | null): string | null; };
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;
1938 /** A controller object that allows you to abort one or more DOM requests as and when desired. */
1939 interface AbortController {
1941 * Returns the AbortSignal object associated with this object.
1943 readonly signal: AbortSignal;
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.
1950 declare var AbortController: {
1951 prototype: AbortController;
1952 new(): AbortController;
1955 interface AbortSignalEventMap {
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 {
1962 * Returns true if this AbortSignal's AbortController has signaled to abort, and false otherwise.
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;
1972 declare var AbortSignal: {
1973 prototype: AbortSignal;
1977 interface AbstractRange {
1979 * Returns true if range is collapsed, and false otherwise.
1981 readonly collapsed: boolean;
1983 * Returns range's end node.
1985 readonly endContainer: Node;
1987 * Returns range's end offset.
1989 readonly endOffset: number;
1991 * Returns range's start node.
1993 readonly startContainer: Node;
1995 * Returns range's start offset.
1997 readonly startOffset: number;
2000 declare var AbstractRange: {
2001 prototype: AbstractRange;
2002 new(): AbstractRange;
2005 interface AbstractWorkerEventMap {
2006 "error": ErrorEvent;
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;
2017 interface AesCfbParams extends Algorithm {
2018 iv: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;
2021 interface AesCmacParams extends Algorithm {
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 {
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;
2038 declare var AnalyserNode: {
2039 prototype: AnalyserNode;
2040 new(context: BaseAudioContext, options?: AnalyserOptions): AnalyserNode;
2043 interface Animatable {
2044 animate(keyframes: Keyframe[] | PropertyIndexedKeyframes | null, options?: number | KeyframeAnimationOptions): Animation;
2045 getAnimations(): Animation[];
2048 interface AnimationEventMap {
2049 "cancel": AnimationPlaybackEvent;
2050 "finish": AnimationPlaybackEvent;
2053 interface Animation extends EventTarget {
2054 currentTime: number | null;
2055 effect: AnimationEffect | null;
2056 readonly finished: Promise<Animation>;
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;
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;
2078 declare var Animation: {
2079 prototype: Animation;
2080 new(effect?: AnimationEffect | null, timeline?: AnimationTimeline | null): Animation;
2083 interface AnimationEffect {
2084 getComputedTiming(): ComputedEffectTiming;
2085 getTiming(): EffectTiming;
2086 updateTiming(timing?: OptionalEffectTiming): void;
2089 declare var AnimationEffect: {
2090 prototype: AnimationEffect;
2091 new(): AnimationEffect;
2094 /** Events providing information related to animations. */
2095 interface AnimationEvent extends Event {
2096 readonly animationName: string;
2097 readonly elapsedTime: number;
2098 readonly pseudoElement: string;
2101 declare var AnimationEvent: {
2102 prototype: AnimationEvent;
2103 new(type: string, animationEventInitDict?: AnimationEventInit): AnimationEvent;
2106 interface AnimationFrameProvider {
2107 cancelAnimationFrame(handle: number): void;
2108 requestAnimationFrame(callback: FrameRequestCallback): number;
2111 interface AnimationPlaybackEvent extends Event {
2112 readonly currentTime: number | null;
2113 readonly timelineTime: number | null;
2116 declare var AnimationPlaybackEvent: {
2117 prototype: AnimationPlaybackEvent;
2118 new(type: string, eventInitDict?: AnimationPlaybackEventInit): AnimationPlaybackEvent;
2121 interface AnimationTimeline {
2122 readonly currentTime: number | null;
2125 declare var AnimationTimeline: {
2126 prototype: AnimationTimeline;
2127 new(): AnimationTimeline;
2130 interface ApplicationCacheEventMap {
2133 "downloading": Event;
2137 "progress": ProgressEvent<ApplicationCache>;
2138 "updateready": Event;
2141 interface ApplicationCache extends EventTarget {
2143 oncached: ((this: ApplicationCache, ev: Event) => any) | null;
2145 onchecking: ((this: ApplicationCache, ev: Event) => any) | null;
2147 ondownloading: ((this: ApplicationCache, ev: Event) => any) | null;
2149 onerror: ((this: ApplicationCache, ev: Event) => any) | null;
2151 onnoupdate: ((this: ApplicationCache, ev: Event) => any) | null;
2153 onobsolete: ((this: ApplicationCache, ev: Event) => any) | null;
2155 onprogress: ((this: ApplicationCache, ev: ProgressEvent<ApplicationCache>) => any) | null;
2157 onupdateready: ((this: ApplicationCache, ev: Event) => any) | null;
2159 readonly status: number;
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;
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;
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;
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;
2217 declare var AudioBuffer: {
2218 prototype: AudioBuffer;
2219 new(options: AudioBufferOptions): AudioBuffer;
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;
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;
2237 declare var AudioBufferSourceNode: {
2238 prototype: AudioBufferSourceNode;
2239 new(context: BaseAudioContext, options?: AudioBufferSourceOptions): AudioBufferSourceNode;
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;
2260 declare var AudioContext: {
2261 prototype: AudioContext;
2262 new(contextOptions?: AudioContextOptions): AudioContext;
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;
2270 declare var AudioDestinationNode: {
2271 prototype: AudioDestinationNode;
2272 new(): AudioDestinationNode;
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;
2287 setOrientation(x: number, y: number, z: number, xUp: number, yUp: number, zUp: number): void;
2289 setPosition(x: number, y: number, z: number): void;
2292 declare var AudioListener: {
2293 prototype: AudioListener;
2294 new(): AudioListener;
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;
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;
2316 declare var AudioNode: {
2317 prototype: AudioNode;
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;
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;
2337 declare var AudioParam: {
2338 prototype: AudioParam;
2342 interface AudioParamMap {
2343 forEach(callbackfn: (value: AudioParam, key: string, parent: AudioParamMap) => void, thisArg?: any): void;
2346 declare var AudioParamMap: {
2347 prototype: AudioParamMap;
2348 new(): AudioParamMap;
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;
2358 declare var AudioProcessingEvent: {
2359 prototype: AudioProcessingEvent;
2360 new(type: string, eventInitDict: AudioProcessingEventInit): AudioProcessingEvent;
2363 interface AudioScheduledSourceNodeEventMap {
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;
2377 declare var AudioScheduledSourceNode: {
2378 prototype: AudioScheduledSourceNode;
2379 new(): AudioScheduledSourceNode;
2382 interface AudioWorklet extends Worklet {
2385 declare var AudioWorklet: {
2386 prototype: AudioWorklet;
2387 new(): AudioWorklet;
2390 interface AudioWorkletNodeEventMap {
2391 "processorerror": Event;
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;
2404 declare var AudioWorkletNode: {
2405 prototype: AudioWorkletNode;
2406 new(context: BaseAudioContext, name: string, options?: AudioWorkletNodeOptions): AudioWorkletNode;
2409 interface AuthenticatorAssertionResponse extends AuthenticatorResponse {
2410 readonly authenticatorData: ArrayBuffer;
2411 readonly signature: ArrayBuffer;
2412 readonly userHandle: ArrayBuffer | null;
2415 declare var AuthenticatorAssertionResponse: {
2416 prototype: AuthenticatorAssertionResponse;
2417 new(): AuthenticatorAssertionResponse;
2420 interface AuthenticatorAttestationResponse extends AuthenticatorResponse {
2421 readonly attestationObject: ArrayBuffer;
2424 declare var AuthenticatorAttestationResponse: {
2425 prototype: AuthenticatorAttestationResponse;
2426 new(): AuthenticatorAttestationResponse;
2429 interface AuthenticatorResponse {
2430 readonly clientDataJSON: ArrayBuffer;
2433 declare var AuthenticatorResponse: {
2434 prototype: AuthenticatorResponse;
2435 new(): AuthenticatorResponse;
2439 readonly visible: boolean;
2442 declare var BarProp: {
2447 interface BaseAudioContextEventMap {
2448 "statechange": Event;
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;
2484 declare var BaseAudioContext: {
2485 prototype: BaseAudioContext;
2486 new(): BaseAudioContext;
2489 /** The beforeunload event is fired when the window, the document and its resources are about to be unloaded. */
2490 interface BeforeUnloadEvent extends Event {
2494 declare var BeforeUnloadEvent: {
2495 prototype: BeforeUnloadEvent;
2496 new(): BeforeUnloadEvent;
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;
2516 declare var BhxBrowser: {
2517 prototype: BhxBrowser;
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;
2531 declare var BiquadFilterNode: {
2532 prototype: BiquadFilterNode;
2533 new(context: BaseAudioContext, options?: BiquadFilterOptions): BiquadFilterNode;
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. */
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>;
2548 new(blobParts?: BlobPart[], options?: BlobPropertyBag): Blob;
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>;
2561 interface BroadcastChannelEventMap {
2562 "message": MessageEvent;
2563 "messageerror": MessageEvent;
2566 interface BroadcastChannel extends EventTarget {
2568 * Returns the channel name (as passed to the constructor).
2570 readonly name: string;
2571 onmessage: ((this: BroadcastChannel, ev: MessageEvent) => any) | null;
2572 onmessageerror: ((this: BroadcastChannel, ev: MessageEvent) => any) | null;
2574 * Closes the BroadcastChannel object, opening it up to garbage collection.
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.
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;
2587 declare var BroadcastChannel: {
2588 prototype: BroadcastChannel;
2589 new(name: string): BroadcastChannel;
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;
2598 declare var ByteLengthQueuingStrategy: {
2599 prototype: ByteLengthQueuingStrategy;
2600 new(options: { highWaterMark: number }): ByteLengthQueuingStrategy;
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 {
2607 declare var CDATASection: {
2608 prototype: CDATASection;
2609 new(): CDATASection;
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;
2617 declare var CSSConditionRule: {
2618 prototype: CSSConditionRule;
2619 new(): CSSConditionRule;
2622 interface CSSFontFaceRule extends CSSRule {
2623 readonly style: CSSStyleDeclaration;
2626 declare var CSSFontFaceRule: {
2627 prototype: CSSFontFaceRule;
2628 new(): CSSFontFaceRule;
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;
2638 declare var CSSGroupingRule: {
2639 prototype: CSSGroupingRule;
2640 new(): CSSGroupingRule;
2643 interface CSSImportRule extends CSSRule {
2644 readonly href: string;
2645 readonly media: MediaList;
2646 readonly styleSheet: CSSStyleSheet;
2649 declare var CSSImportRule: {
2650 prototype: CSSImportRule;
2651 new(): CSSImportRule;
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 {
2657 readonly style: CSSStyleDeclaration;
2660 declare var CSSKeyframeRule: {
2661 prototype: CSSKeyframeRule;
2662 new(): CSSKeyframeRule;
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;
2669 appendRule(rule: string): void;
2670 deleteRule(select: string): void;
2671 findRule(select: string): CSSKeyframeRule | null;
2674 declare var CSSKeyframesRule: {
2675 prototype: CSSKeyframesRule;
2676 new(): CSSKeyframesRule;
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;
2684 declare var CSSMediaRule: {
2685 prototype: CSSMediaRule;
2686 new(): CSSMediaRule;
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;
2695 declare var CSSNamespaceRule: {
2696 prototype: CSSNamespaceRule;
2697 new(): CSSNamespaceRule;
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;
2706 declare var CSSPageRule: {
2707 prototype: CSSPageRule;
2711 /** A single CSS rule. There are several types of rules, listed in the Type constants section below. */
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;
2729 declare var 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;
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;
2751 declare var CSSRuleList: {
2752 prototype: CSSRuleList;
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;
2761 alignmentBaseline: 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;
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;
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;
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;
2829 borderTopColor: string;
2830 borderTopLeftRadius: string;
2831 borderTopRightRadius: string;
2832 borderTopStyle: string;
2833 borderTopWidth: string;
2834 borderWidth: string;
2839 breakBefore: string;
2840 breakInside: string;
2841 captionSide: string;
2848 colorInterpolation: string;
2849 colorInterpolationFilters: string;
2850 columnCount: string;
2854 columnRuleColor: string;
2855 columnRuleStyle: string;
2856 columnRuleWidth: string;
2858 columnWidth: string;
2861 counterIncrement: string;
2862 counterReset: string;
2868 dominantBaseline: string;
2871 fillOpacity: string;
2876 flexDirection: string;
2883 floodOpacity: string;
2886 fontFeatureSettings: string;
2887 fontKerning: string;
2889 fontSizeAdjust: string;
2890 fontStretch: string;
2892 fontSynthesis: string;
2893 fontVariant: string;
2894 fontVariantCaps: string;
2895 fontVariantEastAsian: string;
2896 fontVariantLigatures: string;
2897 fontVariantNumeric: string;
2898 fontVariantPosition: string;
2901 glyphOrientationVertical: string;
2904 gridAutoColumns: string;
2905 gridAutoFlow: string;
2906 gridAutoRows: string;
2908 gridColumnEnd: string;
2909 gridColumnGap: string;
2910 gridColumnStart: string;
2915 gridRowStart: string;
2916 gridTemplate: string;
2917 gridTemplateAreas: string;
2918 gridTemplateColumns: string;
2919 gridTemplateRows: string;
2922 imageOrientation: string;
2923 imageRendering: string;
2925 justifyContent: string;
2926 justifyItems: string;
2927 justifySelf: string;
2929 readonly length: number;
2930 letterSpacing: string;
2931 lightingColor: string;
2935 listStyleImage: string;
2936 listStylePosition: string;
2937 listStyleType: string;
2939 marginBlockEnd: string;
2940 marginBlockStart: string;
2941 marginBottom: string;
2942 marginInlineEnd: string;
2943 marginInlineStart: string;
2945 marginRight: string;
2950 markerStart: string;
2952 maskComposite: string;
2954 maskPosition: string;
2958 maxBlockSize: string;
2960 maxInlineSize: string;
2962 minBlockSize: string;
2964 minInlineSize: string;
2967 objectPosition: string;
2972 outlineColor: string;
2973 outlineOffset: string;
2974 outlineStyle: string;
2975 outlineWidth: string;
2977 overflowAnchor: string;
2978 overflowWrap: string;
2982 paddingBlockEnd: string;
2983 paddingBlockStart: string;
2984 paddingBottom: string;
2985 paddingInlineEnd: string;
2986 paddingInlineStart: string;
2987 paddingLeft: string;
2988 paddingRight: string;
2990 pageBreakAfter: string;
2991 pageBreakBefore: string;
2992 pageBreakInside: string;
2994 readonly parentRule: CSSRule | null;
2995 perspective: string;
2996 perspectiveOrigin: string;
2997 placeContent: string;
3000 pointerEvents: string;
3008 rubyPosition: string;
3010 scrollBehavior: string;
3011 shapeRendering: string;
3013 stopOpacity: string;
3015 strokeDasharray: string;
3016 strokeDashoffset: string;
3017 strokeLinecap: string;
3018 strokeLinejoin: string;
3019 strokeMiterlimit: string;
3020 strokeOpacity: string;
3021 strokeWidth: string;
3023 tableLayout: string;
3025 textAlignLast: 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;
3037 textJustify: string;
3038 textOrientation: string;
3039 textOverflow: string;
3040 textRendering: string;
3042 textTransform: string;
3043 textUnderlinePosition: string;
3045 touchAction: string;
3047 transformBox: string;
3048 transformOrigin: string;
3049 transformStyle: string;
3051 transitionDelay: string;
3052 transitionDuration: string;
3053 transitionProperty: string;
3054 transitionTimingFunction: string;
3056 unicodeBidi: string;
3058 verticalAlign: string;
3061 webkitAlignContent: string;
3063 webkitAlignItems: string;
3065 webkitAlignSelf: string;
3067 webkitAnimation: string;
3069 webkitAnimationDelay: string;
3071 webkitAnimationDirection: string;
3073 webkitAnimationDuration: string;
3075 webkitAnimationFillMode: string;
3077 webkitAnimationIterationCount: string;
3079 webkitAnimationName: string;
3081 webkitAnimationPlayState: string;
3083 webkitAnimationTimingFunction: string;
3085 webkitAppearance: string;
3087 webkitBackfaceVisibility: string;
3089 webkitBackgroundClip: string;
3091 webkitBackgroundOrigin: string;
3093 webkitBackgroundSize: string;
3095 webkitBorderBottomLeftRadius: string;
3097 webkitBorderBottomRightRadius: string;
3099 webkitBorderRadius: string;
3101 webkitBorderTopLeftRadius: string;
3103 webkitBorderTopRightRadius: string;
3105 webkitBoxAlign: string;
3107 webkitBoxFlex: string;
3109 webkitBoxOrdinalGroup: string;
3111 webkitBoxOrient: string;
3113 webkitBoxPack: string;
3115 webkitBoxShadow: string;
3117 webkitBoxSizing: string;
3119 webkitFilter: string;
3123 webkitFlexBasis: string;
3125 webkitFlexDirection: string;
3127 webkitFlexFlow: string;
3129 webkitFlexGrow: string;
3131 webkitFlexShrink: string;
3133 webkitFlexWrap: string;
3135 webkitJustifyContent: string;
3136 webkitLineClamp: string;
3140 webkitMaskBoxImage: string;
3142 webkitMaskBoxImageOutset: string;
3144 webkitMaskBoxImageRepeat: string;
3146 webkitMaskBoxImageSlice: string;
3148 webkitMaskBoxImageSource: string;
3150 webkitMaskBoxImageWidth: string;
3152 webkitMaskClip: string;
3154 webkitMaskComposite: string;
3156 webkitMaskImage: string;
3158 webkitMaskOrigin: string;
3160 webkitMaskPosition: string;
3162 webkitMaskRepeat: string;
3164 webkitMaskSize: string;
3166 webkitOrder: string;
3168 webkitPerspective: string;
3170 webkitPerspectiveOrigin: string;
3171 webkitTapHighlightColor: string;
3173 webkitTextFillColor: string;
3175 webkitTextSizeAdjust: string;
3177 webkitTextStroke: string;
3179 webkitTextStrokeColor: string;
3181 webkitTextStrokeWidth: string;
3183 webkitTransform: string;
3185 webkitTransformOrigin: string;
3187 webkitTransformStyle: string;
3189 webkitTransition: string;
3191 webkitTransitionDelay: string;
3193 webkitTransitionDuration: string;
3195 webkitTransitionProperty: string;
3197 webkitTransitionTimingFunction: string;
3199 webkitUserSelect: string;
3205 wordSpacing: string;
3207 writingMode: 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;
3219 declare var CSSStyleDeclaration: {
3220 prototype: CSSStyleDeclaration;
3221 new(): CSSStyleDeclaration;
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;
3230 declare var CSSStyleRule: {
3231 prototype: CSSStyleRule;
3232 new(): CSSStyleRule;
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;
3246 declare var CSSStyleSheet: {
3247 prototype: CSSStyleSheet;
3248 new(): CSSStyleSheet;
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 {
3255 declare var CSSSupportsRule: {
3256 prototype: CSSSupportsRule;
3257 new(): CSSSupportsRule;
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. */
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>;
3271 declare var Cache: {
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>;
3285 declare var CacheStorage: {
3286 prototype: CacheStorage;
3287 new(): CacheStorage;
3290 interface CanvasCompositing {
3291 globalAlpha: number;
3292 globalCompositeOperation: string;
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;
3301 interface CanvasDrawPath {
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;
3312 stroke(path: Path2D): void;
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;
3323 interface CanvasFilters {
3327 /** An opaque object describing a gradient. It is returned by the methods CanvasRenderingContext2D.createLinearGradient() or CanvasRenderingContext2D.createRadialGradient(). */
3328 interface CanvasGradient {
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.
3332 * Throws an "IndexSizeError" DOMException if the offset is out of range. Throws a "SyntaxError" DOMException if the color cannot be parsed.
3334 addColorStop(offset: number, color: string): void;
3337 declare var CanvasGradient: {
3338 prototype: CanvasGradient;
3339 new(): CanvasGradient;
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;
3350 interface CanvasImageSmoothing {
3351 imageSmoothingEnabled: boolean;
3352 imageSmoothingQuality: ImageSmoothingQuality;
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;
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;
3367 interface CanvasPathDrawingStyles {
3368 lineCap: CanvasLineCap;
3369 lineDashOffset: number;
3370 lineJoin: CanvasLineJoin;
3373 getLineDash(): number[];
3374 setLineDash(segments: number[]): void;
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 {
3380 * Sets the transformation matrix that will be used when rendering the pattern during a fill or stroke painting operation.
3382 setTransform(transform?: DOMMatrix2DInit): void;
3385 declare var CanvasPattern: {
3386 prototype: CanvasPattern;
3387 new(): CanvasPattern;
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;
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;
3401 declare var CanvasRenderingContext2D: {
3402 prototype: CanvasRenderingContext2D;
3403 new(): CanvasRenderingContext2D;
3406 interface CanvasShadowStyles {
3408 shadowColor: string;
3409 shadowOffsetX: number;
3410 shadowOffsetY: number;
3413 interface CanvasState {
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;
3424 interface CanvasTextDrawingStyles {
3425 direction: CanvasDirection;
3427 textAlign: CanvasTextAlign;
3428 textBaseline: CanvasTextBaseline;
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;
3442 interface CanvasUserInterface {
3443 drawFocusIfNeeded(element: Element): void;
3444 drawFocusIfNeeded(path: Path2D, element: Element): void;
3445 scrollPathIntoView(): void;
3446 scrollPathIntoView(path: Path2D): void;
3449 interface CaretPosition {
3450 readonly offset: number;
3451 readonly offsetNode: Node;
3452 getClientRect(): DOMRect | null;
3455 declare var CaretPosition: {
3456 prototype: CaretPosition;
3457 new(): CaretPosition;
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 {
3464 declare var ChannelMergerNode: {
3465 prototype: ChannelMergerNode;
3466 new(context: BaseAudioContext, options?: ChannelMergerOptions): ChannelMergerNode;
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 {
3473 declare var ChannelSplitterNode: {
3474 prototype: ChannelSplitterNode;
3475 new(context: BaseAudioContext, options?: ChannelSplitterOptions): ChannelSplitterNode;
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 {
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;
3490 declare var CharacterData: {
3491 prototype: CharacterData;
3492 new(): CharacterData;
3495 interface ChildNode extends Node {
3497 * Inserts nodes just after node, while replacing strings in nodes with equivalent Text nodes.
3499 * Throws a "HierarchyRequestError" DOMException if the constraints of the node tree are violated.
3501 after(...nodes: (Node | string)[]): void;
3503 * Inserts nodes just before node, while replacing strings in nodes with equivalent Text nodes.
3505 * Throws a "HierarchyRequestError" DOMException if the constraints of the node tree are violated.
3507 before(...nodes: (Node | string)[]): void;
3513 * Replaces node with nodes, while replacing strings in nodes with equivalent Text nodes.
3515 * Throws a "HierarchyRequestError" DOMException if the constraints of the node tree are violated.
3517 replaceWith(...nodes: (Node | string)[]): void;
3520 interface ClientRect {
3522 readonly height: number;
3526 readonly width: number;
3529 declare var ClientRect: {
3530 prototype: ClientRect;
3534 interface ClientRectList {
3535 readonly length: number;
3536 item(index: number): ClientRect;
3537 [index: number]: ClientRect;
3540 declare var ClientRectList: {
3541 prototype: ClientRectList;
3542 new(): ClientRectList;
3545 interface Clipboard extends EventTarget {
3546 readText(): Promise<string>;
3547 writeText(data: string): Promise<void>;
3550 declare var Clipboard: {
3551 prototype: Clipboard;
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;
3560 declare var ClipboardEvent: {
3561 prototype: ClipboardEvent;
3562 new(type: string, eventInitDict?: ClipboardEventInit): ClipboardEvent;
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 {
3568 * Returns the WebSocket connection close code provided by the server.
3570 readonly code: number;
3572 * Returns the WebSocket connection close reason provided by the server.
3574 readonly reason: string;
3576 * Returns true if the connection closed cleanly; false otherwise.
3578 readonly wasClean: boolean;
3581 declare var CloseEvent: {
3582 prototype: CloseEvent;
3583 new(type: string, eventInitDict?: CloseEventInit): CloseEvent;
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 {
3590 declare var Comment: {
3592 new(data?: string): Comment;
3595 /** The DOM CompositionEvent represents events that occur due to the user indirectly entering text. */
3596 interface CompositionEvent extends UIEvent {
3597 readonly data: string;
3600 declare var CompositionEvent: {
3601 prototype: CompositionEvent;
3602 new(type: string, eventInitDict?: CompositionEventInit): CompositionEvent;
3605 interface ConcatParams extends Algorithm {
3606 algorithmId: Uint8Array;
3607 hash?: string | Algorithm;
3608 partyUInfo: Uint8Array;
3609 partyVInfo: Uint8Array;
3610 privateInfo?: Uint8Array;
3611 publicInfo?: Uint8Array;
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;
3622 declare var ConstantSourceNode: {
3623 prototype: ConstantSourceNode;
3624 new(context: BaseAudioContext, options?: ConstantSourceOptions): ConstantSourceNode;
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;
3633 declare var ConvolverNode: {
3634 prototype: ConvolverNode;
3635 new(context: BaseAudioContext, options?: ConvolverOptions): ConvolverNode;
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;
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;
3655 declare var CountQueuingStrategy: {
3656 prototype: CountQueuingStrategy;
3657 new(options: { highWaterMark: number }): CountQueuingStrategy;
3660 interface Credential {
3661 readonly id: string;
3662 readonly type: string;
3665 declare var Credential: {
3666 prototype: Credential;
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>;
3677 declare var CredentialsContainer: {
3678 prototype: CredentialsContainer;
3679 new(): CredentialsContainer;
3682 /** Basic cryptography features available in the current context. It allows access to a cryptographically strong random number generator and to cryptographic primitives. */
3684 readonly subtle: SubtleCrypto;
3685 getRandomValues<T extends Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | null>(array: T): T;
3688 declare var Crypto: {
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[];
3701 declare var CryptoKey: {
3702 prototype: CryptoKey;
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;
3712 declare var CryptoKeyPair: {
3713 prototype: CryptoKeyPair;
3714 new(): CryptoKeyPair;
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>;
3724 declare var CustomElementRegistry: {
3725 prototype: CustomElementRegistry;
3726 new(): CustomElementRegistry;
3729 interface CustomEvent<T = any> extends Event {
3731 * Returns any custom data event was created with. Typically used for synthetic events.
3734 initCustomEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, detailArg: T): void;
3737 declare var CustomEvent: {
3738 prototype: CustomEvent;
3739 new<T>(typeArg: string, eventInitDict?: CustomEventInit<T>): CustomEvent<T>;
3742 /** An error object that contains an error name. */
3743 interface DOMError {
3744 readonly name: string;
3748 declare var DOMError: {
3749 prototype: DOMError;
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;
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;
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;
3821 hasFeature(...args: any[]): true;
3824 declare var DOMImplementation: {
3825 prototype: DOMImplementation;
3826 new(): DOMImplementation;
3829 interface DOML2DeprecatedColorProperty {
3833 interface DOMMatrix extends DOMMatrixReadOnly {
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;
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;
3878 type SVGMatrix = DOMMatrix;
3879 declare var SVGMatrix: typeof DOMMatrix;
3881 type WebKitCSSMatrix = DOMMatrix;
3882 declare var WebKitCSSMatrix: typeof DOMMatrix;
3884 interface DOMMatrixReadOnly {
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;
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;
3919 scaleNonUniform(scaleX?: number, scaleY?: number): DOMMatrix;
3920 skewX(sx?: number): DOMMatrix;
3921 skewY(sy?: number): DOMMatrix;
3922 toFloat32Array(): Float32Array;
3923 toFloat64Array(): Float64Array;
3925 transformPoint(point?: DOMPointInit): DOMPoint;
3926 translate(tx?: number, ty?: number, tz?: number): DOMMatrix;
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;
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;
3944 declare var DOMParser: {
3945 prototype: DOMParser;
3949 interface DOMPoint extends DOMPointReadOnly {
3956 declare var DOMPoint: {
3957 prototype: DOMPoint;
3958 new(x?: number, y?: number, z?: number, w?: number): DOMPoint;
3959 fromPoint(other?: DOMPointInit): DOMPoint;
3962 type SVGPoint = DOMPoint;
3963 declare var SVGPoint: typeof DOMPoint;
3965 interface DOMPointReadOnly {
3970 matrixTransform(matrix?: DOMMatrixInit): DOMPoint;
3974 declare var DOMPointReadOnly: {
3975 prototype: DOMPointReadOnly;
3976 new(x?: number, y?: number, z?: number, w?: number): DOMPointReadOnly;
3977 fromPoint(other?: DOMPointInit): DOMPointReadOnly;
3981 readonly p1: DOMPoint;
3982 readonly p2: DOMPoint;
3983 readonly p3: DOMPoint;
3984 readonly p4: DOMPoint;
3985 getBounds(): DOMRect;
3989 declare var DOMQuad: {
3991 new(p1?: DOMPointInit, p2?: DOMPointInit, p3?: DOMPointInit, p4?: DOMPointInit): DOMQuad;
3992 fromQuad(other?: DOMQuadInit): DOMQuad;
3993 fromRect(other?: DOMRectInit): DOMQuad;
3996 interface DOMRect extends DOMRectReadOnly {
4003 declare var DOMRect: {
4005 new(x?: number, y?: number, width?: number, height?: number): DOMRect;
4006 fromRect(other?: DOMRectInit): DOMRect;
4009 type SVGRect = DOMRect;
4010 declare var SVGRect: typeof DOMRect;
4012 interface DOMRectList {
4013 readonly length: number;
4014 item(index: number): DOMRect | null;
4015 [index: number]: DOMRect;
4018 declare var DOMRectList: {
4019 prototype: DOMRectList;
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;
4035 declare var DOMRectReadOnly: {
4036 prototype: DOMRectReadOnly;
4037 new(x?: number, y?: number, width?: number, height?: number): DOMRectReadOnly;
4038 fromRect(other?: DOMRectInit): DOMRectReadOnly;
4041 interface DOMSettableTokenList extends DOMTokenList {
4045 declare var DOMSettableTokenList: {
4046 prototype: DOMSettableTokenList;
4047 new(): DOMSettableTokenList;
4050 /** A type returned by some APIs which contains a list of DOMString (strings). */
4051 interface DOMStringList {
4053 * Returns the number of strings in strings.
4055 readonly length: number;
4057 * Returns true if strings contains string, and false otherwise.
4059 contains(string: string): boolean;
4061 * Returns the string with index index from strings.
4063 item(index: number): string | null;
4064 [index: number]: string;
4067 declare var DOMStringList: {
4068 prototype: DOMStringList;
4069 new(): DOMStringList;
4072 /** Used by the dataset HTML attribute to represent data for custom attributes added to elements. */
4073 interface DOMStringMap {
4074 [name: string]: string | undefined;
4077 declare var DOMStringMap: {
4078 prototype: DOMStringMap;
4079 new(): DOMStringMap;
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 {
4085 * Returns the number of tokens.
4087 readonly length: number;
4089 * Returns the associated set as string.
4091 * Can be set, to change the associated attribute.
4096 * Adds all arguments passed, except those already present.
4098 * Throws a "SyntaxError" DOMException if one of the arguments is the empty string.
4100 * Throws an "InvalidCharacterError" DOMException if one of the arguments contains any ASCII whitespace.
4102 add(...tokens: string[]): void;
4104 * Returns true if token is present, and false otherwise.
4106 contains(token: string): boolean;
4108 * Returns the token with index index.
4110 item(index: number): string | null;
4112 * Removes arguments passed, if they are present.
4114 * Throws a "SyntaxError" DOMException if one of the arguments is the empty string.
4116 * Throws an "InvalidCharacterError" DOMException if one of the arguments contains any ASCII whitespace.
4118 remove(...tokens: string[]): void;
4120 * Replaces token with newToken.
4122 * Returns true if token was replaced with newToken, and false otherwise.
4124 * Throws a "SyntaxError" DOMException if one of the arguments is the empty string.
4126 * Throws an "InvalidCharacterError" DOMException if one of the arguments contains any ASCII whitespace.
4128 replace(oldToken: string, newToken: string): void;
4130 * Returns true if token is in the associated attribute's supported tokens. Returns false otherwise.
4132 * Throws a TypeError if the associated attribute has no supported tokens defined.
4134 supports(token: string): boolean;
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()).
4138 * Returns true if token is now present, and false otherwise.
4140 * Throws a "SyntaxError" DOMException if token is empty.
4142 * Throws an "InvalidCharacterError" DOMException if token contains any spaces.
4144 toggle(token: string, force?: boolean): boolean;
4145 forEach(callbackfn: (value: string, key: number, parent: DOMTokenList) => void, thisArg?: any): void;
4146 [index: number]: string;
4149 declare var DOMTokenList: {
4150 prototype: DOMTokenList;
4151 new(): DOMTokenList;
4154 interface DataCue extends TextTrackCue {
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;
4162 declare var DataCue: {
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 {
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.
4172 * Can be set, to change the selected operation.
4174 * The possible values are "none", "copy", "link", and "move".
4178 * Returns the kinds of operations that are to be allowed.
4180 * Can be set (during the dragstart event), to change the allowed operations.
4182 * The possible values are "none", "copy", "copyLink", "copyMove", "link", "linkMove", "move", "all", and "uninitialized",
4184 effectAllowed: string;
4186 * Returns a FileList of the files being dragged, if any.
4188 readonly files: FileList;
4190 * Returns a DataTransferItemList object, with the drag data.
4192 readonly items: DataTransferItemList;
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".
4196 readonly types: ReadonlyArray<string>;
4198 * Removes the data of the specified formats. Removes all data if the argument is omitted.
4200 clearData(format?: string): void;
4202 * Returns the specified data. If there is no such data, returns the empty string.
4204 getData(format: string): string;
4206 * Adds the specified data.
4208 setData(format: string, data: string): void;
4210 * Uses the given element to update the drag feedback, replacing any previously specified feedback.
4212 setDragImage(image: Element, x: number, y: number): void;
4215 declare var DataTransfer: {
4216 prototype: DataTransfer;
4217 new(): DataTransfer;
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 {
4223 * Returns the drag data item kind, one of: "string", "file".
4225 readonly kind: string;
4227 * Returns the drag data item type string.
4229 readonly type: string;
4231 * Returns a File object, if the drag data item kind is File.
4233 getAsFile(): File | null;
4235 * Invokes the callback with the string data as the argument, if the drag data item kind is text.
4237 getAsString(callback: FunctionStringCallback | null): void;
4238 webkitGetAsEntry(): any;
4241 declare var DataTransferItem: {
4242 prototype: DataTransferItem;
4243 new(): DataTransferItem;
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 {
4249 * Returns the number of items in the drag data store.
4251 readonly length: number;
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.
4255 add(data: string, type: string): DataTransferItem | null;
4256 add(data: File): DataTransferItem | null;
4258 * Removes all the entries in the drag data store.
4261 item(index: number): DataTransferItem;
4263 * Removes the indexth entry in the drag data store.
4265 remove(index: number): void;
4266 [name: number]: DataTransferItem;
4269 declare var DataTransferItemList: {
4270 prototype: DataTransferItemList;
4271 new(): DataTransferItemList;
4274 interface DeferredPermissionRequest {
4275 readonly id: number;
4276 readonly type: MSWebViewPermissionType;
4277 readonly uri: string;
4282 declare var DeferredPermissionRequest: {
4283 prototype: DeferredPermissionRequest;
4284 new(): DeferredPermissionRequest;
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;
4292 declare var DelayNode: {
4293 prototype: DelayNode;
4294 new(context: BaseAudioContext, options?: DelayOptions): DelayNode;
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;
4304 declare var DeviceAcceleration: {
4305 prototype: DeviceAcceleration;
4306 new(): DeviceAcceleration;
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;
4314 declare var DeviceLightEvent: {
4315 prototype: DeviceLightEvent;
4316 new(typeArg: string, eventInitDict?: DeviceLightEventInit): DeviceLightEvent;
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;
4327 declare var DeviceMotionEvent: {
4328 prototype: DeviceMotionEvent;
4329 new(type: string, eventInitDict?: DeviceMotionEventInit): DeviceMotionEvent;
4330 requestPermission(): Promise<PermissionState>;
4333 interface DeviceMotionEventAcceleration {
4334 readonly x: number | null;
4335 readonly y: number | null;
4336 readonly z: number | null;
4339 interface DeviceMotionEventRotationRate {
4340 readonly alpha: number | null;
4341 readonly beta: number | null;
4342 readonly gamma: number | null;
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;
4353 declare var DeviceOrientationEvent: {
4354 prototype: DeviceOrientationEvent;
4355 new(type: string, eventInitDict?: DeviceOrientationEventInit): DeviceOrientationEvent;
4356 requestPermission(): Promise<PermissionState>;
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;
4366 declare var DeviceRotationRate: {
4367 prototype: DeviceRotationRate;
4368 new(): DeviceRotationRate;
4371 interface DhImportKeyParams extends Algorithm {
4372 generator: Uint8Array;
4376 interface DhKeyAlgorithm extends KeyAlgorithm {
4377 generator: Uint8Array;
4381 interface DhKeyDeriveParams extends Algorithm {
4385 interface DhKeyGenParams extends Algorithm {
4386 generator: Uint8Array;
4390 interface DocumentEventMap extends GlobalEventHandlersEventMap, DocumentAndElementEventHandlersEventMap {
4391 "fullscreenchange": Event;
4392 "fullscreenerror": Event;
4393 "pointerlockchange": Event;
4394 "pointerlockerror": Event;
4395 "readystatechange": Event;
4396 "visibilitychange": Event;
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 {
4402 * Sets or gets the URL for the current document.
4404 readonly URL: string;
4406 * Sets or gets the color of all active links in the document.
4411 * Returns a reference to the collection of elements contained by the object.
4414 readonly all: HTMLAllCollection;
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.
4419 readonly anchors: HTMLCollectionOf<HTMLAnchorElement>;
4421 * Retrieves a collection of all applet objects in the document.
4424 readonly applets: HTMLCollectionOf<HTMLAppletElement>;
4426 * Deprecated. Sets or retrieves a value that indicates the background color behind the object.
4431 * Specifies the beginning and end of the document body.
4435 * Returns document's encoding.
4437 readonly characterSet: string;
4439 * Gets or sets the character set used to encode the object.
4441 readonly charset: string;
4443 * Gets a value that indicates whether standards-compliant mode is switched on for the object.
4445 readonly compatMode: string;
4447 * Returns document's content type.
4449 readonly contentType: string;
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.
4453 * Can be set, to add a new cookie to the element's set of HTTP cookies.
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.
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.
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.
4463 readonly currentScript: HTMLOrSVGScriptElement | null;
4464 readonly defaultView: (WindowProxy & typeof globalThis) | null;
4466 * Sets or gets a value that indicates whether the document can be edited.
4470 * Sets or retrieves a value that indicates the reading order of the object.
4474 * Gets an object representing the document type declaration associated with the current document.
4476 readonly doctype: DocumentType | null;
4478 * Gets a reference to the root node of the document.
4480 readonly documentElement: HTMLElement;
4482 * Returns document's URL.
4484 readonly documentURI: string;
4486 * Sets or gets the security domain of the document.
4490 * Retrieves a collection of all embed objects in the document.
4492 readonly embeds: HTMLCollectionOf<HTMLEmbedElement>;
4494 * Sets or gets the foreground (text) color of the document.
4499 * Retrieves a collection, in source order, of all form objects in the document.
4501 readonly forms: HTMLCollectionOf<HTMLFormElement>;
4503 readonly fullscreen: boolean;
4505 * Returns true if document has the ability to display elements fullscreen and fullscreen is supported, or false otherwise.
4507 readonly fullscreenEnabled: boolean;
4509 * Returns the head element.
4511 readonly head: HTMLHeadElement;
4512 readonly hidden: boolean;
4514 * Retrieves a collection, in source order, of img objects in the document.
4516 readonly images: HTMLCollectionOf<HTMLImageElement>;
4518 * Gets the implementation object of the current document.
4520 readonly implementation: DOMImplementation;
4522 * Returns the character encoding used to create the webpage that is loaded into the document object.
4524 readonly inputEncoding: string;
4526 * Gets the date that the page was last modified, if the page supplies one.
4528 readonly lastModified: string;
4530 * Sets or gets the color of the document links.
4535 * Retrieves a collection of all a objects that specify the href property and all area objects in the document.
4537 readonly links: HTMLCollectionOf<HTMLAnchorElement | HTMLAreaElement>;
4539 * Contains information about the current URL.
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;
4547 * Fires when the state of the object has changed.
4548 * @param ev The event
4550 onreadystatechange: ((this: Document, ev: Event) => any) | null;
4551 onvisibilitychange: ((this: Document, ev: Event) => any) | null;
4553 * Returns document's origin.
4555 readonly origin: string;
4556 readonly ownerDocument: null;
4558 * Return an HTMLCollection of the embed elements in the Document.
4560 readonly plugins: HTMLCollectionOf<HTMLEmbedElement>;
4562 * Retrieves a value that indicates the current state of the object.
4564 readonly readyState: DocumentReadyState;
4566 * Gets the URL of the location that referred the user to the current page.
4568 readonly referrer: string;
4570 * Retrieves a collection of all script objects in the document.
4572 readonly scripts: HTMLCollectionOf<HTMLScriptElement>;
4573 readonly scrollingElement: Element | null;
4574 readonly timeline: DocumentTimeline;
4576 * Contains the title of the document.
4579 readonly visibilityState: VisibilityState;
4581 * Sets or gets the color of the links that the user has visited.
4586 * Moves node from another document and returns it.
4588 * If node is a document, throws a "NotSupportedError" DOMException or, if node is a shadow root, throws a "HierarchyRequestError" DOMException.
4590 adoptNode<T extends Node>(source: T): T;
4592 captureEvents(): void;
4593 caretPositionFromPoint(x: number, y: number): CaretPosition | null;
4595 caretRangeFromPoint(x: number, y: number): Range;
4599 * Closes an output stream and forces the sent data to display.
4603 * Creates an attribute object with a specified name.
4604 * @param name String that sets the attribute object's name.
4606 createAttribute(localName: string): Attr;
4607 createAttributeNS(namespace: string | null, qualifiedName: string): Attr;
4609 * Returns a CDATASection node whose data is data.
4611 createCDATASection(data: string): CDATASection;
4613 * Creates a comment object with the specified data.
4614 * @param data Sets the comment object's data.
4616 createComment(data: string): Comment;
4618 * Creates a new document.
4620 createDocumentFragment(): DocumentFragment;
4622 * Creates an instance of the element for the specified tag.
4623 * @param tagName The name of an element.
4625 createElement<K extends keyof HTMLElementTagNameMap>(tagName: K, options?: ElementCreationOptions): HTMLElementTagNameMap[K];
4627 createElement<K extends keyof HTMLElementDeprecatedTagNameMap>(tagName: K, options?: ElementCreationOptions): HTMLElementDeprecatedTagNameMap[K];
4628 createElement(tagName: string, options?: ElementCreationOptions): HTMLElement;
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.
4632 * If localName does not match the Name production an "InvalidCharacterError" DOMException will be thrown.
4634 * If one of the following conditions is true a "NamespaceError" DOMException will be thrown:
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".
4642 * When supplied, options's is can be used to create a customized built-in element.
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;
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.
4734 createNodeIterator(root: Node, whatToShow?: number, filter?: NodeFilter | null): NodeIterator;
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.
4738 createProcessingInstruction(target: string, data: string): ProcessingInstruction;
4740 * Returns an empty range object that has both of its boundary points positioned at the beginning of the document.
4742 createRange(): Range;
4744 * Creates a text string from the specified value.
4745 * @param data String that specifies the nodeValue property of the text node.
4747 createTextNode(data: string): Text;
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.
4755 createTreeWalker(root: Node, whatToShow?: number, filter?: NodeFilter | null): TreeWalker;
4757 createTreeWalker(root: Node, whatToShow: number, filter: NodeFilter | null, entityReferenceExpansion?: boolean): TreeWalker;
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
4763 elementFromPoint(x: number, y: number): Element | null;
4764 elementsFromPoint(x: number, y: number): Element[];
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.
4771 execCommand(commandId: string, showUI?: boolean, value?: string): boolean;
4773 * Stops document's fullscreen element from being displayed fullscreen and resolves promise when done.
4775 exitFullscreen(): Promise<void>;
4776 exitPointerLock(): void;
4777 getAnimations(): Animation[];
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.
4782 getElementById(elementId: string): HTMLElement | null;
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.
4786 getElementsByClassName(classNames: string): HTMLCollectionOf<Element>;
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.
4791 getElementsByName(elementName: string): NodeListOf<HTMLElement>;
4793 * Retrieves a collection of objects based on the specified element name.
4794 * @param name Specifies the name of an element.
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>;
4800 * If namespace and localName are "*" returns a HTMLCollection of all descendant elements.
4802 * If only namespace is "*" returns a HTMLCollection of all descendant elements whose local name is localName.
4804 * If only localName is "*" returns a HTMLCollection of all descendant elements whose namespace is namespace.
4806 * Otherwise, returns a HTMLCollection of all descendant elements whose namespace is namespace and local name is localName.
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>;
4812 * Returns an object representing the current selection of the document that is loaded into the object displaying a webpage.
4814 getSelection(): Selection | null;
4816 * Gets a value indicating whether the object currently has focus.
4818 hasFocus(): boolean;
4820 * Returns a copy of node. If deep is true, the copy also includes the node's descendants.
4822 * If node is a document or a shadow root, throws a "NotSupportedError" DOMException.
4824 importNode<T extends Node>(importedNode: T, deep: boolean): T;
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.
4832 open(url?: string, name?: string, features?: string, replace?: boolean): Document;
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.
4837 queryCommandEnabled(commandId: string): boolean;
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.
4842 queryCommandIndeterm(commandId: string): boolean;
4844 * Returns a Boolean value that indicates the current state of the command.
4845 * @param commandId String that specifies a command identifier.
4847 queryCommandState(commandId: string): boolean;
4849 * Returns a Boolean value that indicates whether the current command is supported on the current range.
4850 * @param commandId Specifies a command identifier.
4852 queryCommandSupported(commandId: string): boolean;
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.
4857 queryCommandValue(commandId: string): string;
4859 releaseEvents(): void;
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.
4864 write(...text: string[]): void;
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.
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;
4876 declare var Document: {
4877 prototype: Document;
4881 interface DocumentAndElementEventHandlersEventMap {
4882 "copy": ClipboardEvent;
4883 "cut": ClipboardEvent;
4884 "paste": ClipboardEvent;
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;
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;
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;
4984 declare var DocumentFragment: {
4985 prototype: DocumentFragment;
4986 new(): DocumentFragment;
4989 interface DocumentOrShadowRoot {
4990 readonly activeElement: Element | null;
4992 * Returns document's fullscreen element.
4994 readonly fullscreenElement: Element | null;
4995 readonly pointerLockElement: Element | null;
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.
4999 readonly styleSheets: StyleSheetList;
5000 caretPositionFromPoint(x: number, y: number): CaretPosition | null;
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;
5008 interface DocumentTimeline extends AnimationTimeline {
5011 declare var DocumentTimeline: {
5012 prototype: DocumentTimeline;
5013 new(options?: DocumentTimelineOptions): DocumentTimeline;
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;
5024 declare var DocumentType: {
5025 prototype: DocumentType;
5026 new(): DocumentType;
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 {
5032 * Returns the DataTransfer object for the event.
5034 readonly dataTransfer: DataTransfer | null;
5037 declare var DragEvent: {
5038 prototype: DragEvent;
5039 new(type: string, eventInitDict?: DragEventInit): DragEvent;
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;
5052 declare var DynamicsCompressorNode: {
5053 prototype: DynamicsCompressorNode;
5054 new(context: BaseAudioContext, options?: DynamicsCompressorOptions): DynamicsCompressorNode;
5057 interface EXT_blend_minmax {
5058 readonly MAX_EXT: GLenum;
5059 readonly MIN_EXT: GLenum;
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 {
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;
5073 interface EXT_shader_texture_lod {
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;
5082 interface ElementEventMap {
5083 "fullscreenchange": Event;
5084 "fullscreenerror": Event;
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;
5092 * Allows for manipulation of element's class content attribute as a set of whitespace-separated tokens through a DOMTokenList object.
5094 readonly classList: DOMTokenList;
5096 * Returns the value of element's class content attribute. Can be set to change it.
5099 readonly clientHeight: number;
5100 readonly clientLeft: number;
5101 readonly clientTop: number;
5102 readonly clientWidth: number;
5104 * Returns the value of element's id content attribute. Can be set to change it.
5108 * Returns the local name.
5110 readonly localName: string;
5112 * Returns the namespace.
5114 readonly namespaceURI: string | null;
5115 onfullscreenchange: ((this: Element, ev: Event) => any) | null;
5116 onfullscreenerror: ((this: Element, ev: Event) => any) | null;
5118 readonly ownerDocument: Document;
5120 * Returns the namespace prefix.
5122 readonly prefix: string | null;
5123 readonly scrollHeight: number;
5126 readonly scrollWidth: number;
5128 * Returns element's shadow root, if any, and if shadow root's mode is "open", and null otherwise.
5130 readonly shadowRoot: ShadowRoot | null;
5132 * Returns the value of element's slot content attribute. Can be set to change it.
5136 * Returns the HTML-uppercased qualified name.
5138 readonly tagName: string;
5140 * Creates a shadow root for element and returns it.
5142 attachShadow(init: ShadowRootInit): ShadowRoot;
5144 * Returns the first (starting at element) inclusive ancestor that matches selectors, and null otherwise.
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;
5150 * Returns element's first attribute whose qualified name is qualifiedName, and null if there is no such attribute otherwise.
5152 getAttribute(qualifiedName: string): string | null;
5154 * Returns element's attribute whose namespace is namespace and local name is localName, and null if there is no such attribute otherwise.
5156 getAttributeNS(namespace: string | null, localName: string): string | null;
5158 * Returns the qualified names of all element's attributes. Can contain duplicates.
5160 getAttributeNames(): string[];
5161 getAttributeNode(name: string): Attr | null;
5162 getAttributeNodeNS(namespaceURI: string, localName: string): Attr | null;
5163 getBoundingClientRect(): DOMRect;
5164 getClientRects(): DOMRectList;
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.
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>;
5176 * Returns true if element has an attribute whose qualified name is qualifiedName, and false otherwise.
5178 hasAttribute(qualifiedName: string): boolean;
5180 * Returns true if element has an attribute whose namespace is namespace and local name is localName.
5182 hasAttributeNS(namespace: string | null, localName: string): boolean;
5184 * Returns true if element has attributes, and false otherwise.
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;
5192 * Returns true if matching selectors against element's root yields element, and false otherwise.
5194 matches(selectors: string): boolean;
5195 msGetRegionContent(): any;
5196 releasePointerCapture(pointerId: number): void;
5198 * Removes element's first attribute whose qualified name is qualifiedName.
5200 removeAttribute(qualifiedName: string): void;
5202 * Removes element's attribute whose namespace is namespace and local name is localName.
5204 removeAttributeNS(namespace: string | null, localName: string): void;
5205 removeAttributeNode(attr: Attr): Attr;
5207 * Displays element fullscreen and resolves promise when done.
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.
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;
5221 * Sets the value of element's first attribute whose qualified name is qualifiedName to value.
5223 setAttribute(qualifiedName: string, value: string): void;
5225 * Sets the value of element's attribute whose namespace is namespace and local name is localName to value.
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;
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.
5234 * Returns true if qualifiedName is now present, and false otherwise.
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;
5244 declare var Element: {
5249 interface ElementCSSInlineStyle {
5250 readonly style: CSSStyleDeclaration;
5253 interface ElementContentEditable {
5254 contentEditable: string;
5256 readonly isContentEditable: boolean;
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;
5268 declare var ErrorEvent: {
5269 prototype: ErrorEvent;
5270 new(type: string, eventInitDict?: ErrorEventInit): ErrorEvent;
5273 /** An event which takes place in the DOM. */
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.
5278 readonly bubbles: boolean;
5279 cancelBubble: boolean;
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.
5283 readonly cancelable: boolean;
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.
5287 readonly composed: boolean;
5289 * Returns the object whose event listener's callback is currently being invoked.
5291 readonly currentTarget: EventTarget | null;
5293 * Returns true if preventDefault() was invoked successfully to indicate cancelation, and false otherwise.
5295 readonly defaultPrevented: boolean;
5297 * Returns the event's phase, which is one of NONE, CAPTURING_PHASE, AT_TARGET, and BUBBLING_PHASE.
5299 readonly eventPhase: number;
5301 * Returns true if event was dispatched by the user agent, and false otherwise.
5303 readonly isTrusted: boolean;
5304 returnValue: boolean;
5306 readonly srcElement: EventTarget | null;
5308 * Returns the object to which event is dispatched (its target).
5310 readonly target: EventTarget | null;
5312 * Returns the event's timestamp as the number of milliseconds measured relative to the time origin.
5314 readonly timeStamp: number;
5316 * Returns the type of event, e.g. "click", "hashchange", or "submit".
5318 readonly type: string;
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.
5322 composedPath(): EventTarget[];
5323 initEvent(type: string, bubbles?: boolean, cancelable?: boolean): void;
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.
5327 preventDefault(): void;
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.
5331 stopImmediatePropagation(): void;
5333 * When dispatched in a tree, invoking this method prevents event from reaching any objects other than the current object.
5335 stopPropagation(): void;
5336 readonly AT_TARGET: number;
5337 readonly BUBBLING_PHASE: number;
5338 readonly CAPTURING_PHASE: number;
5339 readonly NONE: number;
5342 declare var 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;
5351 interface EventListenerObject {
5352 handleEvent(evt: Event): void;
5355 interface EventSourceEventMap {
5357 "message": MessageEvent;
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;
5366 * Returns the state of this EventSource object's connection. It can have the values described below.
5368 readonly readyState: number;
5370 * Returns the URL providing the event stream.
5372 readonly url: string;
5374 * Returns true if the credentials mode for connection requests to the URL providing the event stream is set to "include", and false otherwise.
5376 readonly withCredentials: boolean;
5378 * Aborts any instances of the fetch algorithm started for this EventSource object, and sets the readyState attribute to CLOSED.
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;
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;
5398 /** EventTarget is a DOM interface implemented by objects that can receive events and may have listeners for them. */
5399 interface EventTarget {
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.
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.
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.
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.
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.
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.
5413 addEventListener(type: string, listener: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions): void;
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.
5417 dispatchEvent(event: Event): boolean;
5419 * Removes the event listener in target's event listener list with the same type, callback, and options.
5421 removeEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
5424 declare var EventTarget: {
5425 prototype: EventTarget;
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;
5441 declare var ExtensionScriptApis: {
5442 prototype: ExtensionScriptApis;
5443 new(): ExtensionScriptApis;
5446 interface External {
5448 AddSearchProvider(): void;
5450 IsSearchProviderInstalled(): void;
5453 declare var External: {
5454 prototype: External;
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;
5466 new(fileBits: BlobPart[], fileName: string, options?: FilePropertyBag): File;
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;
5476 declare var FileList: {
5477 prototype: FileList;
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>;
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;
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;
5515 declare var FileReader: {
5516 prototype: FileReader;
5518 readonly DONE: number;
5519 readonly EMPTY: number;
5520 readonly LOADING: number;
5523 /** Focus-related events like focus, blur, focusin, or focusout. */
5524 interface FocusEvent extends UIEvent {
5525 readonly relatedTarget: EventTarget | null;
5528 declare var FocusEvent: {
5529 prototype: FocusEvent;
5530 new(type: string, eventInitDict?: FocusEventInit): FocusEvent;
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;
5542 declare var FocusNavigationEvent: {
5543 prototype: FocusNavigationEvent;
5544 new(type: string, eventInitDict?: FocusNavigationEventInit): FocusNavigationEvent;
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;
5558 declare var FormData: {
5559 prototype: FormData;
5560 new(form?: HTMLFormElement): FormData;
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;
5568 declare var GainNode: {
5569 prototype: GainNode;
5570 new(context: BaseAudioContext, options?: GainOptions): GainNode;
5573 /** This Gamepad API interface defines an individual gamepad or other controller, allowing access to information such as button presses, axis positions, and id. */
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;
5587 declare var Gamepad: {
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;
5599 declare var GamepadButton: {
5600 prototype: GamepadButton;
5601 new(): GamepadButton;
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;
5609 declare var GamepadEvent: {
5610 prototype: GamepadEvent;
5611 new(type: string, eventInitDict: GamepadEventInit): GamepadEvent;
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>;
5620 declare var GamepadHapticActuator: {
5621 prototype: GamepadHapticActuator;
5622 new(): GamepadHapticActuator;
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;
5637 declare var GamepadPose: {
5638 prototype: GamepadPose;
5642 interface GenericTransformStream {
5644 * Returns a readable stream whose chunks are strings resulting from running encoding's decoder on the chunks written to writable.
5646 readonly readable: ReadableStream;
5648 * Returns a writable stream which accepts [AllowShared] BufferSource chunks and runs them through encoding's decoder before making them available to readable.
5650 * Typically this will be used via the pipeThrough() method on a ReadableStream source.
5653 * var decoder = new TextDecoderStream(encoding);
5655 * .pipeThrough(decoder)
5656 * .pipeTo(textWritable);
5659 * If the error mode is "fatal" and encoding's decoder returns error, both readable and writable will be errored with a TypeError.
5661 readonly writable: WritableStream;
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;
5671 interface GlobalEventHandlersEventMap {
5673 "animationcancel": AnimationEvent;
5674 "animationend": AnimationEvent;
5675 "animationiteration": AnimationEvent;
5676 "animationstart": AnimationEvent;
5677 "auxclick": MouseEvent;
5681 "canplaythrough": Event;
5683 "click": MouseEvent;
5685 "contextmenu": MouseEvent;
5687 "dblclick": MouseEvent;
5689 "dragend": DragEvent;
5690 "dragenter": DragEvent;
5692 "dragleave": DragEvent;
5693 "dragover": DragEvent;
5694 "dragstart": DragEvent;
5696 "durationchange": Event;
5699 "error": ErrorEvent;
5700 "focus": FocusEvent;
5701 "focusin": FocusEvent;
5702 "focusout": FocusEvent;
5703 "gotpointercapture": PointerEvent;
5706 "keydown": KeyboardEvent;
5707 "keypress": KeyboardEvent;
5708 "keyup": KeyboardEvent;
5710 "loadeddata": Event;
5711 "loadedmetadata": 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;
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;
5737 "securitypolicyviolation": SecurityPolicyViolationEvent;
5741 "selectionchange": Event;
5742 "selectstart": Event;
5746 "timeupdate": 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;
5758 "wheel": WheelEvent;
5761 interface GlobalEventHandlers {
5763 * Fires when the user aborts the download.
5764 * @param ev The event.
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;
5773 * Fires when the object loses the input focus.
5774 * @param ev The focus event.
5776 onblur: ((this: GlobalEventHandlers, ev: FocusEvent) => any) | null;
5777 oncancel: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5779 * Occurs when playback is possible, but would require further buffering.
5780 * @param ev The event.
5782 oncanplay: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5783 oncanplaythrough: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5785 * Fires when the contents of the object or selection have changed.
5786 * @param ev The event.
5788 onchange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5790 * Fires when the user clicks the left mouse button on the object
5791 * @param ev The mouse event.
5793 onclick: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
5794 onclose: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5796 * Fires when the user clicks the right mouse button in the client area, opening the context menu.
5797 * @param ev The mouse event.
5799 oncontextmenu: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
5800 oncuechange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5802 * Fires when the user double-clicks the object.
5803 * @param ev The mouse event.
5805 ondblclick: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
5807 * Fires on the source object continuously during a drag operation.
5808 * @param ev The event.
5810 ondrag: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
5812 * Fires on the source object when the user releases the mouse at the close of a drag operation.
5813 * @param ev The event.
5815 ondragend: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
5817 * Fires on the target element when the user drags the object to a valid drop target.
5818 * @param ev The drag event.
5820 ondragenter: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
5821 ondragexit: ((this: GlobalEventHandlers, ev: Event) => any) | null;
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.
5826 ondragleave: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
5828 * Fires on the target element continuously while the user drags the object over a valid drop target.
5829 * @param ev The event.
5831 ondragover: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
5833 * Fires on the source object when the user starts to drag a text selection or selected object.
5834 * @param ev The event.
5836 ondragstart: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
5837 ondrop: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
5839 * Occurs when the duration attribute is updated.
5840 * @param ev The event.
5842 ondurationchange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5844 * Occurs when the media element is reset to its initial state.
5845 * @param ev The event.
5847 onemptied: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5849 * Occurs when the end of playback is reached.
5850 * @param ev The event
5852 onended: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5854 * Fires when an error occurs during object loading.
5855 * @param ev The event.
5857 onerror: OnErrorEventHandler;
5859 * Fires when the object receives focus.
5860 * @param ev The event.
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;
5867 * Fires when the user presses a key.
5868 * @param ev The keyboard event
5870 onkeydown: ((this: GlobalEventHandlers, ev: KeyboardEvent) => any) | null;
5872 * Fires when the user presses an alphanumeric key.
5873 * @param ev The event.
5875 onkeypress: ((this: GlobalEventHandlers, ev: KeyboardEvent) => any) | null;
5877 * Fires when the user releases a key.
5878 * @param ev The keyboard event
5880 onkeyup: ((this: GlobalEventHandlers, ev: KeyboardEvent) => any) | null;
5882 * Fires immediately after the browser loads the object.
5883 * @param ev The event.
5885 onload: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5887 * Occurs when media data is loaded at the current playback position.
5888 * @param ev The event.
5890 onloadeddata: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5892 * Occurs when the duration and dimensions of the media have been determined.
5893 * @param ev The event.
5895 onloadedmetadata: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5897 * Occurs when Internet Explorer begins looking for media data.
5898 * @param ev The event.
5900 onloadstart: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5901 onlostpointercapture: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
5903 * Fires when the user clicks the object with either mouse button.
5904 * @param ev The mouse event.
5906 onmousedown: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
5907 onmouseenter: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
5908 onmouseleave: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
5910 * Fires when the user moves the mouse over the object.
5911 * @param ev The mouse event.
5913 onmousemove: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
5915 * Fires when the user moves the mouse pointer outside the boundaries of the object.
5916 * @param ev The mouse event.
5918 onmouseout: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
5920 * Fires when the user moves the mouse pointer into the object.
5921 * @param ev The mouse event.
5923 onmouseover: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
5925 * Fires when the user releases a mouse button while the mouse is over the object.
5926 * @param ev The mouse event.
5928 onmouseup: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
5930 * Occurs when playback is paused.
5931 * @param ev The event.
5933 onpause: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5935 * Occurs when the play method is requested.
5936 * @param ev The event.
5938 onplay: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5940 * Occurs when the audio or video has started playing.
5941 * @param ev The event.
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;
5953 * Occurs to indicate progress while downloading media data.
5954 * @param ev The event.
5956 onprogress: ((this: GlobalEventHandlers, ev: ProgressEvent) => any) | null;
5958 * Occurs when the playback rate is increased or decreased.
5959 * @param ev The event.
5961 onratechange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5963 * Fires when the user resets a form.
5964 * @param ev The event.
5966 onreset: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5967 onresize: ((this: GlobalEventHandlers, ev: UIEvent) => any) | null;
5969 * Fires when the user repositions the scroll box in the scroll bar on the object.
5970 * @param ev The event.
5972 onscroll: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5973 onsecuritypolicyviolation: ((this: GlobalEventHandlers, ev: SecurityPolicyViolationEvent) => any) | null;
5975 * Occurs when the seek operation ends.
5976 * @param ev The event.
5978 onseeked: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5980 * Occurs when the current playback position is moved.
5981 * @param ev The event.
5983 onseeking: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5985 * Fires when the current selection changes.
5986 * @param ev The event.
5988 onselect: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5989 onselectionchange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5990 onselectstart: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5992 * Occurs when the download has stopped.
5993 * @param ev The event.
5995 onstalled: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5996 onsubmit: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5998 * Occurs if the load operation has been intentionally halted.
5999 * @param ev The event.
6001 onsuspend: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6003 * Occurs to indicate the current playback position.
6004 * @param ev The event.
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;
6017 * Occurs when the volume is changed, or playback is muted or unmuted.
6018 * @param ev The event.
6020 onvolumechange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6022 * Occurs when playback stops because the next frame of a video resource is not available.
6023 * @param ev The event.
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;
6033 interface HTMLAllCollection {
6035 * Returns the number of elements in the collection.
6037 readonly length: number;
6039 * Returns the item with index index from the collection (determined by tree order).
6041 item(nameOrIndex?: string): HTMLCollection | Element | null;
6043 * Returns the item with ID or name name from the collection.
6045 * If there are multiple matching items, then an HTMLCollection object containing all those elements is returned.
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.
6049 namedItem(name: string): HTMLCollection | Element | null;
6050 [index: number]: Element;
6053 declare var HTMLAllCollection: {
6054 prototype: HTMLAllCollection;
6055 new(): HTMLAllCollection;
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 {
6061 * Sets or retrieves the character set used to encode the object.
6066 * Sets or retrieves the coordinates of the object.
6072 * Sets or retrieves the language code of the object.
6076 * Sets or retrieves the shape of the object.
6081 referrerPolicy: string;
6083 * Sets or retrieves the relationship between the object and the destination of the link.
6086 readonly relList: DOMTokenList;
6088 * Sets or retrieves the relationship between the object and the destination of the link.
6093 * Sets or retrieves the shape of the object.
6098 * Sets or retrieves the window or frame at which to target content.
6102 * Retrieves or sets the text of the object as a 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;
6112 declare var HTMLAnchorElement: {
6113 prototype: HTMLAnchorElement;
6114 new(): HTMLAnchorElement;
6117 interface HTMLAppletElement extends HTMLElement {
6121 * Sets or retrieves a text alternative to the graphic.
6126 * Sets or retrieves a character string that can be used to implement your own archive functionality for the object.
6133 * Sets or retrieves the URL of the component.
6137 readonly form: HTMLFormElement | null;
6139 * Sets or retrieves the height of the object.
6146 * Sets or retrieves the shape of the object.
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;
6162 declare var HTMLAppletElement: {
6163 prototype: HTMLAppletElement;
6164 new(): HTMLAppletElement;
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 {
6170 * Sets or retrieves a text alternative to the graphic.
6174 * Sets or retrieves the coordinates of the object.
6179 * Sets or gets whether clicks in this region cause action.
6184 referrerPolicy: string;
6186 readonly relList: DOMTokenList;
6188 * Sets or retrieves the shape of the object.
6192 * Sets or retrieves the window or frame at which to target content.
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;
6201 declare var HTMLAreaElement: {
6202 prototype: HTMLAreaElement;
6203 new(): HTMLAreaElement;
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;
6214 declare var HTMLAudioElement: {
6215 prototype: HTMLAudioElement;
6216 new(): HTMLAudioElement;
6219 /** A HTML line break element (<br>). It inherits from HTMLElement. */
6220 interface HTMLBRElement extends HTMLElement {
6222 * Sets or retrieves the side on which floating objects are not to be positioned when any IHTMLBlockElement is inserted into the document.
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;
6232 declare var HTMLBRElement: {
6233 prototype: HTMLBRElement;
6234 new(): HTMLBRElement;
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 {
6240 * Gets or sets the baseline URL on which relative links are based.
6244 * Sets or retrieves the window or frame at which to target content.
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;
6253 declare var HTMLBaseElement: {
6254 prototype: HTMLBaseElement;
6255 new(): HTMLBaseElement;
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 {
6261 * Sets or retrieves the current typeface family.
6266 * Sets or retrieves the font size of the object.
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;
6276 declare var HTMLBaseFontElement: {
6277 prototype: HTMLBaseFontElement;
6278 new(): HTMLBaseFontElement;
6281 interface HTMLBodyElementEventMap extends HTMLElementEventMap, WindowEventHandlersEventMap {
6282 "orientationchange": Event;
6285 /** Provides special properties (beyond those inherited from the regular HTMLElement interface) for manipulating <body> elements. */
6286 interface HTMLBodyElement extends HTMLElement, WindowEventHandlers {
6296 onorientationchange: ((this: HTMLBodyElement, ev: Event) => any) | null;
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;
6307 declare var HTMLBodyElement: {
6308 prototype: HTMLBodyElement;
6309 new(): HTMLBodyElement;
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 {
6316 * Retrieves a reference to the form that the object is embedded in.
6318 readonly form: HTMLFormElement | null;
6320 * Overrides the action attribute (where the data on a form is sent) on the parent form element.
6324 * Used to override the encoding (formEnctype attribute) specified on the form element.
6326 formEnctype: string;
6328 * Overrides the submit method attribute previously specified on a form element.
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.
6334 formNoValidate: boolean;
6336 * Overrides the target attribute on a form element.
6339 readonly labels: NodeListOf<HTMLLabelElement>;
6341 * Sets or retrieves the name of the object.
6345 * Gets the classification and default behavior of the button.
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.
6351 readonly validationMessage: string;
6353 * Returns a ValidityState object that represents the validity states of an element.
6355 readonly validity: ValidityState;
6357 * Sets or retrieves the default or selected value of the control.
6361 * Returns whether an element will successfully validate based on forms validation rules and constraints.
6363 readonly willValidate: boolean;
6365 * Returns whether a form will validate when it is submitted, without having to submit it.
6367 checkValidity(): boolean;
6368 reportValidity(): boolean;
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.
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;
6380 declare var HTMLButtonElement: {
6381 prototype: HTMLButtonElement;
6382 new(): HTMLButtonElement;
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 {
6388 * Gets or sets the height of a canvas element on a document.
6392 * Gets or sets the width of a canvas element on a document.
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");
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;
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.
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;
6417 declare var HTMLCanvasElement: {
6418 prototype: HTMLCanvasElement;
6419 new(): HTMLCanvasElement;
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 {
6425 * Sets or retrieves the number of objects in a collection.
6427 readonly length: number;
6429 * Retrieves an object from various collections.
6431 item(index: number): Element | null;
6432 [index: number]: Element;
6435 interface HTMLCollection extends HTMLCollectionBase {
6437 * Retrieves a select object or an object from an options collection.
6439 namedItem(name: string): Element | null;
6442 declare var HTMLCollection: {
6443 prototype: HTMLCollection;
6444 new(): HTMLCollection;
6447 interface HTMLCollectionOf<T extends Element> extends HTMLCollectionBase {
6448 item(index: number): T | null;
6449 namedItem(name: string): T | null;
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 {
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;
6463 declare var HTMLDListElement: {
6464 prototype: HTMLDListElement;
6465 new(): HTMLDListElement;
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 {
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;
6477 declare var HTMLDataElement: {
6478 prototype: HTMLDataElement;
6479 new(): HTMLDataElement;
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;
6491 declare var HTMLDataListElement: {
6492 prototype: HTMLDataListElement;
6493 new(): HTMLDataListElement;
6496 interface HTMLDetailsElement extends HTMLElement {
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;
6504 declare var HTMLDetailsElement: {
6505 prototype: HTMLDetailsElement;
6506 new(): HTMLDetailsElement;
6509 interface HTMLDialogElement extends HTMLElement {
6511 returnValue: string;
6512 close(returnValue?: string): 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;
6521 declare var HTMLDialogElement: {
6522 prototype: HTMLDialogElement;
6523 new(): HTMLDialogElement;
6526 interface HTMLDirectoryElement extends HTMLElement {
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;
6535 declare var HTMLDirectoryElement: {
6536 prototype: HTMLDirectoryElement;
6537 new(): HTMLDirectoryElement;
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 {
6543 * Sets or retrieves how the object is aligned with adjacent text.
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;
6553 declare var HTMLDivElement: {
6554 prototype: HTMLDivElement;
6555 new(): HTMLDivElement;
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;
6566 declare var HTMLDocument: {
6567 prototype: HTMLDocument;
6568 new(): HTMLDocument;
6571 interface HTMLElementEventMap extends ElementEventMap, GlobalEventHandlersEventMap, DocumentAndElementEventHandlersEventMap {
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 {
6577 readonly accessKeyLabel: string;
6578 autocapitalize: 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;
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;
6599 declare var HTMLElement: {
6600 prototype: HTMLElement;
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 {
6609 * Sets or retrieves the height of the object.
6613 * Sets or retrieves the name of the object.
6618 * Sets or retrieves a URL to be loaded by the object.
6623 * Sets or retrieves the width of the object.
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;
6633 declare var HTMLEmbedElement: {
6634 prototype: HTMLEmbedElement;
6635 new(): HTMLEmbedElement;
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 {
6641 readonly elements: HTMLCollection;
6643 * Retrieves a reference to the form that the object is embedded in.
6645 readonly form: HTMLFormElement | null;
6647 readonly type: string;
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.
6651 readonly validationMessage: string;
6653 * Returns a ValidityState object that represents the validity states of an element.
6655 readonly validity: ValidityState;
6657 * Returns whether an element will successfully validate based on forms validation rules and constraints.
6659 readonly willValidate: boolean;
6661 * Returns whether a form will validate when it is submitted, without having to submit it.
6663 checkValidity(): boolean;
6664 reportValidity(): boolean;
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.
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;
6676 declare var HTMLFieldSetElement: {
6677 prototype: HTMLFieldSetElement;
6678 new(): HTMLFieldSetElement;
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 {
6686 * Sets or retrieves the current typeface family.
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;
6698 declare var HTMLFontElement: {
6699 prototype: HTMLFontElement;
6700 new(): HTMLFontElement;
6703 /** A collection of HTML form control elements. */
6704 interface HTMLFormControlsCollection extends HTMLCollectionBase {
6706 * Returns the item with ID or name name from the collection.
6708 * If there are multiple matching items, then a RadioNodeList object containing all those elements is returned.
6710 namedItem(name: string): RadioNodeList | Element | null;
6713 declare var HTMLFormControlsCollection: {
6714 prototype: HTMLFormControlsCollection;
6715 new(): HTMLFormControlsCollection;
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 {
6721 * Sets or retrieves a list of character encodings for input data that must be accepted by the server processing the form.
6723 acceptCharset: string;
6725 * Sets or retrieves the URL to which the form content is sent for processing.
6729 * Specifies whether autocomplete is applied to an editable text field.
6731 autocomplete: string;
6733 * Retrieves a collection, in source order, of all controls in a given form.
6735 readonly elements: HTMLFormControlsCollection;
6737 * Sets or retrieves the MIME encoding for the form.
6741 * Sets or retrieves the encoding type for the form.
6745 * Sets or retrieves the number of objects in a collection.
6747 readonly length: number;
6749 * Sets or retrieves how to send the form data to the server.
6753 * Sets or retrieves the name of the object.
6757 * Designates a form that is not validated when submitted.
6759 noValidate: boolean;
6761 * Sets or retrieves the window or frame at which to target content.
6765 * Returns whether a form will validate when it is submitted, without having to submit it.
6767 checkValidity(): boolean;
6768 reportValidity(): boolean;
6770 * Fires when the user resets a form.
6774 * Fires when a FORM is about to be submitted.
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;
6785 declare var HTMLFormElement: {
6786 prototype: HTMLFormElement;
6787 new(): HTMLFormElement;
6790 interface HTMLFrameElement extends HTMLElement {
6792 * Retrieves the document object of the page or frame.
6795 readonly contentDocument: Document | null;
6797 * Retrieves the object of the specified.
6800 readonly contentWindow: WindowProxy | null;
6802 * Sets or retrieves whether to display a border for the frame.
6805 frameBorder: string;
6807 * Sets or retrieves a URI to a long description of the object.
6812 * Sets or retrieves the top and bottom margin heights before displaying the text in a frame.
6815 marginHeight: string;
6817 * Sets or retrieves the left and right margin widths before displaying the text in a frame.
6820 marginWidth: string;
6822 * Sets or retrieves the frame name.
6827 * Sets or retrieves whether the user can resize the frame.
6832 * Sets or retrieves whether the frame can be scrolled.
6837 * Sets or retrieves a URL to be loaded by the object.
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;
6847 declare var HTMLFrameElement: {
6848 prototype: HTMLFrameElement;
6849 new(): HTMLFrameElement;
6852 interface HTMLFrameSetElementEventMap extends HTMLElementEventMap, WindowEventHandlersEventMap {
6855 /** Provides special properties (beyond those of the regular HTMLElement interface they also inherit) for manipulating <frameset> elements. */
6856 interface HTMLFrameSetElement extends HTMLElement, WindowEventHandlers {
6858 * Sets or retrieves the frame widths of the object.
6863 * Sets or retrieves the frame heights of the object.
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;
6873 declare var HTMLFrameSetElement: {
6874 prototype: HTMLFrameSetElement;
6875 new(): HTMLFrameSetElement;
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 {
6881 * Sets or retrieves how the object is aligned with adjacent text.
6888 * Sets or retrieves whether the horizontal rule is drawn with 3-D shading.
6895 * Sets or retrieves the width of the object.
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;
6905 declare var HTMLHRElement: {
6906 prototype: HTMLHRElement;
6907 new(): HTMLHRElement;
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;
6918 declare var HTMLHeadElement: {
6919 prototype: HTMLHeadElement;
6920 new(): HTMLHeadElement;
6923 /** The different heading elements. It inherits methods and properties from the HTMLElement interface. */
6924 interface HTMLHeadingElement extends HTMLElement {
6926 * Sets or retrieves a value that indicates the table alignment.
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;
6936 declare var HTMLHeadingElement: {
6937 prototype: HTMLHeadingElement;
6938 new(): HTMLHeadingElement;
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 {
6944 * Sets or retrieves the DTD version that governs the current document.
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;
6954 declare var HTMLHtmlElement: {
6955 prototype: HTMLHtmlElement;
6956 new(): HTMLHtmlElement;
6959 interface HTMLHyperlinkElementUtils {
6965 readonly origin: string;
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 {
6977 * Sets or retrieves how the object is aligned with adjacent text.
6982 allowFullscreen: boolean;
6983 allowPaymentRequest: boolean;
6985 * Retrieves the document object of the page or frame.
6987 readonly contentDocument: Document | null;
6989 * Retrieves the object of the specified.
6991 readonly contentWindow: WindowProxy | null;
6993 * Sets or retrieves whether to display a border for the frame.
6996 frameBorder: string;
6998 * Sets or retrieves the height of the object.
7002 * Sets or retrieves a URI to a long description of the object.
7007 * Sets or retrieves the top and bottom margin heights before displaying the text in a frame.
7010 marginHeight: string;
7012 * Sets or retrieves the left and right margin widths before displaying the text in a frame.
7015 marginWidth: string;
7017 * Sets or retrieves the frame name.
7020 referrerPolicy: ReferrerPolicy;
7021 readonly sandbox: DOMTokenList;
7023 * Sets or retrieves whether the frame can be scrolled.
7028 * Sets or retrieves a URL to be loaded by the object.
7032 * Sets or retrives the content of the page that is to contain.
7036 * Sets or retrieves the width of the object.
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;
7046 declare var HTMLIFrameElement: {
7047 prototype: HTMLIFrameElement;
7048 new(): HTMLIFrameElement;
7051 /** Provides special properties and methods for manipulating <img> elements. */
7052 interface HTMLImageElement extends HTMLElement {
7054 * Sets or retrieves how the object is aligned with adjacent text.
7059 * Sets or retrieves a text alternative to the graphic.
7063 * Specifies the properties of a border drawn around an object.
7068 * Retrieves whether the object is fully loaded.
7070 readonly complete: boolean;
7071 crossOrigin: string | null;
7072 readonly currentSrc: string;
7073 decoding: "async" | "sync" | "auto";
7075 * Sets or retrieves the height of the object.
7079 * Sets or retrieves the width of the border to draw around the object.
7084 * Sets or retrieves whether the image is a server-side image map.
7088 * Sets or retrieves a Uniform Resource Identifier (URI) to a long description of the object.
7095 * Sets or retrieves the name of the object.
7100 * The original height of the image resource before sizing.
7102 readonly naturalHeight: number;
7104 * The original width of the image resource before sizing.
7106 readonly naturalWidth: number;
7107 referrerPolicy: string;
7110 * The address or URL of the a media resource that is to be considered.
7115 * Sets or retrieves the URL, often with a bookmark extension (#name), to use as a client-side image map.
7119 * Sets or retrieves the vertical margin for the object.
7124 * Sets or retrieves the width of the object.
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;
7136 declare var HTMLImageElement: {
7137 prototype: HTMLImageElement;
7138 new(): HTMLImageElement;
7141 /** Provides special properties and methods for manipulating the options, layout, and presentation of <input> elements. */
7142 interface HTMLInputElement extends HTMLElement {
7144 * Sets or retrieves a comma-separated list of content types.
7148 * Sets or retrieves how the object is aligned with adjacent text.
7153 * Sets or retrieves a text alternative to the graphic.
7157 * Specifies whether autocomplete is applied to an editable text field.
7159 autocomplete: string;
7161 * Sets or retrieves the state of the check box or radio button.
7165 * Sets or retrieves the state of the check box or radio button.
7167 defaultChecked: boolean;
7169 * Sets or retrieves the initial contents of the object.
7171 defaultValue: string;
7175 * Returns a FileList object on a file type input object.
7177 files: FileList | null;
7179 * Retrieves a reference to the form that the object is embedded in.
7181 readonly form: HTMLFormElement | null;
7183 * Overrides the action attribute (where the data on a form is sent) on the parent form element.
7187 * Used to override the encoding (formEnctype attribute) specified on the form element.
7189 formEnctype: string;
7191 * Overrides the submit method attribute previously specified on a form element.
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.
7197 formNoValidate: boolean;
7199 * Overrides the target attribute on a form element.
7203 * Sets or retrieves the height of the object.
7206 indeterminate: boolean;
7207 readonly labels: NodeListOf<HTMLLabelElement> | null;
7209 * Specifies the ID of a pre-defined datalist of options for an input element.
7211 readonly list: HTMLElement | null;
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.
7217 * Sets or retrieves the maximum number of characters that the user can enter in a text control.
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.
7226 * Sets or retrieves the Boolean value indicating whether multiple items can be selected from a list.
7230 * Sets or retrieves the name of the object.
7234 * Gets or sets a string containing a regular expression that the user's input must match.
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.
7240 placeholder: string;
7243 * When present, marks an element that can't be submitted without a value.
7246 selectionDirection: "forward" | "backward" | "none" | null;
7248 * Gets or sets the end position or offset of a text selection.
7250 selectionEnd: number | null;
7252 * Gets or sets the starting position or offset of a text selection.
7254 selectionStart: number | null;
7257 * The address or URL of the a media resource that is to be considered.
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.
7265 * Returns the content type of the object.
7269 * Sets or retrieves the URL, often with a bookmark extension (#name), to use as a client-side image map.
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.
7276 readonly validationMessage: string;
7278 * Returns a ValidityState object that represents the validity states of an element.
7280 readonly validity: ValidityState;
7282 * Returns the value of the data at the cursor's current position.
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.
7288 valueAsDate: Date | null;
7290 * Returns the input field value as a number.
7292 valueAsNumber: number;
7294 * Sets or retrieves the width of the object.
7298 * Returns whether an element will successfully validate based on forms validation rules and constraints.
7300 readonly willValidate: boolean;
7302 * Returns whether a form will validate when it is submitted, without having to submit it.
7304 checkValidity(): boolean;
7305 reportValidity(): boolean;
7307 * Makes the selection equal to the current object.
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.
7314 setCustomValidity(error: string): void;
7315 setRangeText(replacement: string): void;
7316 setRangeText(replacement: string, start: number, end: number, selectionMode?: SelectionMode): void;
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.
7323 setSelectionRange(start: number, end: number, direction?: "forward" | "backward" | "none"): void;
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.
7328 stepDown(n?: number): void;
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.
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;
7340 declare var HTMLInputElement: {
7341 prototype: HTMLInputElement;
7342 new(): HTMLInputElement;
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 {
7350 * Sets or retrieves the value of a list item.
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;
7359 declare var HTMLLIElement: {
7360 prototype: HTMLLIElement;
7361 new(): HTMLLIElement;
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;
7368 * Retrieves a reference to the form that the object is embedded in.
7370 readonly form: HTMLFormElement | null;
7372 * Sets or retrieves the object to which the given label object is assigned.
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;
7381 declare var HTMLLabelElement: {
7382 prototype: HTMLLabelElement;
7383 new(): HTMLLabelElement;
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 {
7391 * Retrieves a reference to the form that the object is embedded in.
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;
7400 declare var HTMLLegendElement: {
7401 prototype: HTMLLegendElement;
7402 new(): HTMLLegendElement;
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 {
7409 * Sets or retrieves the character set used to encode the object.
7413 crossOrigin: string | null;
7416 * Sets or retrieves a destination URL or an anchor point.
7420 * Sets or retrieves the language code of the object.
7424 imageSrcset: string;
7427 * Sets or retrieves the media type.
7430 referrerPolicy: string;
7432 * Sets or retrieves the relationship between the object and the destination of the link.
7435 readonly relList: DOMTokenList;
7437 * Sets or retrieves the relationship between the object and the destination of the link.
7441 readonly sizes: DOMTokenList;
7443 * Sets or retrieves the window or frame at which to target content.
7448 * Sets or retrieves the MIME type of the object.
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;
7457 declare var HTMLLinkElement: {
7458 prototype: HTMLLinkElement;
7459 new(): HTMLLinkElement;
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 {
7465 * Retrieves a collection of the area objects defined for the given map object.
7467 readonly areas: HTMLCollection;
7469 * Sets or retrieves the name of the object.
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;
7478 declare var HTMLMapElement: {
7479 prototype: HTMLMapElement;
7480 new(): HTMLMapElement;
7483 interface HTMLMarqueeElementEventMap extends HTMLElementEventMap {
7489 /** Provides methods to manipulate <marquee> elements. */
7490 interface HTMLMarqueeElement extends HTMLElement {
7504 onbounce: ((this: HTMLMarqueeElement, ev: Event) => any) | null;
7506 onfinish: ((this: HTMLMarqueeElement, ev: Event) => any) | null;
7508 onstart: ((this: HTMLMarqueeElement, ev: Event) => any) | null;
7510 scrollAmount: number;
7512 scrollDelay: number;
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;
7529 declare var HTMLMarqueeElement: {
7530 prototype: HTMLMarqueeElement;
7531 new(): HTMLMarqueeElement;
7534 interface HTMLMediaElementEventMap extends HTMLElementEventMap {
7535 "encrypted": MediaEncryptedEvent;
7536 "waitingforkey": Event;
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 {
7542 * Gets or sets a value that indicates whether to start playing the media automatically.
7546 * Gets a collection of buffered time ranges.
7548 readonly buffered: TimeRanges;
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).
7553 crossOrigin: string | null;
7555 * Gets the address or URL of the current media resource that is selected by IHTMLMediaElement.
7557 readonly currentSrc: string;
7559 * Gets or sets the current playback position, in seconds.
7561 currentTime: number;
7562 defaultMuted: boolean;
7564 * Gets or sets the default playback rate when the user is not using fast forward or reverse for a video or audio resource.
7566 defaultPlaybackRate: number;
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.
7570 readonly duration: number;
7572 * Gets information about whether the playback has ended or not.
7574 readonly ended: boolean;
7576 * Returns an object representing the current error state of the audio or video element.
7578 readonly error: MediaError | null;
7580 * Gets or sets a flag to specify whether playback should restart after it completes.
7583 readonly mediaKeys: MediaKeys | null;
7585 * Gets or sets a flag that indicates whether the audio (either audio or the audio track on video media) is muted.
7589 * Gets the current network activity for the element.
7591 readonly networkState: number;
7592 onencrypted: ((this: HTMLMediaElement, ev: MediaEncryptedEvent) => any) | null;
7593 onwaitingforkey: ((this: HTMLMediaElement, ev: Event) => any) | null;
7595 * Gets a flag that specifies whether playback is paused.
7597 readonly paused: boolean;
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.
7601 playbackRate: number;
7603 * Gets TimeRanges for the current media resource that has been played.
7605 readonly played: TimeRanges;
7607 * Gets or sets the current playback position, in seconds.
7610 readonly readyState: number;
7612 * Returns a TimeRanges object that represents the ranges of the current media resource that can be seeked.
7614 readonly seekable: TimeRanges;
7616 * Gets a flag that indicates whether the client is currently moving to a new playback position in the media resource.
7618 readonly seeking: boolean;
7620 * The address or URL of the a media resource that is to be considered.
7623 srcObject: MediaProvider | null;
7624 readonly textTracks: TextTrackList;
7626 * Gets or sets the volume level for audio portions of the media element.
7629 addTextTrack(kind: TextTrackKind, label?: string, language?: string): TextTrack;
7631 * Returns a string that specifies whether the client can play a given media resource type.
7633 canPlayType(type: string): CanPlayTypeResult;
7634 fastSeek(time: number): void;
7636 * Resets the audio or video object and loads a new media resource.
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.
7644 * Loads and starts playback of a media resource.
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;
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;
7677 interface HTMLMenuElement extends HTMLElement {
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;
7686 declare var HTMLMenuElement: {
7687 prototype: HTMLMenuElement;
7688 new(): HTMLMenuElement;
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 {
7694 * Gets or sets meta-information to associate with httpEquiv or name.
7698 * Gets or sets information used to bind the value of a content attribute of a meta element to an HTTP response header.
7702 * Sets or retrieves the value specified in the content attribute of the meta object.
7706 * Sets or retrieves a scheme to be used in interpreting the value of a property specified for the object.
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;
7716 declare var HTMLMetaElement: {
7717 prototype: HTMLMetaElement;
7718 new(): HTMLMetaElement;
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 {
7724 readonly labels: NodeListOf<HTMLLabelElement>;
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;
7736 declare var HTMLMeterElement: {
7737 prototype: HTMLMeterElement;
7738 new(): HTMLMeterElement;
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 {
7744 * Sets or retrieves reference information about the object.
7748 * Sets or retrieves the date and time of a modification to the object.
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;
7757 declare var HTMLModElement: {
7758 prototype: HTMLModElement;
7759 new(): HTMLModElement;
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 {
7768 * The starting number.
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;
7778 declare var HTMLOListElement: {
7779 prototype: HTMLOListElement;
7780 new(): HTMLOListElement;
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 {
7788 * Sets or retrieves a character string that can be used to implement your own archive functionality for the object.
7795 * Sets or retrieves the URL of the file containing the compiled Java class.
7800 * Sets or retrieves the URL of the component.
7805 * Sets or retrieves the Internet media type for the code associated with the object.
7810 * Retrieves the document object of the page or frame.
7812 readonly contentDocument: Document | null;
7813 readonly contentWindow: WindowProxy | null;
7815 * Sets or retrieves the URL that references the data of the object.
7821 * Retrieves a reference to the form that the object is embedded in.
7823 readonly form: HTMLFormElement | null;
7825 * Sets or retrieves the height of the object.
7831 * Sets or retrieves the name of the object.
7835 * Sets or retrieves a message to be displayed while an object is loading.
7840 * Sets or retrieves the MIME type of the object.
7844 * Sets or retrieves the URL, often with a bookmark extension (#name), to use as a client-side image map.
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.
7850 readonly validationMessage: string;
7852 * Returns a ValidityState object that represents the validity states of an element.
7854 readonly validity: ValidityState;
7858 * Sets or retrieves the width of the object.
7862 * Returns whether an element will successfully validate based on forms validation rules and constraints.
7864 readonly willValidate: boolean;
7866 * Returns whether a form will validate when it is submitted, without having to submit it.
7868 checkValidity(): boolean;
7869 getSVGDocument(): Document | null;
7870 reportValidity(): boolean;
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.
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;
7882 declare var HTMLObjectElement: {
7883 prototype: HTMLObjectElement;
7884 new(): HTMLObjectElement;
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 {
7891 * Retrieves a reference to the form that the object is embedded in.
7893 readonly form: HTMLFormElement | null;
7895 * Sets or retrieves a value that you can use to implement your own label functionality for the object.
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;
7904 declare var HTMLOptGroupElement: {
7905 prototype: HTMLOptGroupElement;
7906 new(): HTMLOptGroupElement;
7909 /** <option> elements and inherits all classes and methods of the HTMLElement interface. */
7910 interface HTMLOptionElement extends HTMLElement {
7912 * Sets or retrieves the status of an option.
7914 defaultSelected: boolean;
7917 * Retrieves a reference to the form that the object is embedded in.
7919 readonly form: HTMLFormElement | null;
7921 * Sets or retrieves the ordinal position of an option in a list box.
7923 readonly index: number;
7925 * Sets or retrieves a value that you can use to implement your own label functionality for the object.
7929 * Sets or retrieves whether the option in the list box is the default item.
7933 * Sets or retrieves the text string specified by the option tag.
7937 * Sets or retrieves the value which is returned to the server when the form control is submitted.
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;
7946 declare var HTMLOptionElement: {
7947 prototype: HTMLOptionElement;
7948 new(): HTMLOptionElement;
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> {
7954 * Returns the number of elements in the collection.
7956 * When set to a smaller number, truncates the number of option elements in the corresponding container.
7958 * When set to a greater number, adds new blank option elements to that container.
7962 * Returns the index of the first selected item, if any, or −1 if there is no selected item.
7964 * Can be set, to change the selection.
7966 selectedIndex: number;
7968 * Inserts element before the node given by before.
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.
7972 * If before is omitted, null, or a number out of range, then element will be added at the end of the list.
7974 * This method will throw a "HierarchyRequestError" DOMException if element is an ancestor of the element into which it is to be inserted.
7976 add(element: HTMLOptionElement | HTMLOptGroupElement, before?: HTMLElement | number | null): void;
7978 * Removes the item with index index from the collection.
7980 remove(index: number): void;
7983 declare var HTMLOptionsCollection: {
7984 prototype: HTMLOptionsCollection;
7985 new(): HTMLOptionsCollection;
7988 interface HTMLOrSVGElement {
7990 readonly dataset: DOMStringMap;
7994 focus(options?: FocusOptions): void;
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>;
8004 readonly type: string;
8005 readonly validationMessage: string;
8006 readonly validity: ValidityState;
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;
8018 declare var HTMLOutputElement: {
8019 prototype: HTMLOutputElement;
8020 new(): HTMLOutputElement;
8023 /** Provides special properties (beyond those of the regular HTMLElement object interface it inherits) for manipulating <p> elements. */
8024 interface HTMLParagraphElement extends HTMLElement {
8026 * Sets or retrieves how the object is aligned with adjacent text.
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;
8036 declare var HTMLParagraphElement: {
8037 prototype: HTMLParagraphElement;
8038 new(): HTMLParagraphElement;
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 {
8044 * Sets or retrieves the name of an input parameter for an element.
8048 * Sets or retrieves the content type of the resource designated by the value attribute.
8053 * Sets or retrieves the value of an input parameter for an element.
8057 * Sets or retrieves the data type of the value attribute.
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;
8067 declare var HTMLParamElement: {
8068 prototype: HTMLParamElement;
8069 new(): HTMLParamElement;
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;
8080 declare var HTMLPictureElement: {
8081 prototype: HTMLPictureElement;
8082 new(): HTMLPictureElement;
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 {
8088 * Sets or gets a value that you can use to implement your own width functionality for the object.
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;
8098 declare var HTMLPreElement: {
8099 prototype: HTMLPreElement;
8100 new(): HTMLPreElement;
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>;
8107 * Defines the maximum, or "done" value for a progress element.
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).
8113 readonly position: number;
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.
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;
8124 declare var HTMLProgressElement: {
8125 prototype: HTMLProgressElement;
8126 new(): HTMLProgressElement;
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 {
8132 * Sets or retrieves reference information about the object.
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;
8141 declare var HTMLQuoteElement: {
8142 prototype: HTMLQuoteElement;
8143 new(): HTMLQuoteElement;
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 {
8150 * Sets or retrieves the character set used to encode the object.
8154 crossOrigin: string | null;
8156 * Sets or retrieves the status of the script.
8160 * Sets or retrieves the event for which the script is written.
8165 * Sets or retrieves the object that is bound to the event script.
8171 referrerPolicy: string;
8173 * Retrieves the URL to an external file that contains the source code or data.
8177 * Retrieves or sets the text of the object as a string.
8181 * Sets or retrieves the MIME type for the associated scripting engine.
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;
8190 declare var HTMLScriptElement: {
8191 prototype: HTMLScriptElement;
8192 new(): HTMLScriptElement;
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;
8200 * Retrieves a reference to the form that the object is embedded in.
8202 readonly form: HTMLFormElement | null;
8203 readonly labels: NodeListOf<HTMLLabelElement>;
8205 * Sets or retrieves the number of objects in a collection.
8209 * Sets or retrieves the Boolean value indicating whether multiple items can be selected from a list.
8213 * Sets or retrieves the name of the object.
8216 readonly options: HTMLOptionsCollection;
8218 * When present, marks an element that can't be submitted without a value.
8222 * Sets or retrieves the index of the selected option in a select object.
8224 selectedIndex: number;
8225 readonly selectedOptions: HTMLCollectionOf<HTMLOptionElement>;
8227 * Sets or retrieves the number of rows in the list box.
8231 * Retrieves the type of select control based on the value of the MULTIPLE attribute.
8233 readonly type: string;
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.
8237 readonly validationMessage: string;
8239 * Returns a ValidityState object that represents the validity states of an element.
8241 readonly validity: ValidityState;
8243 * Sets or retrieves the value which is returned to the server when the form control is submitted.
8247 * Returns whether an element will successfully validate based on forms validation rules and constraints.
8249 readonly willValidate: boolean;
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.
8255 add(element: HTMLOptionElement | HTMLOptGroupElement, before?: HTMLElement | number | null): void;
8257 * Returns whether a form will validate when it is submitted, without having to submit it.
8259 checkValidity(): boolean;
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.
8265 item(index: number): Element | null;
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.
8270 namedItem(name: string): HTMLOptionElement | null;
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.
8276 remove(index: number): void;
8277 reportValidity(): boolean;
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.
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;
8290 declare var HTMLSelectElement: {
8291 prototype: HTMLSelectElement;
8292 new(): HTMLSelectElement;
8295 interface HTMLSlotElement extends HTMLElement {
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;
8305 declare var HTMLSlotElement: {
8306 prototype: HTMLSlotElement;
8307 new(): HTMLSlotElement;
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 {
8313 * Gets or sets the intended media type of the media source.
8318 * The address or URL of the a media resource that is to be considered.
8323 * Gets or sets the MIME type of a media resource.
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;
8332 declare var HTMLSourceElement: {
8333 prototype: HTMLSourceElement;
8334 new(): HTMLSourceElement;
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;
8345 declare var HTMLSpanElement: {
8346 prototype: HTMLSpanElement;
8347 new(): HTMLSpanElement;
8350 /** A <style> element. It inherits properties and methods from its parent, HTMLElement, and from LinkStyle. */
8351 interface HTMLStyleElement extends HTMLElement, LinkStyle {
8353 * Sets or retrieves the media type.
8357 * Retrieves the CSS language in which the style sheet is written.
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;
8367 declare var HTMLStyleElement: {
8368 prototype: HTMLStyleElement;
8369 new(): HTMLStyleElement;
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 {
8375 * Sets or retrieves the alignment of the caption or legend.
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;
8385 declare var HTMLTableCaptionElement: {
8386 prototype: HTMLTableCaptionElement;
8387 new(): HTMLTableCaptionElement;
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 {
8393 * Sets or retrieves abbreviated text for the object.
8397 * Sets or retrieves how the object is aligned with adjacent text.
8402 * Sets or retrieves a comma-delimited list of conceptual categories associated with the object.
8409 * Retrieves the position of the object in the cells collection of a row.
8411 readonly cellIndex: number;
8417 * Sets or retrieves the number columns in the table that the object should span.
8421 * Sets or retrieves a list of header cells that provide information for the object.
8425 * Sets or retrieves the height of the object.
8430 * Sets or retrieves whether the browser automatically performs wordwrap.
8435 * Sets or retrieves how many rows in a table the cell should span.
8439 * Sets or retrieves the group of cells in a table to which the object's information applies.
8445 * Sets or retrieves the width of the object.
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;
8455 declare var HTMLTableCellElement: {
8456 prototype: HTMLTableCellElement;
8457 new(): HTMLTableCellElement;
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 {
8463 * Sets or retrieves the alignment of the object relative to the display or table.
8472 * Sets or retrieves the number of columns in the group.
8478 * Sets or retrieves the width of the object.
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;
8488 declare var HTMLTableColElement: {
8489 prototype: HTMLTableColElement;
8490 new(): HTMLTableColElement;
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;
8500 declare var HTMLTableDataCellElement: {
8501 prototype: HTMLTableDataCellElement;
8502 new(): HTMLTableDataCellElement;
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 {
8508 * Sets or retrieves a value that indicates the table alignment.
8515 * Sets or retrieves the width of the border to draw around the object.
8520 * Retrieves the caption object of a table.
8522 caption: HTMLTableCaptionElement | null;
8524 * Sets or retrieves the amount of space between the border of the cell and the content of the cell.
8527 cellPadding: string;
8529 * Sets or retrieves the amount of space between cells in a table.
8532 cellSpacing: string;
8534 * Sets or retrieves the way the border frame around the table is displayed.
8539 * Sets or retrieves the number of horizontal rows contained in the object.
8541 readonly rows: HTMLCollectionOf<HTMLTableRowElement>;
8543 * Sets or retrieves which dividing lines (inner borders) are displayed.
8548 * Sets or retrieves a description and/or structure of the object.
8553 * Retrieves a collection of all tBody objects in the table. Objects in this collection are in source order.
8555 readonly tBodies: HTMLCollectionOf<HTMLTableSectionElement>;
8557 * Retrieves the tFoot object of the table.
8559 tFoot: HTMLTableSectionElement | null;
8561 * Retrieves the tHead object of the table.
8563 tHead: HTMLTableSectionElement | null;
8565 * Sets or retrieves the width of the object.
8570 * Creates an empty caption element in the table.
8572 createCaption(): HTMLTableCaptionElement;
8574 * Creates an empty tBody element in the table.
8576 createTBody(): HTMLTableSectionElement;
8578 * Creates an empty tFoot element in the table.
8580 createTFoot(): HTMLTableSectionElement;
8582 * Returns the tHead element object if successful, or null otherwise.
8584 createTHead(): HTMLTableSectionElement;
8586 * Deletes the caption element and its contents from the table.
8588 deleteCaption(): void;
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.
8593 deleteRow(index: number): void;
8595 * Deletes the tFoot element and its contents from the table.
8597 deleteTFoot(): void;
8599 * Deletes the tHead element and its contents from the table.
8601 deleteTHead(): void;
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.
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;
8613 declare var HTMLTableElement: {
8614 prototype: HTMLTableElement;
8615 new(): HTMLTableElement;
8618 interface HTMLTableHeaderCellElement extends HTMLTableCellElement {
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;
8626 declare var HTMLTableHeaderCellElement: {
8627 prototype: HTMLTableHeaderCellElement;
8628 new(): HTMLTableHeaderCellElement;
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 {
8634 * Sets or retrieves how the object is aligned with adjacent text.
8641 * Retrieves a collection of all cells in the table row.
8643 readonly cells: HTMLCollectionOf<HTMLTableDataCellElement | HTMLTableHeaderCellElement>;
8649 * Retrieves the position of the object in the rows collection for the table.
8651 readonly rowIndex: number;
8653 * Retrieves the position of the object in the collection.
8655 readonly sectionRowIndex: number;
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.
8662 deleteCell(index: number): void;
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.
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;
8674 declare var HTMLTableRowElement: {
8675 prototype: HTMLTableRowElement;
8676 new(): HTMLTableRowElement;
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 {
8682 * Sets or retrieves a value that indicates the table alignment.
8691 * Sets or retrieves the number of horizontal rows contained in the object.
8693 readonly rows: HTMLCollectionOf<HTMLTableRowElement>;
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.
8700 deleteRow(index: number): void;
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.
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;
8712 declare var HTMLTableSectionElement: {
8713 prototype: HTMLTableSectionElement;
8714 new(): HTMLTableSectionElement;
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;
8726 declare var HTMLTemplateElement: {
8727 prototype: HTMLTemplateElement;
8728 new(): HTMLTemplateElement;
8731 /** Provides special properties and methods for manipulating the layout and presentation of <textarea> elements. */
8732 interface HTMLTextAreaElement extends HTMLElement {
8733 autocomplete: string;
8735 * Sets or retrieves the width of the object.
8739 * Sets or retrieves the initial contents of the object.
8741 defaultValue: string;
8745 * Retrieves a reference to the form that the object is embedded in.
8747 readonly form: HTMLFormElement | null;
8748 readonly labels: NodeListOf<HTMLLabelElement>;
8750 * Sets or retrieves the maximum number of characters that the user can enter in a text control.
8755 * Sets or retrieves the name of the object.
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.
8761 placeholder: string;
8763 * Sets or retrieves the value indicated whether the content of the object is read-only.
8767 * When present, marks an element that can't be submitted without a value.
8771 * Sets or retrieves the number of horizontal rows contained in the object.
8774 selectionDirection: "forward" | "backward" | "none";
8776 * Gets or sets the end position or offset of a text selection.
8778 selectionEnd: number;
8780 * Gets or sets the starting position or offset of a text selection.
8782 selectionStart: number;
8783 readonly textLength: number;
8785 * Retrieves the type of control.
8787 readonly type: string;
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.
8791 readonly validationMessage: string;
8793 * Returns a ValidityState object that represents the validity states of an element.
8795 readonly validity: ValidityState;
8797 * Retrieves or sets the text in the entry field of the textArea element.
8801 * Returns whether an element will successfully validate based on forms validation rules and constraints.
8803 readonly willValidate: boolean;
8805 * Sets or retrieves how to handle wordwrapping in the object.
8809 * Returns whether a form will validate when it is submitted, without having to submit it.
8811 checkValidity(): boolean;
8812 reportValidity(): boolean;
8814 * Highlights the input area of a form element.
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.
8821 setCustomValidity(error: string): void;
8822 setRangeText(replacement: string): void;
8823 setRangeText(replacement: string, start: number, end: number, selectionMode?: SelectionMode): void;
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.
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;
8837 declare var HTMLTextAreaElement: {
8838 prototype: HTMLTextAreaElement;
8839 new(): HTMLTextAreaElement;
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 {
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;
8851 declare var HTMLTimeElement: {
8852 prototype: HTMLTimeElement;
8853 new(): HTMLTimeElement;
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 {
8859 * Retrieves or sets the text of the object as a 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;
8868 declare var HTMLTitleElement: {
8869 prototype: HTMLTitleElement;
8870 new(): HTMLTitleElement;
8873 /** The HTMLTrackElement */
8874 interface HTMLTrackElement extends HTMLElement {
8878 readonly readyState: number;
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;
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;
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 {
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;
8913 declare var HTMLUListElement: {
8914 prototype: HTMLUListElement;
8915 new(): HTMLUListElement;
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;
8926 declare var HTMLUnknownElement: {
8927 prototype: HTMLUnknownElement;
8928 new(): HTMLUnknownElement;
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 {
8934 * Gets or sets the height of the video element.
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.
8942 * Gets the intrinsic height of a video in CSS pixels, or zero if the dimensions are not known.
8944 readonly videoHeight: number;
8946 * Gets the intrinsic width of a video in CSS pixels, or zero if the dimensions are not known.
8948 readonly videoWidth: number;
8950 * Gets or sets the width of the video element.
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;
8960 declare var HTMLVideoElement: {
8961 prototype: HTMLVideoElement;
8962 new(): HTMLVideoElement;
8965 /** Events that fire when the fragment identifier of the URL has changed. */
8966 interface HashChangeEvent extends Event {
8968 * Returns the URL of the session history entry that is now current.
8970 readonly newURL: string;
8972 * Returns the URL of the session history entry that was previously current.
8974 readonly oldURL: string;
8977 declare var HashChangeEvent: {
8978 prototype: HashChangeEvent;
8979 new(type: string, eventInitDict?: HashChangeEventInit): HashChangeEvent;
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. */
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;
8992 declare var Headers: {
8994 new(init?: HeadersInit): Headers;
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. */
8999 readonly length: number;
9000 scrollRestoration: ScrollRestoration;
9001 readonly state: any;
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;
9009 declare var History: {
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;
9020 interface IDBArrayKey extends Array<IDBValidKey> {
9023 /** This IndexedDB API interface represents a cursor for traversing or iterating over multiple records in a database. */
9024 interface IDBCursor {
9026 * Returns the direction ("next", "nextunique", "prev" or "prevunique") of the cursor.
9028 readonly direction: IDBCursorDirection;
9030 * Returns the key of the cursor. Throws a "InvalidStateError" DOMException if the cursor is advancing or is finished.
9032 readonly key: IDBValidKey;
9034 * Returns the effective key of the cursor. Throws a "InvalidStateError" DOMException if the cursor is advancing or is finished.
9036 readonly primaryKey: IDBValidKey;
9038 * Returns the IDBObjectStore or IDBIndex the cursor was opened from.
9040 readonly source: IDBObjectStore | IDBIndex;
9042 * Advances the cursor through the next count records in range.
9044 advance(count: number): void;
9046 * Advances the cursor to the next record in range.
9048 continue(key?: IDBValidKey): void;
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.
9052 continuePrimaryKey(key: IDBValidKey, primaryKey: IDBValidKey): void;
9054 * Delete the record pointed at by the cursor with a new value.
9056 * If successful, request's result will be undefined.
9058 delete(): IDBRequest<undefined>;
9060 * Updated the record pointed at by the cursor with a new value.
9062 * Throws a "DataError" DOMException if the effective object store uses in-line keys and the key would have changed.
9064 * If successful, request's result will be the record's key.
9066 update(value: any): IDBRequest<IDBValidKey>;
9069 declare var IDBCursor: {
9070 prototype: IDBCursor;
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 {
9077 * Returns the cursor's current value.
9079 readonly value: any;
9082 declare var IDBCursorWithValue: {
9083 prototype: IDBCursorWithValue;
9084 new(): IDBCursorWithValue;
9087 interface IDBDatabaseEventMap {
9091 "versionchange": IDBVersionChangeEvent;
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 {
9097 * Returns the name of the database.
9099 readonly name: string;
9101 * Returns a list of the names of object stores in the database.
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;
9109 * Returns the version of the database.
9111 readonly version: number;
9113 * Closes the connection once all running transactions have finished.
9117 * Creates a new object store with the given name and options and returns a new IDBObjectStore.
9119 * Throws a "InvalidStateError" DOMException if not called within an upgrade transaction.
9121 createObjectStore(name: string, optionalParameters?: IDBObjectStoreParameters): IDBObjectStore;
9123 * Deletes the object store with the given name.
9125 * Throws a "InvalidStateError" DOMException if not called within an upgrade transaction.
9127 deleteObjectStore(name: string): void;
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.
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;
9138 declare var IDBDatabase: {
9139 prototype: IDBDatabase;
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 {
9146 * Compares two values as keys. Returns -1 if key1 precedes key2, 1 if key2 precedes key1, and 0 if the keys are equal.
9148 * Throws a "DataError" DOMException if either input is not a valid key.
9150 cmp(first: any, second: any): number;
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.
9154 deleteDatabase(name: string): IDBOpenDBRequest;
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.
9158 open(name: string, version?: number): IDBOpenDBRequest;
9161 declare var IDBFactory: {
9162 prototype: IDBFactory;
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;
9171 * Returns the name of the index.
9175 * Returns the IDBObjectStore the index belongs to.
9177 readonly objectStore: IDBObjectStore;
9178 readonly unique: boolean;
9180 * Retrieves the number of records matching the given key or key range in query.
9182 * If successful, request's result will be the count.
9184 count(key?: IDBValidKey | IDBKeyRange): IDBRequest<number>;
9186 * Retrieves the value of the first record matching the given key or key range in query.
9188 * If successful, request's result will be the value, or undefined if there was no matching record.
9190 get(key: IDBValidKey | IDBKeyRange): IDBRequest<any | undefined>;
9192 * Retrieves the values of the records matching the given key or key range in query (up to count if given).
9194 * If successful, request's result will be an Array of the values.
9196 getAll(query?: IDBValidKey | IDBKeyRange | null, count?: number): IDBRequest<any[]>;
9198 * Retrieves the keys of records matching the given key or key range in query (up to count if given).
9200 * If successful, request's result will be an Array of the keys.
9202 getAllKeys(query?: IDBValidKey | IDBKeyRange | null, count?: number): IDBRequest<IDBValidKey[]>;
9204 * Retrieves the key of the first record matching the given key or key range in query.
9206 * If successful, request's result will be the key, or undefined if there was no matching record.
9208 getKey(key: IDBValidKey | IDBKeyRange): IDBRequest<IDBValidKey | undefined>;
9210 * Opens a cursor over the records matching query, ordered by direction. If query is null, all records in index are matched.
9212 * If successful, request's result will be an IDBCursorWithValue, or null if there were no matching records.
9214 openCursor(query?: IDBValidKey | IDBKeyRange | null, direction?: IDBCursorDirection): IDBRequest<IDBCursorWithValue | null>;
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.
9218 * If successful, request's result will be an IDBCursor, or null if there were no matching records.
9220 openKeyCursor(query?: IDBValidKey | IDBKeyRange | null, direction?: IDBCursorDirection): IDBRequest<IDBCursor | null>;
9223 declare var IDBIndex: {
9224 prototype: IDBIndex;
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 {
9231 * Returns lower bound, or undefined if none.
9233 readonly lower: any;
9235 * Returns true if the lower open flag is set, and false otherwise.
9237 readonly lowerOpen: boolean;
9239 * Returns upper bound, or undefined if none.
9241 readonly upper: any;
9243 * Returns true if the upper open flag is set, and false otherwise.
9245 readonly upperOpen: boolean;
9247 * Returns true if key is included in the range, and false otherwise.
9249 includes(key: any): boolean;
9252 declare var IDBKeyRange: {
9253 prototype: IDBKeyRange;
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.
9258 bound(lower: any, upper: any, lowerOpen?: boolean, upperOpen?: boolean): IDBKeyRange;
9260 * Returns a new IDBKeyRange starting at key with no upper bound. If open is true, key is not included in the range.
9262 lowerBound(lower: any, open?: boolean): IDBKeyRange;
9264 * Returns a new IDBKeyRange spanning only key.
9266 only(value: any): IDBKeyRange;
9268 * Returns a new IDBKeyRange with no lower bound and ending at key. If open is true, key is not included in the range.
9270 upperBound(upper: any, open?: boolean): IDBKeyRange;
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 {
9276 * Returns true if the store has a key generator, and false otherwise.
9278 readonly autoIncrement: boolean;
9280 * Returns a list of the names of indexes in the store.
9282 readonly indexNames: DOMStringList;
9284 * Returns the key path of the store, or null if none.
9286 readonly keyPath: string | string[];
9288 * Returns the name of the store.
9292 * Returns the associated transaction.
9294 readonly transaction: IDBTransaction;
9296 * Adds or updates a record in store with the given value and key.
9298 * If the store uses in-line keys and key is specified a "DataError" DOMException will be thrown.
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.
9302 * If successful, request's result will be the record's key.
9304 add(value: any, key?: IDBValidKey): IDBRequest<IDBValidKey>;
9306 * Deletes all records in store.
9308 * If successful, request's result will be undefined.
9310 clear(): IDBRequest<undefined>;
9312 * Retrieves the number of records matching the given key or key range in query.
9314 * If successful, request's result will be the count.
9316 count(key?: IDBValidKey | IDBKeyRange): IDBRequest<number>;
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.
9320 * Throws an "InvalidStateError" DOMException if not called within an upgrade transaction.
9322 createIndex(name: string, keyPath: string | string[], options?: IDBIndexParameters): IDBIndex;
9324 * Deletes records in store with the given key or in the given key range in query.
9326 * If successful, request's result will be undefined.
9328 delete(key: IDBValidKey | IDBKeyRange): IDBRequest<undefined>;
9330 * Deletes the index in store with the given name.
9332 * Throws an "InvalidStateError" DOMException if not called within an upgrade transaction.
9334 deleteIndex(name: string): void;
9336 * Retrieves the value of the first record matching the given key or key range in query.
9338 * If successful, request's result will be the value, or undefined if there was no matching record.
9340 get(query: IDBValidKey | IDBKeyRange): IDBRequest<any | undefined>;
9342 * Retrieves the values of the records matching the given key or key range in query (up to count if given).
9344 * If successful, request's result will be an Array of the values.
9346 getAll(query?: IDBValidKey | IDBKeyRange | null, count?: number): IDBRequest<any[]>;
9348 * Retrieves the keys of records matching the given key or key range in query (up to count if given).
9350 * If successful, request's result will be an Array of the keys.
9352 getAllKeys(query?: IDBValidKey | IDBKeyRange | null, count?: number): IDBRequest<IDBValidKey[]>;
9354 * Retrieves the key of the first record matching the given key or key range in query.
9356 * If successful, request's result will be the key, or undefined if there was no matching record.
9358 getKey(query: IDBValidKey | IDBKeyRange): IDBRequest<IDBValidKey | undefined>;
9359 index(name: string): IDBIndex;
9361 * Opens a cursor over the records matching query, ordered by direction. If query is null, all records in store are matched.
9363 * If successful, request's result will be an IDBCursorWithValue pointing at the first matching record, or null if there were no matching records.
9365 openCursor(query?: IDBValidKey | IDBKeyRange | null, direction?: IDBCursorDirection): IDBRequest<IDBCursorWithValue | null>;
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.
9369 * If successful, request's result will be an IDBCursor pointing at the first matching record, or null if there were no matching records.
9371 openKeyCursor(query?: IDBValidKey | IDBKeyRange | null, direction?: IDBCursorDirection): IDBRequest<IDBCursor | null>;
9373 * Adds or updates a record in store with the given value and key.
9375 * If the store uses in-line keys and key is specified a "DataError" DOMException will be thrown.
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.
9379 * If successful, request's result will be the record's key.
9381 put(value: any, key?: IDBValidKey): IDBRequest<IDBValidKey>;
9384 declare var IDBObjectStore: {
9385 prototype: IDBObjectStore;
9386 new(): IDBObjectStore;
9389 interface IDBOpenDBRequestEventMap extends IDBRequestEventMap {
9391 "upgradeneeded": IDBVersionChangeEvent;
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;
9404 declare var IDBOpenDBRequest: {
9405 prototype: IDBOpenDBRequest;
9406 new(): IDBOpenDBRequest;
9409 interface IDBRequestEventMap {
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 {
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.
9419 readonly error: DOMException | null;
9420 onerror: ((this: IDBRequest<T>, ev: Event) => any) | null;
9421 onsuccess: ((this: IDBRequest<T>, ev: Event) => any) | null;
9423 * Returns "pending" until a request is complete, then returns "done".
9425 readonly readyState: IDBRequestReadyState;
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.
9431 * Returns the IDBObjectStore, IDBIndex, or IDBCursor the request was made against, or null if is was an open request.
9433 readonly source: IDBObjectStore | IDBIndex | IDBCursor;
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.
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;
9444 declare var IDBRequest: {
9445 prototype: IDBRequest;
9449 interface IDBTransactionEventMap {
9455 interface IDBTransaction extends EventTarget {
9457 * Returns the transaction's connection.
9459 readonly db: IDBDatabase;
9461 * If the transaction was aborted, returns the error (a DOMException) providing the reason.
9463 readonly error: DOMException;
9465 * Returns the mode the transaction was created with ("readonly" or "readwrite"), or "versionchange" for an upgrade transaction.
9467 readonly mode: IDBTransactionMode;
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.
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;
9476 * Aborts the transaction. All pending requests will fail with a "AbortError" DOMException and all changes made to the database will be reverted.
9480 * Returns an IDBObjectStore in the transaction's scope.
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;
9489 declare var IDBTransaction: {
9490 prototype: IDBTransaction;
9491 new(): IDBTransaction;
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;
9500 declare var IDBVersionChangeEvent: {
9501 prototype: IDBVersionChangeEvent;
9502 new(type: string, eventInitDict?: IDBVersionChangeEventInit): IDBVersionChangeEvent;
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;
9510 declare var IIRFilterNode: {
9511 prototype: IIRFilterNode;
9512 new(context: BaseAudioContext, options: IIRFilterOptions): IIRFilterNode;
9515 interface ImageBitmap {
9517 * Returns the intrinsic height of the image, in CSS pixels.
9519 readonly height: number;
9521 * Returns the intrinsic width of the image, in CSS pixels.
9523 readonly width: number;
9525 * Releases imageBitmap's underlying bitmap data.
9530 declare var ImageBitmap: {
9531 prototype: ImageBitmap;
9535 interface ImageBitmapRenderingContext {
9537 * Returns the canvas element that the context is bound to.
9539 readonly canvas: HTMLCanvasElement | OffscreenCanvas;
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.
9543 transferFromImageBitmap(bitmap: ImageBitmap | null): void;
9546 declare var ImageBitmapRenderingContext: {
9547 prototype: ImageBitmapRenderingContext;
9548 new(): ImageBitmapRenderingContext;
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 {
9554 * Returns the one-dimensional array containing the data in RGBA order, as integers in the range 0 to 255.
9556 readonly data: Uint8ClampedArray;
9558 * Returns the actual dimensions of the data in the ImageData object, in pixels.
9560 readonly height: number;
9562 * Returns the actual dimensions of the data in the ImageData object, in pixels.
9564 readonly width: number;
9567 declare var ImageData: {
9568 prototype: ImageData;
9569 new(width: number, height: number): ImageData;
9570 new(array: Uint8ClampedArray, width: number, height?: number): ImageData;
9573 interface InnerHTML {
9577 interface InputDeviceInfo extends MediaDeviceInfo {
9578 getCapabilities(): MediaTrackCapabilities;
9581 declare var InputDeviceInfo: {
9582 prototype: InputDeviceInfo;
9583 new(): InputDeviceInfo;
9586 interface InputEvent extends UIEvent {
9587 readonly data: string | null;
9588 readonly inputType: string;
9589 readonly isComposing: boolean;
9592 declare var InputEvent: {
9593 prototype: InputEvent;
9594 new(type: string, eventInitDict?: InputEventInit): InputEvent;
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>;
9603 observe(target: Element): void;
9604 takeRecords(): IntersectionObserverEntry[];
9605 unobserve(target: Element): void;
9608 declare var IntersectionObserver: {
9609 prototype: IntersectionObserver;
9610 new(callback: IntersectionObserverCallback, options?: IntersectionObserverInit): IntersectionObserver;
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;
9624 declare var IntersectionObserverEntry: {
9625 prototype: IntersectionObserverEntry;
9626 new(intersectionObserverEntryInit: IntersectionObserverEntryInit): IntersectionObserverEntry;
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;
9635 readonly charCode: number;
9636 readonly code: string;
9637 readonly ctrlKey: boolean;
9638 readonly isComposing: boolean;
9639 readonly key: string;
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;
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;
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;
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;
9676 interface LinkStyle {
9677 readonly sheet: CSSStyleSheet | null;
9680 interface ListeningStateChangedEvent extends Event {
9681 readonly label: string;
9682 readonly state: ListeningState;
9685 declare var ListeningStateChangedEvent: {
9686 prototype: ListeningStateChangedEvent;
9687 new(): ListeningStateChangedEvent;
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 {
9693 * Returns a DOMStringList object listing the origins of the ancestor browsing contexts, from the parent browsing context to the top-level browsing context.
9695 readonly ancestorOrigins: DOMStringList;
9697 * Returns the Location object's URL's fragment (includes leading "#" if non-empty).
9699 * Can be set, to navigate to the same URL with a changed fragment (ignores leading "#").
9703 * Returns the Location object's URL's host and port (if different from the default port for the scheme).
9705 * Can be set, to navigate to the same URL with a changed host and port.
9709 * Returns the Location object's URL's host.
9711 * Can be set, to navigate to the same URL with a changed host.
9715 * Returns the Location object's URL.
9717 * Can be set, to navigate to the given URL.
9722 * Returns the Location object's URL's origin.
9724 readonly origin: string;
9726 * Returns the Location object's URL's path.
9728 * Can be set, to navigate to the same URL with a changed path.
9732 * Returns the Location object's URL's port.
9734 * Can be set, to navigate to the same URL with a changed port.
9738 * Returns the Location object's URL's scheme.
9740 * Can be set, to navigate to the same URL with a changed scheme.
9744 * Returns the Location object's URL's query (includes leading "?" if non-empty).
9746 * Can be set, to navigate to the same URL with a changed query (ignores leading "?").
9750 * Navigates to the given URL.
9752 assign(url: string): void;
9754 * Reloads the current page.
9758 reload(forcedReload: boolean): void;
9760 * Removes the current page from the session history and navigates to the given URL.
9762 replace(url: string): void;
9765 declare var Location: {
9766 prototype: Location;
9770 interface MSAssertion {
9771 readonly id: string;
9772 readonly type: MSCredentialType;
9775 declare var MSAssertion: {
9776 prototype: MSAssertion;
9780 interface MSBlobBuilder {
9781 append(data: any, endings?: string): void;
9782 getBlob(contentType?: string): Blob;
9785 declare var MSBlobBuilder: {
9786 prototype: MSBlobBuilder;
9787 new(): MSBlobBuilder;
9790 interface MSFIDOCredentialAssertion extends MSAssertion {
9791 readonly algorithm: string | Algorithm;
9792 readonly attestation: any;
9793 readonly publicKey: string;
9794 readonly transportHints: MSTransportType[];
9797 declare var MSFIDOCredentialAssertion: {
9798 prototype: MSFIDOCredentialAssertion;
9799 new(): MSFIDOCredentialAssertion;
9802 interface MSFIDOSignature {
9803 readonly authnrData: string;
9804 readonly clientData: string;
9805 readonly signature: string;
9808 declare var MSFIDOSignature: {
9809 prototype: MSFIDOSignature;
9810 new(): MSFIDOSignature;
9813 interface MSFIDOSignatureAssertion extends MSAssertion {
9814 readonly signature: MSFIDOSignature;
9817 declare var MSFIDOSignatureAssertion: {
9818 prototype: MSFIDOSignatureAssertion;
9819 new(): MSFIDOSignatureAssertion;
9822 interface MSFileSaver {
9823 msSaveBlob(blob: any, defaultName?: string): boolean;
9824 msSaveOrOpenBlob(blob: any, defaultName?: string): boolean;
9827 interface MSGesture {
9829 addPointer(pointerId: number): void;
9833 declare var MSGesture: {
9834 prototype: MSGesture;
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;
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;
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;
9881 declare var MSGraphicsTrust: {
9882 prototype: MSGraphicsTrust;
9883 new(): MSGraphicsTrust;
9886 interface MSInputMethodContextEventMap {
9887 "MSCandidateWindowHide": Event;
9888 "MSCandidateWindowShow": Event;
9889 "MSCandidateWindowUpdate": Event;
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;
9909 declare var MSInputMethodContext: {
9910 prototype: MSInputMethodContext;
9911 new(): MSInputMethodContext;
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;
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;
9936 interface MSMediaKeyMessageEvent extends Event {
9937 readonly destinationURL: string | null;
9938 readonly message: Uint8Array;
9941 declare var MSMediaKeyMessageEvent: {
9942 prototype: MSMediaKeyMessageEvent;
9943 new(): MSMediaKeyMessageEvent;
9946 interface MSMediaKeyNeededEvent extends Event {
9947 readonly initData: Uint8Array | null;
9950 declare var MSMediaKeyNeededEvent: {
9951 prototype: MSMediaKeyNeededEvent;
9952 new(): MSMediaKeyNeededEvent;
9955 interface MSMediaKeySession extends EventTarget {
9956 readonly error: MSMediaKeyError | null;
9957 readonly keySystem: string;
9958 readonly sessionId: string;
9960 update(key: Uint8Array): void;
9963 declare var MSMediaKeySession: {
9964 prototype: MSMediaKeySession;
9965 new(): MSMediaKeySession;
9968 interface MSMediaKeys {
9969 readonly keySystem: string;
9970 createSession(type: string, initData: Uint8Array, cdmData?: Uint8Array | null): MSMediaKeySession;
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;
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;
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;
10007 declare var MSPointerEvent: {
10008 prototype: MSPointerEvent;
10009 new(typeArg: string, eventInitDict?: PointerEventInit): MSPointerEvent;
10012 interface MSStream {
10013 readonly type: string;
10015 msDetachStream(): any;
10018 declare var MSStream: {
10019 prototype: MSStream;
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;
10032 declare var MediaDeviceInfo: {
10033 prototype: MediaDeviceInfo;
10034 new(): MediaDeviceInfo;
10037 interface MediaDevicesEventMap {
10038 "devicechange": Event;
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;
10053 declare var MediaDevices: {
10054 prototype: MediaDevices;
10055 new(): MediaDevices;
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;
10063 declare var MediaElementAudioSourceNode: {
10064 prototype: MediaElementAudioSourceNode;
10065 new(context: AudioContext, options: MediaElementAudioSourceOptions): MediaElementAudioSourceNode;
10068 interface MediaEncryptedEvent extends Event {
10069 readonly initData: ArrayBuffer | null;
10070 readonly initDataType: string;
10073 declare var MediaEncryptedEvent: {
10074 prototype: MediaEncryptedEvent;
10075 new(type: string, eventInitDict?: MediaEncryptedEventInit): MediaEncryptedEvent;
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;
10088 declare var MediaError: {
10089 prototype: 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;
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;
10103 declare var MediaKeyMessageEvent: {
10104 prototype: MediaKeyMessageEvent;
10105 new(type: string, eventInitDict: MediaKeyMessageEventInit): MediaKeyMessageEvent;
10108 interface MediaKeySessionEventMap {
10109 "keystatuseschange": Event;
10110 "message": MediaKeyMessageEvent;
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;
10132 declare var MediaKeySession: {
10133 prototype: MediaKeySession;
10134 new(): MediaKeySession;
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;
10145 declare var MediaKeyStatusMap: {
10146 prototype: MediaKeyStatusMap;
10147 new(): MediaKeyStatusMap;
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;
10157 declare var MediaKeySystemAccess: {
10158 prototype: MediaKeySystemAccess;
10159 new(): MediaKeySystemAccess;
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>;
10168 declare var MediaKeys: {
10169 prototype: MediaKeys;
10173 interface MediaList {
10174 readonly length: number;
10176 toString(): string;
10177 appendMedium(medium: string): void;
10178 deleteMedium(medium: string): void;
10179 item(index: number): string | null;
10180 [index: number]: string;
10183 declare var MediaList: {
10184 prototype: MediaList;
10188 interface MediaQueryListEventMap {
10189 "change": MediaQueryListEvent;
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;
10198 addListener(listener: ((this: MediaQueryList, ev: MediaQueryListEvent) => any) | null): void;
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;
10207 declare var MediaQueryList: {
10208 prototype: MediaQueryList;
10209 new(): MediaQueryList;
10212 interface MediaQueryListEvent extends Event {
10213 readonly matches: boolean;
10214 readonly media: string;
10217 declare var MediaQueryListEvent: {
10218 prototype: MediaQueryListEvent;
10219 new(type: string, eventInitDict?: MediaQueryListEventInit): MediaQueryListEvent;
10222 interface MediaSourceEventMap {
10223 "sourceclose": Event;
10224 "sourceended": Event;
10225 "sourceopen": Event;
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;
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;
10248 declare var MediaSource: {
10249 prototype: MediaSource;
10250 new(): MediaSource;
10251 isTypeSupported(type: string): boolean;
10254 interface MediaStreamEventMap {
10255 "addtrack": MediaStreamTrackEvent;
10256 "removetrack": MediaStreamTrackEvent;
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;
10278 declare var MediaStream: {
10279 prototype: MediaStream;
10280 new(): MediaStream;
10281 new(stream: MediaStream): MediaStream;
10282 new(tracks: MediaStreamTrack[]): MediaStream;
10285 interface MediaStreamAudioDestinationNode extends AudioNode {
10286 readonly stream: MediaStream;
10289 declare var MediaStreamAudioDestinationNode: {
10290 prototype: MediaStreamAudioDestinationNode;
10291 new(context: AudioContext, options?: AudioNodeOptions): MediaStreamAudioDestinationNode;
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;
10299 declare var MediaStreamAudioSourceNode: {
10300 prototype: MediaStreamAudioSourceNode;
10301 new(context: AudioContext, options: MediaStreamAudioSourceOptions): MediaStreamAudioSourceNode;
10304 interface MediaStreamError {
10305 readonly constraintName: string | null;
10306 readonly message: string | null;
10307 readonly name: string;
10310 declare var MediaStreamError: {
10311 prototype: MediaStreamError;
10312 new(): MediaStreamError;
10315 interface MediaStreamErrorEvent extends Event {
10316 readonly error: MediaStreamError | null;
10319 declare var MediaStreamErrorEvent: {
10320 prototype: MediaStreamErrorEvent;
10321 new(typeArg: string, eventInitDict?: MediaStreamErrorEventInit): MediaStreamErrorEvent;
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;
10329 declare var MediaStreamEvent: {
10330 prototype: MediaStreamEvent;
10331 new(type: string, eventInitDict: MediaStreamEventInit): MediaStreamEvent;
10334 interface MediaStreamTrackEventMap {
10336 "isolationchange": Event;
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 {
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;
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;
10366 declare var MediaStreamTrack: {
10367 prototype: MediaStreamTrack;
10368 new(): MediaStreamTrack;
10371 interface MediaStreamTrackAudioSourceNode extends AudioNode {
10374 declare var MediaStreamTrackAudioSourceNode: {
10375 prototype: MediaStreamTrackAudioSourceNode;
10376 new(context: AudioContext, options: MediaStreamTrackAudioSourceOptions): MediaStreamTrackAudioSourceNode;
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;
10384 declare var MediaStreamTrackEvent: {
10385 prototype: MediaStreamTrackEvent;
10386 new(type: string, eventInitDict: MediaStreamTrackEventInit): MediaStreamTrackEvent;
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 {
10392 * Returns the first MessagePort object.
10394 readonly port1: MessagePort;
10396 * Returns the second MessagePort object.
10398 readonly port2: MessagePort;
10401 declare var MessageChannel: {
10402 prototype: MessageChannel;
10403 new(): MessageChannel;
10406 /** A message received by a target object. */
10407 interface MessageEvent extends Event {
10409 * Returns the data of the message.
10411 readonly data: any;
10413 * Returns the last event ID string, for server-sent events.
10415 readonly lastEventId: string;
10417 * Returns the origin of the message, for server-sent events and cross-document messaging.
10419 readonly origin: string;
10421 * Returns the MessagePort array sent with the message, for cross-document messaging and channel messaging.
10423 readonly ports: ReadonlyArray<MessagePort>;
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.
10427 readonly source: MessageEventSource | null;
10430 declare var MessageEvent: {
10431 prototype: MessageEvent;
10432 new(type: string, eventInitDict?: MessageEventInit): MessageEvent;
10435 interface MessagePortEventMap {
10436 "message": MessageEvent;
10437 "messageerror": MessageEvent;
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;
10445 * Disconnects the port, so that it is no longer active.
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.
10451 * Throws a "DataCloneError" DOMException if transfer contains duplicate objects or port, or if message could not be cloned.
10453 postMessage(message: any, transfer: Transferable[]): void;
10454 postMessage(message: any, options?: PostMessageOptions): void;
10456 * Begins dispatching messages received on the port.
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;
10465 declare var MessagePort: {
10466 prototype: MessagePort;
10467 new(): MessagePort;
10470 /** Provides contains information about a MIME type associated with a particular plugin. NavigatorPlugins.mimeTypes returns an array of this object. */
10471 interface MimeType {
10473 * Returns the MIME type's description.
10475 readonly description: string;
10477 * Returns the Plugin object that implements this MIME type.
10479 readonly enabledPlugin: Plugin;
10481 * Returns the MIME type's typical file extensions, in a comma-separated list.
10483 readonly suffixes: string;
10485 * Returns the MIME type.
10487 readonly type: string;
10490 declare var MimeType: {
10491 prototype: MimeType;
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;
10503 declare var MimeTypeArray: {
10504 prototype: MimeTypeArray;
10505 new(): MimeTypeArray;
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;
10533 declare var MouseEvent: {
10534 prototype: MouseEvent;
10535 new(type: string, eventInitDict?: MouseEventInit): MouseEvent;
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;
10551 declare var MutationEvent: {
10552 prototype: MutationEvent;
10553 new(): MutationEvent;
10554 readonly ADDITION: number;
10555 readonly MODIFICATION: number;
10556 readonly REMOVAL: number;
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 {
10562 * Stops observer from observing any mutations. Until the observe() method is used again, observer's callback will not be invoked.
10564 disconnect(): void;
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).
10568 * The options argument allows for setting mutation observation options via object members.
10570 observe(target: Node, options?: MutationObserverInit): void;
10572 * Empties the record queue and returns what was in there.
10574 takeRecords(): MutationRecord[];
10577 declare var MutationObserver: {
10578 prototype: MutationObserver;
10579 new(callback: MutationCallback): MutationObserver;
10582 /** A MutationRecord represents an individual DOM mutation. It is the object that is passed to MutationObserver's callback. */
10583 interface MutationRecord {
10585 * Return the nodes added and removed respectively.
10587 readonly addedNodes: NodeList;
10589 * Returns the local name of the changed attribute, and null otherwise.
10591 readonly attributeName: string | null;
10593 * Returns the namespace of the changed attribute, and null otherwise.
10595 readonly attributeNamespace: string | null;
10597 * Return the previous and next sibling respectively of the added or removed nodes, and null otherwise.
10599 readonly nextSibling: Node | null;
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.
10603 readonly oldValue: string | null;
10605 * Return the previous and next sibling respectively of the added or removed nodes, and null otherwise.
10607 readonly previousSibling: Node | null;
10609 * Return the nodes added and removed respectively.
10611 readonly removedNodes: NodeList;
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.
10615 readonly target: Node;
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.
10619 readonly type: MutationRecordType;
10622 declare var MutationRecord: {
10623 prototype: MutationRecord;
10624 new(): MutationRecord;
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;
10640 declare var NamedNodeMap: {
10641 prototype: NamedNodeMap;
10642 new(): NamedNodeMap;
10645 interface NavigationPreloadManager {
10646 disable(): Promise<void>;
10647 enable(): Promise<void>;
10648 getState(): Promise<NavigationPreloadState>;
10649 setHeaderValue(value: string): Promise<void>;
10652 declare var NavigationPreloadManager: {
10653 prototype: NavigationPreloadManager;
10654 new(): NavigationPreloadManager;
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;
10682 declare var Navigator: {
10683 prototype: Navigator;
10687 interface NavigatorAutomationInformation {
10688 readonly webdriver: boolean;
10691 interface NavigatorBeacon {
10692 sendBeacon(url: string, data?: Blob | Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer | FormData | string | null): boolean;
10695 interface NavigatorConcurrentHardware {
10696 readonly hardwareConcurrency: number;
10699 interface NavigatorContentUtils {
10700 registerProtocolHandler(scheme: string, url: string, title: string): void;
10701 unregisterProtocolHandler(scheme: string, url: string): void;
10704 interface NavigatorCookies {
10705 readonly cookieEnabled: boolean;
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;
10720 interface NavigatorLanguage {
10721 readonly language: string;
10722 readonly languages: ReadonlyArray<string>;
10725 interface NavigatorOnLine {
10726 readonly onLine: boolean;
10729 interface NavigatorPlugins {
10730 readonly mimeTypes: MimeTypeArray;
10731 readonly plugins: PluginArray;
10732 javaEnabled(): boolean;
10735 interface NavigatorStorage {
10736 readonly storage: StorageManager;
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 {
10742 * Returns node's node document's document base URL.
10744 readonly baseURI: string;
10746 * Returns the children.
10748 readonly childNodes: NodeListOf<ChildNode>;
10750 * Returns the first child.
10752 readonly firstChild: ChildNode | null;
10754 * Returns true if node is connected and false otherwise.
10756 readonly isConnected: boolean;
10758 * Returns the last child.
10760 readonly lastChild: ChildNode | null;
10762 readonly namespaceURI: string | null;
10764 * Returns the next sibling.
10766 readonly nextSibling: ChildNode | null;
10768 * Returns a string appropriate for the type of node.
10770 readonly nodeName: string;
10772 * Returns the type of node.
10774 readonly nodeType: number;
10775 nodeValue: string | null;
10777 * Returns the node document. Returns null for documents.
10779 readonly ownerDocument: Document | null;
10781 * Returns the parent element.
10783 readonly parentElement: HTMLElement | null;
10785 * Returns the parent.
10787 readonly parentNode: Node & ParentNode | null;
10789 * Returns the previous sibling.
10791 readonly previousSibling: ChildNode | null;
10792 textContent: string | null;
10793 appendChild<T extends Node>(newChild: T): T;
10795 * Returns a copy of node. If deep is true, the copy also includes the node's descendants.
10797 cloneNode(deep?: boolean): Node;
10799 * Returns a bitmask indicating the position of other relative to node.
10801 compareDocumentPosition(other: Node): number;
10803 * Returns true if other is an inclusive descendant of node, and false otherwise.
10805 contains(other: Node | null): boolean;
10807 * Returns node's root.
10809 getRootNode(options?: GetRootNodeOptions): Node;
10811 * Returns whether node has children.
10813 hasChildNodes(): boolean;
10814 insertBefore<T extends Node>(newChild: T, refChild: Node | null): T;
10815 isDefaultNamespace(namespace: string | null): boolean;
10817 * Returns whether node and otherNode have the same properties.
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;
10824 * Removes empty exclusive Text nodes and concatenates the data of remaining contiguous exclusive Text nodes into the first of their nodes.
10827 removeChild<T extends Node>(oldChild: T): T;
10828 replaceChild<T extends Node>(newChild: Node, oldChild: T): T;
10829 readonly ATTRIBUTE_NODE: number;
10831 * node is a CDATASection node.
10833 readonly CDATA_SECTION_NODE: number;
10835 * node is a Comment node.
10837 readonly COMMENT_NODE: number;
10839 * node is a DocumentFragment node.
10841 readonly DOCUMENT_FRAGMENT_NODE: number;
10843 * node is a document.
10845 readonly DOCUMENT_NODE: number;
10847 * Set when other is a descendant of node.
10849 readonly DOCUMENT_POSITION_CONTAINED_BY: number;
10851 * Set when other is an ancestor of node.
10853 readonly DOCUMENT_POSITION_CONTAINS: number;
10855 * Set when node and other are not in the same tree.
10857 readonly DOCUMENT_POSITION_DISCONNECTED: number;
10859 * Set when other is following node.
10861 readonly DOCUMENT_POSITION_FOLLOWING: number;
10862 readonly DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC: number;
10864 * Set when other is preceding node.
10866 readonly DOCUMENT_POSITION_PRECEDING: number;
10868 * node is a doctype.
10870 readonly DOCUMENT_TYPE_NODE: number;
10872 * node is an element.
10874 readonly ELEMENT_NODE: number;
10875 readonly ENTITY_NODE: number;
10876 readonly ENTITY_REFERENCE_NODE: number;
10877 readonly NOTATION_NODE: number;
10879 * node is a ProcessingInstruction node.
10881 readonly PROCESSING_INSTRUCTION_NODE: number;
10883 * node is a Text node.
10885 readonly TEXT_NODE: number;
10888 declare var Node: {
10891 readonly ATTRIBUTE_NODE: number;
10893 * node is a CDATASection node.
10895 readonly CDATA_SECTION_NODE: number;
10897 * node is a Comment node.
10899 readonly COMMENT_NODE: number;
10901 * node is a DocumentFragment node.
10903 readonly DOCUMENT_FRAGMENT_NODE: number;
10905 * node is a document.
10907 readonly DOCUMENT_NODE: number;
10909 * Set when other is a descendant of node.
10911 readonly DOCUMENT_POSITION_CONTAINED_BY: number;
10913 * Set when other is an ancestor of node.
10915 readonly DOCUMENT_POSITION_CONTAINS: number;
10917 * Set when node and other are not in the same tree.
10919 readonly DOCUMENT_POSITION_DISCONNECTED: number;
10921 * Set when other is following node.
10923 readonly DOCUMENT_POSITION_FOLLOWING: number;
10924 readonly DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC: number;
10926 * Set when other is preceding node.
10928 readonly DOCUMENT_POSITION_PRECEDING: number;
10930 * node is a doctype.
10932 readonly DOCUMENT_TYPE_NODE: number;
10934 * node is an element.
10936 readonly ELEMENT_NODE: number;
10937 readonly ENTITY_NODE: number;
10938 readonly ENTITY_REFERENCE_NODE: number;
10939 readonly NOTATION_NODE: number;
10941 * node is a ProcessingInstruction node.
10943 readonly PROCESSING_INSTRUCTION_NODE: number;
10945 * node is a Text node.
10947 readonly TEXT_NODE: number;
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;
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;
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;
10982 nextNode(): Node | null;
10983 previousNode(): Node | null;
10986 declare var NodeIterator: {
10987 prototype: NodeIterator;
10988 new(): NodeIterator;
10991 /** NodeList objects are collections of nodes, usually returned by properties such as Node.childNodes and methods such as document.querySelectorAll(). */
10992 interface NodeList {
10994 * Returns the number of nodes in the collection.
10996 readonly length: number;
10998 * Returns the node with index index from the collection. The nodes are sorted in tree order.
11000 item(index: number): Node | null;
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.
11006 forEach(callbackfn: (value: Node, key: number, parent: NodeList) => void, thisArg?: any): void;
11007 [index: number]: Node;
11010 declare var NodeList: {
11011 prototype: NodeList;
11015 interface NodeListOf<TNode extends Node> extends NodeList {
11017 item(index: number): TNode;
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.
11023 forEach(callbackfn: (value: TNode, key: number, parent: NodeListOf<TNode>) => void, thisArg?: any): void;
11024 [index: number]: TNode;
11027 interface NonDocumentTypeChildNode {
11029 * Returns the first following sibling that is an element, and null otherwise.
11031 readonly nextElementSibling: Element | null;
11033 * Returns the first preceding sibling that is an element, and null otherwise.
11035 readonly previousElementSibling: Element | null;
11038 interface NonElementParentNode {
11040 * Returns the first element within node's descendants whose ID is elementId.
11042 getElementById(elementId: string): Element | null;
11045 interface NotificationEventMap {
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>;
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;
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>;
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 {
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;
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 {
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 {
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;
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 {
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;
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;
11127 declare var OfflineAudioCompletionEvent: {
11128 prototype: OfflineAudioCompletionEvent;
11129 new(type: string, eventInitDict: OfflineAudioCompletionEventInit): OfflineAudioCompletionEvent;
11132 interface OfflineAudioContextEventMap extends BaseAudioContextEventMap {
11133 "complete": OfflineAudioCompletionEvent;
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;
11149 declare var OfflineAudioContext: {
11150 prototype: OfflineAudioContext;
11151 new(contextOptions: OfflineAudioContextOptions): OfflineAudioContext;
11152 new(numberOfChannels: number, length: number, sampleRate: number): OfflineAudioContext;
11155 interface OffscreenCanvas extends EventTarget {
11157 * These attributes return the dimensions of the OffscreenCanvas object's bitmap.
11159 * They can be set, to replace the bitmap with a new, transparent black bitmap of the specified dimensions (effectively resizing it).
11163 * These attributes return the dimensions of the OffscreenCanvas object's bitmap.
11165 * They can be set, to replace the bitmap with a new, transparent black bitmap of the specified dimensions (effectively resizing it).
11169 * Returns a promise that will fulfill with a new Blob object representing a file containing the image in the OffscreenCanvas object.
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.
11173 convertToBlob(options?: ImageEncodeOptions): Promise<Blob>;
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.
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]
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).
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;
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.
11189 transferToImageBitmap(): ImageBitmap;
11192 declare var OffscreenCanvas: {
11193 prototype: OffscreenCanvas;
11194 new(width: number, height: number): OffscreenCanvas;
11197 interface OffscreenCanvasRenderingContext2D extends CanvasCompositing, CanvasDrawImage, CanvasDrawPath, CanvasFillStrokeStyles, CanvasFilters, CanvasImageData, CanvasImageSmoothing, CanvasPath, CanvasPathDrawingStyles, CanvasRect, CanvasShadowStyles, CanvasState, CanvasText, CanvasTextDrawingStyles, CanvasTransform {
11198 readonly canvas: OffscreenCanvas;
11202 declare var OffscreenCanvasRenderingContext2D: {
11203 prototype: OffscreenCanvasRenderingContext2D;
11204 new(): OffscreenCanvasRenderingContext2D;
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;
11219 declare var OscillatorNode: {
11220 prototype: OscillatorNode;
11221 new(context: BaseAudioContext, options?: OscillatorOptions): OscillatorNode;
11224 interface OverconstrainedError extends Error {
11225 constraint: string;
11228 declare var OverconstrainedError: {
11229 prototype: OverconstrainedError;
11230 new(): OverconstrainedError;
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;
11242 declare var OverflowEvent: {
11243 prototype: OverflowEvent;
11244 new(): OverflowEvent;
11245 readonly BOTH: number;
11246 readonly HORIZONTAL: number;
11247 readonly VERTICAL: number;
11250 /** The PageTransitionEvent is fired when a document is being loaded or unloaded. */
11251 interface PageTransitionEvent extends Event {
11253 * For the pageshow event, returns false if the page is newly being loaded (and the load event will fire). Otherwise, returns true.
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.
11257 * Things that can cause the page to be unsalvageable include:
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
11265 readonly persisted: boolean;
11268 declare var PageTransitionEvent: {
11269 prototype: PageTransitionEvent;
11270 new(type: string, eventInitDict?: PageTransitionEventInit): PageTransitionEvent;
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;
11290 setOrientation(x: number, y: number, z: number): void;
11292 setPosition(x: number, y: number, z: number): void;
11295 declare var PannerNode: {
11296 prototype: PannerNode;
11297 new(context: BaseAudioContext, options?: PannerOptions): PannerNode;
11300 interface ParentNode {
11301 readonly childElementCount: number;
11303 * Returns the child elements.
11305 readonly children: HTMLCollection;
11307 * Returns the first child that is an element, and null otherwise.
11309 readonly firstElementChild: Element | null;
11311 * Returns the last child that is an element, and null otherwise.
11313 readonly lastElementChild: Element | null;
11315 * Inserts nodes after the last child of node, while replacing strings in nodes with equivalent Text nodes.
11317 * Throws a "HierarchyRequestError" DOMException if the constraints of the node tree are violated.
11319 append(...nodes: (Node | string)[]): void;
11321 * Inserts nodes before the first child of node, while replacing strings in nodes with equivalent Text nodes.
11323 * Throws a "HierarchyRequestError" DOMException if the constraints of the node tree are violated.
11325 prepend(...nodes: (Node | string)[]): void;
11327 * Returns the first element that is a descendant of node that matches selectors.
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;
11333 * Returns all element descendants of node that match selectors.
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>;
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 {
11343 * Adds to the path the path given by the argument.
11345 addPath(path: Path2D, transform?: DOMMatrix2DInit): void;
11348 declare var Path2D: {
11350 new(path?: Path2D | string): Path2D;
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;
11369 declare var PaymentAddress: {
11370 prototype: PaymentAddress;
11371 new(): PaymentAddress;
11374 interface PaymentRequestEventMap {
11375 "shippingaddresschange": Event;
11376 "shippingoptionchange": Event;
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;
11396 declare var PaymentRequest: {
11397 prototype: PaymentRequest;
11398 new(methodData: PaymentMethodData[], details: PaymentDetailsInit, options?: PaymentOptions): PaymentRequest;
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;
11406 declare var PaymentRequestUpdateEvent: {
11407 prototype: PaymentRequestUpdateEvent;
11408 new(type: string, eventInitDict?: PaymentRequestUpdateEventInit): PaymentRequestUpdateEvent;
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>;
11425 declare var PaymentResponse: {
11426 prototype: PaymentResponse;
11427 new(): PaymentResponse;
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;
11454 declare var PerfWidgetExternal: {
11455 prototype: PerfWidgetExternal;
11456 new(): PerfWidgetExternal;
11459 interface PerformanceEventMap {
11460 "resourcetimingbufferfull": Event;
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 {
11466 readonly navigation: PerformanceNavigation;
11467 onresourcetimingbufferfull: ((this: Performance, ev: Event) => any) | null;
11468 readonly timeOrigin: number;
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;
11480 setResourceTimingBufferSize(maxSize: number): void;
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;
11488 declare var Performance: {
11489 prototype: Performance;
11490 new(): Performance;
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;
11502 declare var PerformanceEntry: {
11503 prototype: PerformanceEntry;
11504 new(): PerformanceEntry;
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 {
11511 declare var PerformanceMark: {
11512 prototype: PerformanceMark;
11513 new(): PerformanceMark;
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 {
11520 declare var PerformanceMeasure: {
11521 prototype: PerformanceMeasure;
11522 new(): PerformanceMeasure;
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;
11530 readonly TYPE_BACK_FORWARD: number;
11531 readonly TYPE_NAVIGATE: number;
11532 readonly TYPE_RELOAD: number;
11533 readonly TYPE_RESERVED: number;
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;
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;
11560 declare var PerformanceNavigationTiming: {
11561 prototype: PerformanceNavigationTiming;
11562 new(): PerformanceNavigationTiming;
11565 interface PerformanceObserver {
11566 disconnect(): void;
11567 observe(options?: PerformanceObserverInit): void;
11568 takeRecords(): PerformanceEntryList;
11571 declare var PerformanceObserver: {
11572 prototype: PerformanceObserver;
11573 new(callback: PerformanceObserverCallback): PerformanceObserver;
11574 readonly supportedEntryTypes: ReadonlyArray<string>;
11577 interface PerformanceObserverEntryList {
11578 getEntries(): PerformanceEntryList;
11579 getEntriesByName(name: string, type?: string): PerformanceEntryList;
11580 getEntriesByType(type: string): PerformanceEntryList;
11583 declare var PerformanceObserverEntryList: {
11584 prototype: PerformanceObserverEntryList;
11585 new(): PerformanceObserverEntryList;
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;
11610 declare var PerformanceResourceTiming: {
11611 prototype: PerformanceResourceTiming;
11612 new(): PerformanceResourceTiming;
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;
11641 declare var PerformanceTiming: {
11642 prototype: PerformanceTiming;
11643 new(): PerformanceTiming;
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 {
11650 declare var PeriodicWave: {
11651 prototype: PeriodicWave;
11652 new(context: BaseAudioContext, options?: PeriodicWaveOptions): PeriodicWave;
11655 interface PermissionRequest extends DeferredPermissionRequest {
11656 readonly state: MSWebViewPermissionState;
11660 declare var PermissionRequest: {
11661 prototype: PermissionRequest;
11662 new(): PermissionRequest;
11665 interface PermissionRequestedEvent extends Event {
11666 readonly permissionRequest: PermissionRequest;
11669 declare var PermissionRequestedEvent: {
11670 prototype: PermissionRequestedEvent;
11671 new(): PermissionRequestedEvent;
11674 interface PermissionStatusEventMap {
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;
11687 declare var PermissionStatus: {
11688 prototype: PermissionStatus;
11689 new(): PermissionStatus;
11692 interface Permissions {
11693 query(permissionDesc: PermissionDescriptor | DevicePermissionDescriptor | MidiPermissionDescriptor | PushPermissionDescriptor): Promise<PermissionStatus>;
11696 declare var Permissions: {
11697 prototype: Permissions;
11698 new(): Permissions;
11701 /** Provides information about a browser plugin. */
11704 * Returns the plugin's description.
11706 readonly description: string;
11708 * Returns the plugin library's filename, if applicable on the current platform.
11710 readonly filename: string;
11712 * Returns the number of MIME types, represented by MimeType objects, supported by the plugin.
11714 readonly length: number;
11716 * Returns the plugin's name.
11718 readonly name: string;
11720 * Returns the specified MimeType object.
11722 item(index: number): MimeType | null;
11723 namedItem(name: string): MimeType | null;
11724 [index: number]: MimeType;
11727 declare var Plugin: {
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;
11741 declare var PluginArray: {
11742 prototype: PluginArray;
11743 new(): PluginArray;
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;
11760 declare var PointerEvent: {
11761 prototype: PointerEvent;
11762 new(type: string, eventInitDict?: PointerEventInit): PointerEvent;
11765 /** PopStateEvent is an event handler for the popstate event on the window. */
11766 interface PopStateEvent extends Event {
11768 * Returns a copy of the information that was provided to pushState() or replaceState().
11770 readonly state: any;
11773 declare var PopStateEvent: {
11774 prototype: PopStateEvent;
11775 new(type: string, eventInitDict?: PopStateEventInit): PopStateEvent;
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;
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;
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;
11799 declare var ProcessingInstruction: {
11800 prototype: ProcessingInstruction;
11801 new(): ProcessingInstruction;
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;
11812 declare var ProgressEvent: {
11813 prototype: ProgressEvent;
11814 new(type: string, eventInitDict?: ProgressEventInit): ProgressEvent;
11817 interface PromiseRejectionEvent extends Event {
11818 readonly promise: Promise<any>;
11819 readonly reason: any;
11822 declare var PromiseRejectionEvent: {
11823 prototype: PromiseRejectionEvent;
11824 new(type: string, eventInitDict: PromiseRejectionEventInit): PromiseRejectionEvent;
11827 interface PublicKeyCredential extends Credential {
11828 readonly rawId: ArrayBuffer;
11829 readonly response: AuthenticatorResponse;
11830 getClientExtensionResults(): AuthenticationExtensionsClientOutputs;
11833 declare var PublicKeyCredential: {
11834 prototype: PublicKeyCredential;
11835 new(): PublicKeyCredential;
11836 isUserVerifyingPlatformAuthenticatorAvailable(): Promise<boolean>;
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>;
11846 declare var PushManager: {
11847 prototype: PushManager;
11848 new(): PushManager;
11849 readonly supportedContentEncodings: ReadonlyArray<string>;
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>;
11862 declare var PushSubscription: {
11863 prototype: PushSubscription;
11864 new(): PushSubscription;
11867 interface PushSubscriptionOptions {
11868 readonly applicationServerKey: ArrayBuffer | null;
11869 readonly userVisibleOnly: boolean;
11872 declare var PushSubscriptionOptions: {
11873 prototype: PushSubscriptionOptions;
11874 new(): PushSubscriptionOptions;
11877 interface RTCCertificate {
11878 readonly expires: number;
11879 getFingerprints(): RTCDtlsFingerprint[];
11882 declare var RTCCertificate: {
11883 prototype: RTCCertificate;
11884 new(): RTCCertificate;
11885 getSupportedAlgorithms(): AlgorithmIdentifier[];
11888 interface RTCDTMFSenderEventMap {
11889 "tonechange": RTCDTMFToneChangeEvent;
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;
11903 declare var RTCDTMFSender: {
11904 prototype: RTCDTMFSender;
11905 new(): RTCDTMFSender;
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;
11913 declare var RTCDTMFToneChangeEvent: {
11914 prototype: RTCDTMFToneChangeEvent;
11915 new(type: string, eventInitDict: RTCDTMFToneChangeEventInit): RTCDTMFToneChangeEvent;
11918 interface RTCDataChannelEventMap {
11919 "bufferedamountlow": Event;
11921 "error": RTCErrorEvent;
11922 "message": MessageEvent;
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;
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;
11955 declare var RTCDataChannel: {
11956 prototype: RTCDataChannel;
11957 new(): RTCDataChannel;
11960 interface RTCDataChannelEvent extends Event {
11961 readonly channel: RTCDataChannel;
11964 declare var RTCDataChannelEvent: {
11965 prototype: RTCDataChannelEvent;
11966 new(type: string, eventInitDict: RTCDataChannelEventInit): RTCDataChannelEvent;
11969 interface RTCDtlsTransportEventMap {
11970 "error": RTCErrorEvent;
11971 "statechange": Event;
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;
11986 declare var RTCDtlsTransport: {
11987 prototype: RTCDtlsTransport;
11988 new(): RTCDtlsTransport;
11991 interface RTCDtlsTransportStateChangedEvent extends Event {
11992 readonly state: RTCDtlsTransportState;
11995 declare var RTCDtlsTransportStateChangedEvent: {
11996 prototype: RTCDtlsTransportStateChangedEvent;
11997 new(): RTCDtlsTransportStateChangedEvent;
12000 interface RTCDtmfSenderEventMap {
12001 "tonechange": RTCDTMFToneChangeEvent;
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;
12018 declare var RTCDtmfSender: {
12019 prototype: RTCDtmfSender;
12020 new(sender: RTCRtpSender): RTCDtmfSender;
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;
12032 declare var RTCError: {
12033 prototype: RTCError;
12034 new(init: RTCErrorInit, message?: string): RTCError;
12037 interface RTCErrorEvent extends Event {
12038 readonly error: RTCError;
12041 declare var RTCErrorEvent: {
12042 prototype: RTCErrorEvent;
12043 new(type: string, eventInitDict: RTCErrorEventInit): RTCErrorEvent;
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;
12064 declare var RTCIceCandidate: {
12065 prototype: RTCIceCandidate;
12066 new(candidateInitDict?: RTCIceCandidateInit): RTCIceCandidate;
12069 interface RTCIceCandidatePairChangedEvent extends Event {
12070 readonly pair: RTCIceCandidatePair;
12073 declare var RTCIceCandidatePairChangedEvent: {
12074 prototype: RTCIceCandidatePairChangedEvent;
12075 new(): RTCIceCandidatePairChangedEvent;
12078 interface RTCIceGathererEventMap {
12080 "localcandidate": RTCIceGathererEvent;
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;
12096 declare var RTCIceGatherer: {
12097 prototype: RTCIceGatherer;
12098 new(options: RTCIceGatherOptions): RTCIceGatherer;
12101 interface RTCIceGathererEvent extends Event {
12102 readonly candidate: RTCIceCandidateDictionary | RTCIceCandidateComplete;
12105 declare var RTCIceGathererEvent: {
12106 prototype: RTCIceGathererEvent;
12107 new(): RTCIceGathererEvent;
12110 interface RTCIceTransportEventMap {
12111 "gatheringstatechange": Event;
12112 "selectedcandidatepairchange": Event;
12113 "statechange": Event;
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;
12136 declare var RTCIceTransport: {
12137 prototype: RTCIceTransport;
12138 new(): RTCIceTransport;
12141 interface RTCIceTransportStateChangedEvent extends Event {
12142 readonly state: RTCIceTransportState;
12145 declare var RTCIceTransportStateChangedEvent: {
12146 prototype: RTCIceTransportStateChangedEvent;
12147 new(): RTCIceTransportStateChangedEvent;
12150 interface RTCIdentityAssertion {
12155 declare var RTCIdentityAssertion: {
12156 prototype: RTCIdentityAssertion;
12157 new(idp: string, name: string): RTCIdentityAssertion;
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;
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;
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;
12224 declare var RTCPeerConnection: {
12225 prototype: RTCPeerConnection;
12226 new(configuration?: RTCConfiguration): RTCPeerConnection;
12227 generateCertificate(keygenAlgorithm: AlgorithmIdentifier): Promise<RTCCertificate>;
12228 getDefaultIceServers(): RTCIceServer[];
12231 interface RTCPeerConnectionIceErrorEvent extends Event {
12232 readonly errorCode: number;
12233 readonly errorText: string;
12234 readonly hostCandidate: string;
12235 readonly url: string;
12238 declare var RTCPeerConnectionIceErrorEvent: {
12239 prototype: RTCPeerConnectionIceErrorEvent;
12240 new(type: string, eventInitDict: RTCPeerConnectionIceErrorEventInit): RTCPeerConnectionIceErrorEvent;
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;
12249 declare var RTCPeerConnectionIceEvent: {
12250 prototype: RTCPeerConnectionIceEvent;
12251 new(type: string, eventInitDict?: RTCPeerConnectionIceEventInit): RTCPeerConnectionIceEvent;
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[];
12265 declare var RTCRtpReceiver: {
12266 prototype: RTCRtpReceiver;
12267 new(): RTCRtpReceiver;
12268 getCapabilities(kind: string): RTCRtpCapabilities | null;
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;
12284 declare var RTCRtpSender: {
12285 prototype: RTCRtpSender;
12286 new(): RTCRtpSender;
12287 getCapabilities(kind: string): RTCRtpCapabilities | null;
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;
12300 declare var RTCRtpTransceiver: {
12301 prototype: RTCRtpTransceiver;
12302 new(): RTCRtpTransceiver;
12305 interface RTCSctpTransportEventMap {
12306 "statechange": Event;
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;
12321 declare var RTCSctpTransport: {
12322 prototype: RTCSctpTransport;
12323 new(): RTCSctpTransport;
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;
12333 declare var RTCSessionDescription: {
12334 prototype: RTCSessionDescription;
12335 new(descriptionInitDict?: RTCSessionDescriptionInit): RTCSessionDescription;
12338 interface RTCSrtpSdesTransportEventMap {
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;
12351 declare var RTCSrtpSdesTransport: {
12352 prototype: RTCSrtpSdesTransport;
12353 new(transport: RTCIceTransport, encryptParameters: RTCSrtpSdesParameters, decryptParameters: RTCSrtpSdesParameters): RTCSrtpSdesTransport;
12354 getLocalParameters(): RTCSrtpSdesParameters[];
12357 interface RTCSsrcConflictEvent extends Event {
12358 readonly ssrc: number;
12361 declare var RTCSsrcConflictEvent: {
12362 prototype: RTCSsrcConflictEvent;
12363 new(): RTCSsrcConflictEvent;
12366 interface RTCStatsEvent extends Event {
12367 readonly report: RTCStatsReport;
12370 declare var RTCStatsEvent: {
12371 prototype: RTCStatsEvent;
12372 new(type: string, eventInitDict: RTCStatsEventInit): RTCStatsEvent;
12375 interface RTCStatsProvider extends EventTarget {
12376 getStats(): Promise<RTCStatsReport>;
12377 msGetStats(): Promise<RTCStatsReport>;
12380 declare var RTCStatsProvider: {
12381 prototype: RTCStatsProvider;
12382 new(): RTCStatsProvider;
12385 interface RTCStatsReport {
12386 forEach(callbackfn: (value: any, key: string, parent: RTCStatsReport) => void, thisArg?: any): void;
12389 declare var RTCStatsReport: {
12390 prototype: RTCStatsReport;
12391 new(): RTCStatsReport;
12394 interface RTCTrackEvent extends Event {
12395 readonly receiver: RTCRtpReceiver;
12396 readonly streams: ReadonlyArray<MediaStream>;
12397 readonly track: MediaStreamTrack;
12398 readonly transceiver: RTCRtpTransceiver;
12401 declare var RTCTrackEvent: {
12402 prototype: RTCTrackEvent;
12403 new(type: string, eventInitDict: RTCTrackEventInit): RTCTrackEvent;
12406 interface RadioNodeList extends NodeList {
12410 declare var RadioNodeList: {
12411 prototype: RadioNodeList;
12412 new(): RadioNodeList;
12415 interface RandomSource {
12416 getRandomValues<T extends Int8Array | Uint8ClampedArray | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array>(array: T): T;
12419 declare var RandomSource: {
12420 prototype: RandomSource;
12421 new(): RandomSource;
12424 /** A fragment of a document that can contain nodes and parts of text nodes. */
12425 interface Range extends AbstractRange {
12427 * Returns the node, furthest away from the document, that is an ancestor of both range's start node and end node.
12429 readonly commonAncestorContainer: Node;
12430 cloneContents(): DocumentFragment;
12431 cloneRange(): Range;
12432 collapse(toStart?: boolean): void;
12433 compareBoundaryPoints(how: number, sourceRange: Range): number;
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.
12437 comparePoint(node: Node, offset: number): number;
12438 createContextualFragment(fragment: string): DocumentFragment;
12439 deleteContents(): void;
12441 extractContents(): DocumentFragment;
12442 getBoundingClientRect(): DOMRect;
12443 getClientRects(): DOMRectList;
12444 insertNode(node: Node): void;
12446 * Returns whether range intersects node.
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;
12466 declare var 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;
12476 interface ReadableByteStreamController {
12477 readonly byobRequest: ReadableStreamBYOBRequest | undefined;
12478 readonly desiredSize: number | null;
12480 enqueue(chunk: ArrayBufferView): void;
12481 error(error?: any): void;
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>];
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>;
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;
12508 interface ReadableStreamBYOBRequest {
12509 readonly view: ArrayBufferView;
12510 respond(bytesWritten: number): void;
12511 respondWithNewView(view: ArrayBufferView): void;
12514 interface ReadableStreamDefaultController<R = any> {
12515 readonly desiredSize: number | null;
12517 enqueue(chunk: R): void;
12518 error(error?: any): void;
12521 interface ReadableStreamDefaultReader<R = any> {
12522 readonly closed: Promise<void>;
12523 cancel(reason?: any): Promise<void>;
12524 read(): Promise<ReadableStreamReadResult<R>>;
12525 releaseLock(): void;
12528 interface ReadableStreamReader<R = any> {
12529 cancel(): Promise<void>;
12530 read(): Promise<ReadableStreamReadResult<R>>;
12531 releaseLock(): void;
12534 declare var ReadableStreamReader: {
12535 prototype: ReadableStreamReader;
12536 new(): ReadableStreamReader;
12539 /** This Fetch API interface represents a resource request. */
12540 interface Request extends Body {
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.
12544 readonly cache: RequestCache;
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.
12548 readonly credentials: RequestCredentials;
12550 * Returns the kind of resource requested by request, e.g., "document" or "script".
12552 readonly destination: RequestDestination;
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.
12556 readonly headers: Headers;
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]
12560 readonly integrity: string;
12562 * Returns a boolean indicating whether or not request is for a history navigation (a.k.a. back-foward navigation).
12564 readonly isHistoryNavigation: boolean;
12566 * Returns a boolean indicating whether or not request is for a reload navigation.
12568 readonly isReloadNavigation: boolean;
12570 * Returns a boolean indicating whether or not request can outlive the global in which it was created.
12572 readonly keepalive: boolean;
12574 * Returns request's HTTP method, which is "GET" by default.
12576 readonly method: string;
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.
12580 readonly mode: RequestMode;
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.
12584 readonly redirect: RequestRedirect;
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.
12588 readonly referrer: string;
12590 * Returns the referrer policy associated with request. This is used during fetching to compute the value of the request's referrer.
12592 readonly referrerPolicy: ReferrerPolicy;
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.
12596 readonly signal: AbortSignal;
12598 * Returns the URL of request as a string.
12600 readonly url: string;
12604 declare var Request: {
12605 prototype: Request;
12606 new(input: RequestInfo, init?: RequestInit): Request;
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;
12622 declare var Response: {
12623 prototype: Response;
12624 new(body?: BodyInit | null, init?: ResponseInit): Response;
12626 redirect(url: string, status?: number): Response;
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;
12638 declare var SVGAElement: {
12639 prototype: SVGAElement;
12640 new(): SVGAElement;
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;
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;
12658 declare var SVGAngle: {
12659 prototype: 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;
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;
12675 declare var SVGAnimateElement: {
12676 prototype: SVGAnimateElement;
12677 new(): SVGAnimateElement;
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;
12687 declare var SVGAnimateMotionElement: {
12688 prototype: SVGAnimateMotionElement;
12689 new(): SVGAnimateMotionElement;
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;
12699 declare var SVGAnimateTransformElement: {
12700 prototype: SVGAnimateTransformElement;
12701 new(): SVGAnimateTransformElement;
12704 /** Used for attributes of basic type <angle> which can be animated. */
12705 interface SVGAnimatedAngle {
12706 readonly animVal: SVGAngle;
12707 readonly baseVal: SVGAngle;
12710 declare var SVGAnimatedAngle: {
12711 prototype: SVGAnimatedAngle;
12712 new(): SVGAnimatedAngle;
12715 /** Used for attributes of type boolean which can be animated. */
12716 interface SVGAnimatedBoolean {
12717 readonly animVal: boolean;
12721 declare var SVGAnimatedBoolean: {
12722 prototype: SVGAnimatedBoolean;
12723 new(): SVGAnimatedBoolean;
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;
12732 declare var SVGAnimatedEnumeration: {
12733 prototype: SVGAnimatedEnumeration;
12734 new(): SVGAnimatedEnumeration;
12737 /** Used for attributes of basic type <integer> which can be animated. */
12738 interface SVGAnimatedInteger {
12739 readonly animVal: number;
12743 declare var SVGAnimatedInteger: {
12744 prototype: SVGAnimatedInteger;
12745 new(): SVGAnimatedInteger;
12748 /** Used for attributes of basic type <length> which can be animated. */
12749 interface SVGAnimatedLength {
12750 readonly animVal: SVGLength;
12751 readonly baseVal: SVGLength;
12754 declare var SVGAnimatedLength: {
12755 prototype: SVGAnimatedLength;
12756 new(): SVGAnimatedLength;
12759 /** Used for attributes of type SVGLengthList which can be animated. */
12760 interface SVGAnimatedLengthList {
12761 readonly animVal: SVGLengthList;
12762 readonly baseVal: SVGLengthList;
12765 declare var SVGAnimatedLengthList: {
12766 prototype: SVGAnimatedLengthList;
12767 new(): SVGAnimatedLengthList;
12770 /** Used for attributes of basic type <Number> which can be animated. */
12771 interface SVGAnimatedNumber {
12772 readonly animVal: number;
12776 declare var SVGAnimatedNumber: {
12777 prototype: SVGAnimatedNumber;
12778 new(): SVGAnimatedNumber;
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;
12787 declare var SVGAnimatedNumberList: {
12788 prototype: SVGAnimatedNumberList;
12789 new(): SVGAnimatedNumberList;
12792 interface SVGAnimatedPoints {
12793 readonly animatedPoints: SVGPointList;
12794 readonly points: SVGPointList;
12797 /** Used for attributes of type SVGPreserveAspectRatio which can be animated. */
12798 interface SVGAnimatedPreserveAspectRatio {
12799 readonly animVal: SVGPreserveAspectRatio;
12800 readonly baseVal: SVGPreserveAspectRatio;
12803 declare var SVGAnimatedPreserveAspectRatio: {
12804 prototype: SVGAnimatedPreserveAspectRatio;
12805 new(): SVGAnimatedPreserveAspectRatio;
12808 /** Used for attributes of basic SVGRect which can be animated. */
12809 interface SVGAnimatedRect {
12810 readonly animVal: DOMRectReadOnly;
12811 readonly baseVal: DOMRect;
12814 declare var SVGAnimatedRect: {
12815 prototype: SVGAnimatedRect;
12816 new(): SVGAnimatedRect;
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;
12825 declare var SVGAnimatedString: {
12826 prototype: SVGAnimatedString;
12827 new(): SVGAnimatedString;
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;
12836 declare var SVGAnimatedTransformList: {
12837 prototype: SVGAnimatedTransformList;
12838 new(): SVGAnimatedTransformList;
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;
12852 declare var SVGAnimationElement: {
12853 prototype: SVGAnimationElement;
12854 new(): SVGAnimationElement;
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;
12868 declare var SVGCircleElement: {
12869 prototype: SVGCircleElement;
12870 new(): SVGCircleElement;
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;
12883 declare var SVGClipPathElement: {
12884 prototype: SVGClipPathElement;
12885 new(): SVGClipPathElement;
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;
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;
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;
12929 declare var SVGCursorElement: {
12930 prototype: SVGCursorElement;
12931 new(): SVGCursorElement;
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;
12942 declare var SVGDefsElement: {
12943 prototype: SVGDefsElement;
12944 new(): SVGDefsElement;
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;
12955 declare var SVGDescElement: {
12956 prototype: SVGDescElement;
12957 new(): SVGDescElement;
12960 interface SVGElementEventMap extends ElementEventMap, GlobalEventHandlersEventMap, DocumentAndElementEventHandlersEventMap {
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 {
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;
12975 declare var SVGElement: {
12976 prototype: SVGElement;
12980 interface SVGElementInstance extends EventTarget {
12981 readonly correspondingElement: SVGElement;
12982 readonly correspondingUseElement: SVGUseElement;
12985 declare var SVGElementInstance: {
12986 prototype: SVGElementInstance;
12987 new(): SVGElementInstance;
12990 interface SVGElementInstanceList {
12992 readonly length: number;
12994 item(index: number): SVGElementInstance;
12997 declare var SVGElementInstanceList: {
12998 prototype: SVGElementInstanceList;
12999 new(): SVGElementInstanceList;
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;
13014 declare var SVGEllipseElement: {
13015 prototype: SVGEllipseElement;
13016 new(): SVGEllipseElement;
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;
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;
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;
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;
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;
13104 declare var SVGFEComponentTransferElement: {
13105 prototype: SVGFEComponentTransferElement;
13106 new(): SVGFEComponentTransferElement;
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;
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;
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;
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;
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;
13189 declare var SVGFEDiffuseLightingElement: {
13190 prototype: SVGFEDiffuseLightingElement;
13191 new(): SVGFEDiffuseLightingElement;
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;
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;
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;
13232 declare var SVGFEDistantLightElement: {
13233 prototype: SVGFEDistantLightElement;
13234 new(): SVGFEDistantLightElement;
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;
13250 declare var SVGFEDropShadowElement: {
13251 prototype: SVGFEDropShadowElement;
13252 new(): SVGFEDropShadowElement;
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;
13263 declare var SVGFEFloodElement: {
13264 prototype: SVGFEFloodElement;
13265 new(): SVGFEFloodElement;
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;
13276 declare var SVGFEFuncAElement: {
13277 prototype: SVGFEFuncAElement;
13278 new(): SVGFEFuncAElement;
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;
13289 declare var SVGFEFuncBElement: {
13290 prototype: SVGFEFuncBElement;
13291 new(): SVGFEFuncBElement;
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;
13302 declare var SVGFEFuncGElement: {
13303 prototype: SVGFEFuncGElement;
13304 new(): SVGFEFuncGElement;
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;
13315 declare var SVGFEFuncRElement: {
13316 prototype: SVGFEFuncRElement;
13317 new(): SVGFEFuncRElement;
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;
13332 declare var SVGFEGaussianBlurElement: {
13333 prototype: SVGFEGaussianBlurElement;
13334 new(): SVGFEGaussianBlurElement;
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;
13346 declare var SVGFEImageElement: {
13347 prototype: SVGFEImageElement;
13348 new(): SVGFEImageElement;
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;
13359 declare var SVGFEMergeElement: {
13360 prototype: SVGFEMergeElement;
13361 new(): SVGFEMergeElement;
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;
13373 declare var SVGFEMergeNodeElement: {
13374 prototype: SVGFEMergeNodeElement;
13375 new(): SVGFEMergeNodeElement;
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;
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;
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;
13412 declare var SVGFEOffsetElement: {
13413 prototype: SVGFEOffsetElement;
13414 new(): SVGFEOffsetElement;
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;
13428 declare var SVGFEPointLightElement: {
13429 prototype: SVGFEPointLightElement;
13430 new(): SVGFEPointLightElement;
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;
13447 declare var SVGFESpecularLightingElement: {
13448 prototype: SVGFESpecularLightingElement;
13449 new(): SVGFESpecularLightingElement;
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;
13468 declare var SVGFESpotLightElement: {
13469 prototype: SVGFESpotLightElement;
13470 new(): SVGFESpotLightElement;
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;
13482 declare var SVGFETileElement: {
13483 prototype: SVGFETileElement;
13484 new(): SVGFETileElement;
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;
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;
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;
13532 declare var SVGFilterElement: {
13533 prototype: SVGFilterElement;
13534 new(): SVGFilterElement;
13537 interface SVGFilterPrimitiveStandardAttributes {
13538 readonly height: SVGAnimatedLength;
13539 readonly result: SVGAnimatedString;
13540 readonly width: SVGAnimatedLength;
13541 readonly x: SVGAnimatedLength;
13542 readonly y: SVGAnimatedLength;
13545 interface SVGFitToViewBox {
13546 readonly preserveAspectRatio: SVGAnimatedPreserveAspectRatio;
13547 readonly viewBox: SVGAnimatedRect;
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;
13562 declare var SVGForeignObjectElement: {
13563 prototype: SVGForeignObjectElement;
13564 new(): SVGForeignObjectElement;
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;
13575 declare var SVGGElement: {
13576 prototype: SVGGElement;
13577 new(): SVGGElement;
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;
13592 declare var SVGGeometryElement: {
13593 prototype: SVGGeometryElement;
13594 new(): SVGGeometryElement;
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;
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;
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;
13633 declare var SVGGraphicsElement: {
13634 prototype: SVGGraphicsElement;
13635 new(): SVGGraphicsElement;
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;
13651 declare var SVGImageElement: {
13652 prototype: SVGImageElement;
13653 new(): SVGImageElement;
13656 /** Correspond to the <length> basic data type. */
13657 interface SVGLength {
13658 readonly unitType: 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;
13677 declare var SVGLength: {
13678 prototype: 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;
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;
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;
13707 declare var SVGLengthList: {
13708 prototype: SVGLengthList;
13709 new(): SVGLengthList;
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;
13724 declare var SVGLineElement: {
13725 prototype: SVGLineElement;
13726 new(): SVGLineElement;
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;
13741 declare var SVGLinearGradientElement: {
13742 prototype: SVGLinearGradientElement;
13743 new(): SVGLinearGradientElement;
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;
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;
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;
13793 declare var SVGMaskElement: {
13794 prototype: SVGMaskElement;
13795 new(): SVGMaskElement;
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;
13806 declare var SVGMetadataElement: {
13807 prototype: SVGMetadataElement;
13808 new(): SVGMetadataElement;
13811 /** Corresponds to the <number> basic data type. */
13812 interface SVGNumber {
13816 declare var SVGNumber: {
13817 prototype: SVGNumber;
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;
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;
13835 declare var SVGNumberList: {
13836 prototype: SVGNumberList;
13837 new(): SVGNumberList;
13840 /** Corresponds to the <path> element. */
13841 interface SVGPathElement extends SVGGraphicsElement {
13843 readonly pathSegList: SVGPathSegList;
13845 createSVGPathSegArcAbs(x: number, y: number, r1: number, r2: number, angle: number, largeArcFlag: boolean, sweepFlag: boolean): SVGPathSegArcAbs;
13847 createSVGPathSegArcRel(x: number, y: number, r1: number, r2: number, angle: number, largeArcFlag: boolean, sweepFlag: boolean): SVGPathSegArcRel;
13849 createSVGPathSegClosePath(): SVGPathSegClosePath;
13851 createSVGPathSegCurvetoCubicAbs(x: number, y: number, x1: number, y1: number, x2: number, y2: number): SVGPathSegCurvetoCubicAbs;
13853 createSVGPathSegCurvetoCubicRel(x: number, y: number, x1: number, y1: number, x2: number, y2: number): SVGPathSegCurvetoCubicRel;
13855 createSVGPathSegCurvetoCubicSmoothAbs(x: number, y: number, x2: number, y2: number): SVGPathSegCurvetoCubicSmoothAbs;
13857 createSVGPathSegCurvetoCubicSmoothRel(x: number, y: number, x2: number, y2: number): SVGPathSegCurvetoCubicSmoothRel;
13859 createSVGPathSegCurvetoQuadraticAbs(x: number, y: number, x1: number, y1: number): SVGPathSegCurvetoQuadraticAbs;
13861 createSVGPathSegCurvetoQuadraticRel(x: number, y: number, x1: number, y1: number): SVGPathSegCurvetoQuadraticRel;
13863 createSVGPathSegCurvetoQuadraticSmoothAbs(x: number, y: number): SVGPathSegCurvetoQuadraticSmoothAbs;
13865 createSVGPathSegCurvetoQuadraticSmoothRel(x: number, y: number): SVGPathSegCurvetoQuadraticSmoothRel;
13867 createSVGPathSegLinetoAbs(x: number, y: number): SVGPathSegLinetoAbs;
13869 createSVGPathSegLinetoHorizontalAbs(x: number): SVGPathSegLinetoHorizontalAbs;
13871 createSVGPathSegLinetoHorizontalRel(x: number): SVGPathSegLinetoHorizontalRel;
13873 createSVGPathSegLinetoRel(x: number, y: number): SVGPathSegLinetoRel;
13875 createSVGPathSegLinetoVerticalAbs(y: number): SVGPathSegLinetoVerticalAbs;
13877 createSVGPathSegLinetoVerticalRel(y: number): SVGPathSegLinetoVerticalRel;
13879 createSVGPathSegMovetoAbs(x: number, y: number): SVGPathSegMovetoAbs;
13881 createSVGPathSegMovetoRel(x: number, y: number): SVGPathSegMovetoRel;
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;
13892 declare var SVGPathElement: {
13893 prototype: SVGPathElement;
13894 new(): SVGPathElement;
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;
13922 declare var SVGPathSeg: {
13923 prototype: 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;
13947 interface SVGPathSegArcAbs extends SVGPathSeg {
13949 largeArcFlag: boolean;
13952 sweepFlag: boolean;
13957 declare var SVGPathSegArcAbs: {
13958 prototype: SVGPathSegArcAbs;
13959 new(): SVGPathSegArcAbs;
13962 interface SVGPathSegArcRel extends SVGPathSeg {
13964 largeArcFlag: boolean;
13967 sweepFlag: boolean;
13972 declare var SVGPathSegArcRel: {
13973 prototype: SVGPathSegArcRel;
13974 new(): SVGPathSegArcRel;
13977 interface SVGPathSegClosePath extends SVGPathSeg {
13980 declare var SVGPathSegClosePath: {
13981 prototype: SVGPathSegClosePath;
13982 new(): SVGPathSegClosePath;
13985 interface SVGPathSegCurvetoCubicAbs extends SVGPathSeg {
13994 declare var SVGPathSegCurvetoCubicAbs: {
13995 prototype: SVGPathSegCurvetoCubicAbs;
13996 new(): SVGPathSegCurvetoCubicAbs;
13999 interface SVGPathSegCurvetoCubicRel extends SVGPathSeg {
14008 declare var SVGPathSegCurvetoCubicRel: {
14009 prototype: SVGPathSegCurvetoCubicRel;
14010 new(): SVGPathSegCurvetoCubicRel;
14013 interface SVGPathSegCurvetoCubicSmoothAbs extends SVGPathSeg {
14020 declare var SVGPathSegCurvetoCubicSmoothAbs: {
14021 prototype: SVGPathSegCurvetoCubicSmoothAbs;
14022 new(): SVGPathSegCurvetoCubicSmoothAbs;
14025 interface SVGPathSegCurvetoCubicSmoothRel extends SVGPathSeg {
14032 declare var SVGPathSegCurvetoCubicSmoothRel: {
14033 prototype: SVGPathSegCurvetoCubicSmoothRel;
14034 new(): SVGPathSegCurvetoCubicSmoothRel;
14037 interface SVGPathSegCurvetoQuadraticAbs extends SVGPathSeg {
14044 declare var SVGPathSegCurvetoQuadraticAbs: {
14045 prototype: SVGPathSegCurvetoQuadraticAbs;
14046 new(): SVGPathSegCurvetoQuadraticAbs;
14049 interface SVGPathSegCurvetoQuadraticRel extends SVGPathSeg {
14056 declare var SVGPathSegCurvetoQuadraticRel: {
14057 prototype: SVGPathSegCurvetoQuadraticRel;
14058 new(): SVGPathSegCurvetoQuadraticRel;
14061 interface SVGPathSegCurvetoQuadraticSmoothAbs extends SVGPathSeg {
14066 declare var SVGPathSegCurvetoQuadraticSmoothAbs: {
14067 prototype: SVGPathSegCurvetoQuadraticSmoothAbs;
14068 new(): SVGPathSegCurvetoQuadraticSmoothAbs;
14071 interface SVGPathSegCurvetoQuadraticSmoothRel extends SVGPathSeg {
14076 declare var SVGPathSegCurvetoQuadraticSmoothRel: {
14077 prototype: SVGPathSegCurvetoQuadraticSmoothRel;
14078 new(): SVGPathSegCurvetoQuadraticSmoothRel;
14081 interface SVGPathSegLinetoAbs extends SVGPathSeg {
14086 declare var SVGPathSegLinetoAbs: {
14087 prototype: SVGPathSegLinetoAbs;
14088 new(): SVGPathSegLinetoAbs;
14091 interface SVGPathSegLinetoHorizontalAbs extends SVGPathSeg {
14095 declare var SVGPathSegLinetoHorizontalAbs: {
14096 prototype: SVGPathSegLinetoHorizontalAbs;
14097 new(): SVGPathSegLinetoHorizontalAbs;
14100 interface SVGPathSegLinetoHorizontalRel extends SVGPathSeg {
14104 declare var SVGPathSegLinetoHorizontalRel: {
14105 prototype: SVGPathSegLinetoHorizontalRel;
14106 new(): SVGPathSegLinetoHorizontalRel;
14109 interface SVGPathSegLinetoRel extends SVGPathSeg {
14114 declare var SVGPathSegLinetoRel: {
14115 prototype: SVGPathSegLinetoRel;
14116 new(): SVGPathSegLinetoRel;
14119 interface SVGPathSegLinetoVerticalAbs extends SVGPathSeg {
14123 declare var SVGPathSegLinetoVerticalAbs: {
14124 prototype: SVGPathSegLinetoVerticalAbs;
14125 new(): SVGPathSegLinetoVerticalAbs;
14128 interface SVGPathSegLinetoVerticalRel extends SVGPathSeg {
14132 declare var SVGPathSegLinetoVerticalRel: {
14133 prototype: SVGPathSegLinetoVerticalRel;
14134 new(): SVGPathSegLinetoVerticalRel;
14137 interface SVGPathSegList {
14138 readonly numberOfItems: number;
14139 appendItem(newItem: SVGPathSeg): SVGPathSeg;
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;
14148 declare var SVGPathSegList: {
14149 prototype: SVGPathSegList;
14150 new(): SVGPathSegList;
14153 interface SVGPathSegMovetoAbs extends SVGPathSeg {
14158 declare var SVGPathSegMovetoAbs: {
14159 prototype: SVGPathSegMovetoAbs;
14160 new(): SVGPathSegMovetoAbs;
14163 interface SVGPathSegMovetoRel extends SVGPathSeg {
14168 declare var SVGPathSegMovetoRel: {
14169 prototype: SVGPathSegMovetoRel;
14170 new(): SVGPathSegMovetoRel;
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;
14188 declare var SVGPatternElement: {
14189 prototype: SVGPatternElement;
14190 new(): SVGPatternElement;
14193 interface SVGPointList {
14194 readonly length: number;
14195 readonly numberOfItems: number;
14196 appendItem(newItem: DOMPoint): DOMPoint;
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;
14206 declare var SVGPointList: {
14207 prototype: SVGPointList;
14208 new(): SVGPointList;
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;
14219 declare var SVGPolygonElement: {
14220 prototype: SVGPolygonElement;
14221 new(): SVGPolygonElement;
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;
14232 declare var SVGPolylineElement: {
14233 prototype: SVGPolylineElement;
14234 new(): SVGPolylineElement;
14237 /** Corresponds to the preserveAspectRatio attribute, which is available for some of SVG's elements. */
14238 interface SVGPreserveAspectRatio {
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;
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;
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;
14290 declare var SVGRadialGradientElement: {
14291 prototype: SVGRadialGradientElement;
14292 new(): SVGRadialGradientElement;
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;
14309 declare var SVGRectElement: {
14310 prototype: SVGRectElement;
14311 new(): SVGRectElement;
14314 interface SVGSVGElementEventMap extends SVGElementEventMap {
14315 "SVGUnload": Event;
14316 "SVGZoom": SVGZoomEvent;
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 {
14322 contentScriptType: string;
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;
14331 readonly pixelUnitToMillimeterX: number;
14333 readonly pixelUnitToMillimeterY: number;
14335 readonly screenPixelToMillimeterX: number;
14337 readonly screenPixelToMillimeterY: number;
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;
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;
14365 suspendRedraw(maxWaitMilliseconds: number): number;
14366 unpauseAnimations(): void;
14368 unsuspendRedraw(suspendHandleID: number): void;
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;
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;
14385 /** Corresponds to the SVG <script> element. */
14386 interface SVGScriptElement extends SVGElement, SVGURIReference {
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;
14394 declare var SVGScriptElement: {
14395 prototype: SVGScriptElement;
14396 new(): SVGScriptElement;
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;
14408 declare var SVGStopElement: {
14409 prototype: SVGStopElement;
14410 new(): SVGStopElement;
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;
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;
14427 declare var SVGStringList: {
14428 prototype: SVGStringList;
14429 new(): SVGStringList;
14432 /** Corresponds to the SVG <style> element. */
14433 interface SVGStyleElement extends SVGElement {
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;
14444 declare var SVGStyleElement: {
14445 prototype: SVGStyleElement;
14446 new(): SVGStyleElement;
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;
14457 declare var SVGSwitchElement: {
14458 prototype: SVGSwitchElement;
14459 new(): SVGSwitchElement;
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;
14470 declare var SVGSymbolElement: {
14471 prototype: SVGSymbolElement;
14472 new(): SVGSymbolElement;
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;
14483 declare var SVGTSpanElement: {
14484 prototype: SVGTSpanElement;
14485 new(): SVGTSpanElement;
14488 interface SVGTests {
14489 readonly requiredExtensions: SVGStringList;
14490 readonly systemLanguage: SVGStringList;
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;
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;
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;
14531 declare var SVGTextElement: {
14532 prototype: SVGTextElement;
14533 new(): SVGTextElement;
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;
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;
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;
14577 declare var SVGTextPositioningElement: {
14578 prototype: SVGTextPositioningElement;
14579 new(): SVGTextPositioningElement;
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;
14590 declare var SVGTitleElement: {
14591 prototype: SVGTitleElement;
14592 new(): SVGTitleElement;
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;
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;
14627 /** The SVGTransformList defines a list of SVGTransform objects. */
14628 interface SVGTransformList {
14629 readonly numberOfItems: number;
14630 appendItem(newItem: SVGTransform): SVGTransform;
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;
14641 declare var SVGTransformList: {
14642 prototype: SVGTransformList;
14643 new(): SVGTransformList;
14646 interface SVGURIReference {
14647 readonly href: SVGAnimatedString;
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;
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;
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;
14679 declare var SVGUseElement: {
14680 prototype: SVGUseElement;
14681 new(): SVGUseElement;
14684 /** Provides access to the properties of <view> elements, as well as methods to manipulate them. */
14685 interface SVGViewElement extends SVGElement, SVGFitToViewBox, SVGZoomAndPan {
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;
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;
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;
14707 declare var SVGZoomAndPan: {
14708 readonly SVG_ZOOMANDPAN_DISABLE: number;
14709 readonly SVG_ZOOMANDPAN_MAGNIFY: number;
14710 readonly SVG_ZOOMANDPAN_UNKNOWN: number;
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;
14721 declare var SVGZoomEvent: {
14722 prototype: SVGZoomEvent;
14723 new(): SVGZoomEvent;
14726 interface ScopedCredential {
14727 readonly id: ArrayBuffer;
14728 readonly type: ScopedCredentialType;
14731 declare var ScopedCredential: {
14732 prototype: ScopedCredential;
14733 new(): ScopedCredential;
14736 interface ScopedCredentialInfo {
14737 readonly credential: ScopedCredential;
14738 readonly publicKey: CryptoKey;
14741 declare var ScopedCredentialInfo: {
14742 prototype: ScopedCredentialInfo;
14743 new(): ScopedCredentialInfo;
14746 /** A screen, usually the one on which the current window is being rendered, and is obtained using window.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;
14757 declare var Screen: {
14762 interface ScreenOrientationEventMap {
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>;
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;
14778 declare var ScreenOrientation: {
14779 prototype: ScreenOrientation;
14780 new(): ScreenOrientation;
14783 interface ScriptProcessorNodeEventMap {
14784 "audioprocess": AudioProcessingEvent;
14787 /** Allows the generation, processing, or analyzing of audio using JavaScript. */
14788 interface ScriptProcessorNode extends AudioNode {
14790 readonly bufferSize: number;
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;
14799 declare var ScriptProcessorNode: {
14800 prototype: ScriptProcessorNode;
14801 new(): ScriptProcessorNode;
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;
14818 declare var SecurityPolicyViolationEvent: {
14819 prototype: SecurityPolicyViolationEvent;
14820 new(type: string, eventInitDict?: SecurityPolicyViolationEventInit): SecurityPolicyViolationEvent;
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;
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;
14849 declare var Selection: {
14850 prototype: Selection;
14852 toString(): string;
14855 interface ServiceUIFrameContext {
14856 getCachedFrameMessage(key: string): string;
14857 postFrameMessage(key: string, data: string): void;
14859 declare var ServiceUIFrameContext: ServiceUIFrameContext;
14861 interface ServiceWorkerEventMap extends AbstractWorkerEventMap {
14862 "statechange": Event;
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;
14878 declare var ServiceWorker: {
14879 prototype: ServiceWorker;
14880 new(): ServiceWorker;
14883 interface ServiceWorkerContainerEventMap {
14884 "controllerchange": Event;
14885 "message": MessageEvent;
14886 "messageerror": MessageEvent;
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;
14906 declare var ServiceWorkerContainer: {
14907 prototype: ServiceWorkerContainer;
14908 new(): ServiceWorkerContainer;
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;
14920 declare var ServiceWorkerMessageEvent: {
14921 prototype: ServiceWorkerMessageEvent;
14922 new(type: string, eventInitDict?: ServiceWorkerMessageEventInit): ServiceWorkerMessageEvent;
14925 interface ServiceWorkerRegistrationEventMap {
14926 "updatefound": Event;
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;
14950 declare var ServiceWorkerRegistration: {
14951 prototype: ServiceWorkerRegistration;
14952 new(): ServiceWorkerRegistration;
14955 interface ShadowRoot extends DocumentFragment, DocumentOrShadowRoot, InnerHTML {
14956 readonly host: Element;
14957 readonly mode: ShadowRootMode;
14959 * Throws a "NotSupportedError" DOMException if context object is a shadow root.
14963 declare var ShadowRoot: {
14964 prototype: ShadowRoot;
14968 interface SharedWorker extends EventTarget, AbstractWorker {
14970 * Returns sharedWorker's MessagePort object which can be used to communicate with the global environment.
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;
14979 declare var SharedWorker: {
14980 prototype: SharedWorker;
14981 new(scriptURL: string, options?: string | WorkerOptions): SharedWorker;
14984 interface Slotable {
14985 readonly assignedSlot: HTMLSlotElement | null;
14988 interface SourceBufferEventMap {
14992 "updateend": Event;
14993 "updatestart": Event;
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;
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;
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;
15018 declare var SourceBuffer: {
15019 prototype: SourceBuffer;
15020 new(): SourceBuffer;
15023 interface SourceBufferListEventMap {
15024 "addsourcebuffer": Event;
15025 "removesourcebuffer": Event;
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;
15040 declare var SourceBufferList: {
15041 prototype: SourceBufferList;
15042 new(): SourceBufferList;
15045 interface SpeechGrammar {
15050 declare var SpeechGrammar: {
15051 prototype: SpeechGrammar;
15052 new(): SpeechGrammar;
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;
15063 declare var SpeechGrammarList: {
15064 prototype: SpeechGrammarList;
15065 new(): SpeechGrammarList;
15068 interface SpeechRecognitionEventMap {
15070 "audiostart": Event;
15073 "nomatch": SpeechRecognitionEvent;
15074 "result": SpeechRecognitionEvent;
15076 "soundstart": Event;
15077 "speechend": Event;
15078 "speechstart": Event;
15082 interface SpeechRecognition extends EventTarget {
15083 continuous: boolean;
15084 grammars: SpeechGrammarList;
15085 interimResults: boolean;
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;
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;
15108 declare var SpeechRecognition: {
15109 prototype: SpeechRecognition;
15110 new(): SpeechRecognition;
15113 interface SpeechRecognitionAlternative {
15114 readonly confidence: number;
15115 readonly transcript: string;
15118 declare var SpeechRecognitionAlternative: {
15119 prototype: SpeechRecognitionAlternative;
15120 new(): SpeechRecognitionAlternative;
15123 interface SpeechRecognitionEvent extends Event {
15124 readonly resultIndex: number;
15125 readonly results: SpeechRecognitionResultList;
15128 declare var SpeechRecognitionEvent: {
15129 prototype: SpeechRecognitionEvent;
15130 new(): SpeechRecognitionEvent;
15133 interface SpeechRecognitionResult {
15134 readonly isFinal: boolean;
15135 readonly length: number;
15136 item(index: number): SpeechRecognitionAlternative;
15137 [index: number]: SpeechRecognitionAlternative;
15140 declare var SpeechRecognitionResult: {
15141 prototype: SpeechRecognitionResult;
15142 new(): SpeechRecognitionResult;
15145 interface SpeechRecognitionResultList {
15146 readonly length: number;
15147 item(index: number): SpeechRecognitionResult;
15148 [index: number]: SpeechRecognitionResult;
15151 declare var SpeechRecognitionResultList: {
15152 prototype: SpeechRecognitionResultList;
15153 new(): SpeechRecognitionResultList;
15156 interface SpeechSynthesisEventMap {
15157 "voiceschanged": Event;
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;
15167 getVoices(): SpeechSynthesisVoice[];
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;
15177 declare var SpeechSynthesis: {
15178 prototype: SpeechSynthesis;
15179 new(): SpeechSynthesis;
15182 interface SpeechSynthesisErrorEvent extends SpeechSynthesisEvent {
15183 readonly error: SpeechSynthesisErrorCode;
15186 declare var SpeechSynthesisErrorEvent: {
15187 prototype: SpeechSynthesisErrorEvent;
15188 new(type: string, eventInitDict: SpeechSynthesisErrorEventInit): SpeechSynthesisErrorEvent;
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;
15200 declare var SpeechSynthesisEvent: {
15201 prototype: SpeechSynthesisEvent;
15202 new(type: string, eventInitDict: SpeechSynthesisEventInit): SpeechSynthesisEvent;
15205 interface SpeechSynthesisUtteranceEventMap {
15206 "boundary": SpeechSynthesisEvent;
15207 "end": SpeechSynthesisEvent;
15208 "error": SpeechSynthesisErrorEvent;
15209 "mark": SpeechSynthesisEvent;
15210 "pause": SpeechSynthesisEvent;
15211 "resume": SpeechSynthesisEvent;
15212 "start": SpeechSynthesisEvent;
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 {
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;
15228 voice: SpeechSynthesisVoice | null;
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;
15236 declare var SpeechSynthesisUtterance: {
15237 prototype: SpeechSynthesisUtterance;
15238 new(text?: string): SpeechSynthesisUtterance;
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;
15250 declare var SpeechSynthesisVoice: {
15251 prototype: SpeechSynthesisVoice;
15252 new(): SpeechSynthesisVoice;
15255 interface StaticRange extends AbstractRange {
15258 declare var StaticRange: {
15259 prototype: StaticRange;
15260 new(init: StaticRangeInit): StaticRange;
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;
15268 declare var StereoPannerNode: {
15269 prototype: StereoPannerNode;
15270 new(context: BaseAudioContext, options?: StereoPannerOptions): StereoPannerNode;
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 {
15276 * Returns the number of key/value pairs currently present in the list associated with the object.
15278 readonly length: number;
15280 * Empties the list associated with the object of all key/value pairs, if there are any.
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.
15286 getItem(key: string): string | null;
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.
15290 key(index: number): string | null;
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.
15294 removeItem(key: string): void;
15296 * Sets the value of the pair identified by key to value, creating a new key/value pair if none existed for key previously.
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.)
15300 setItem(key: string, value: string): void;
15301 [name: string]: any;
15304 declare var Storage: {
15305 prototype: Storage;
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 {
15312 * Returns the key of the storage item being changed.
15314 readonly key: string | null;
15316 * Returns the new value of the key of the storage item whose value is being changed.
15318 readonly newValue: string | null;
15320 * Returns the old value of the key of the storage item whose value is being changed.
15322 readonly oldValue: string | null;
15324 * Returns the Storage object that was affected.
15326 readonly storageArea: Storage | null;
15328 * Returns the URL of the document whose storage item changed.
15330 readonly url: string;
15333 declare var StorageEvent: {
15334 prototype: StorageEvent;
15335 new(type: string, eventInitDict?: StorageEventInit): StorageEvent;
15338 interface StorageManager {
15339 estimate(): Promise<StorageEstimate>;
15340 persist(): Promise<boolean>;
15341 persisted(): Promise<boolean>;
15344 declare var StorageManager: {
15345 prototype: StorageManager;
15346 new(): StorageManager;
15349 interface StyleMedia {
15350 readonly type: string;
15351 matchMedium(mediaquery: string): boolean;
15354 declare var StyleMedia: {
15355 prototype: StyleMedia;
15359 /** A single style sheet. CSS style sheets will further implement the more specialized CSSStyleSheet interface. */
15360 interface StyleSheet {
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;
15370 declare var StyleSheet: {
15371 prototype: StyleSheet;
15375 /** A list of StyleSheet. */
15376 interface StyleSheetList {
15377 readonly length: number;
15378 item(index: number): CSSStyleSheet | null;
15379 [index: number]: CSSStyleSheet;
15382 declare var StyleSheetList: {
15383 prototype: StyleSheetList;
15384 new(): StyleSheetList;
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>;
15409 declare var SubtleCrypto: {
15410 prototype: SubtleCrypto;
15411 new(): SubtleCrypto;
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>;
15420 declare var SyncManager: {
15421 prototype: SyncManager;
15422 new(): SyncManager;
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;
15429 * Returns the combined data of all direct Text node siblings.
15431 readonly wholeText: string;
15433 * Splits data at the given offset and returns the remainder as Text node.
15435 splitText(offset: number): Text;
15438 declare var Text: {
15440 new(data?: string): Text;
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 {
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.
15449 * var string = "", decoder = new TextDecoder(encoding), buffer;
15450 * while(buffer = next_chunk()) {
15451 * string += decoder.decode(buffer, {stream:true});
15453 * string += decoder.decode(); // end-of-stream
15456 * If the error mode is "fatal" and encoding's decoder returns error, throws a TypeError.
15458 decode(input?: BufferSource, options?: TextDecodeOptions): string;
15461 declare var TextDecoder: {
15462 prototype: TextDecoder;
15463 new(label?: string, options?: TextDecoderOptions): TextDecoder;
15466 interface TextDecoderCommon {
15468 * Returns encoding's name, lowercased.
15470 readonly encoding: string;
15472 * Returns true if error mode is "fatal", and false otherwise.
15474 readonly fatal: boolean;
15476 * Returns true if ignore BOM flag is set, and false otherwise.
15478 readonly ignoreBOM: boolean;
15481 interface TextDecoderStream extends GenericTransformStream, TextDecoderCommon {
15482 readonly readable: ReadableStream<string>;
15483 readonly writable: WritableStream<BufferSource>;
15486 declare var TextDecoderStream: {
15487 prototype: TextDecoderStream;
15488 new(label?: string, options?: TextDecoderOptions): TextDecoderStream;
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 {
15494 * Returns the result of running UTF-8's encoder.
15496 encode(input?: string): Uint8Array;
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.
15500 encodeInto(source: string, destination: Uint8Array): TextEncoderEncodeIntoResult;
15503 declare var TextEncoder: {
15504 prototype: TextEncoder;
15505 new(): TextEncoder;
15508 interface TextEncoderCommon {
15512 readonly encoding: string;
15515 interface TextEncoderStream extends GenericTransformStream, TextEncoderCommon {
15516 readonly readable: ReadableStream<Uint8Array>;
15517 readonly writable: WritableStream<string>;
15520 declare var TextEncoderStream: {
15521 prototype: TextEncoderStream;
15522 new(): TextEncoderStream;
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;
15540 declare var TextEvent: {
15541 prototype: 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;
15555 /** The dimensions of a piece of text in the canvas, as created by the CanvasRenderingContext2D.measureText() method. */
15556 interface TextMetrics {
15558 * Returns the measurement described below.
15560 readonly actualBoundingBoxAscent: number;
15562 * Returns the measurement described below.
15564 readonly actualBoundingBoxDescent: number;
15566 * Returns the measurement described below.
15568 readonly actualBoundingBoxLeft: number;
15570 * Returns the measurement described below.
15572 readonly actualBoundingBoxRight: number;
15574 * Returns the measurement described below.
15576 readonly alphabeticBaseline: number;
15578 * Returns the measurement described below.
15580 readonly emHeightAscent: number;
15582 * Returns the measurement described below.
15584 readonly emHeightDescent: number;
15586 * Returns the measurement described below.
15588 readonly fontBoundingBoxAscent: number;
15590 * Returns the measurement described below.
15592 readonly fontBoundingBoxDescent: number;
15594 * Returns the measurement described below.
15596 readonly hangingBaseline: number;
15598 * Returns the measurement described below.
15600 readonly ideographicBaseline: number;
15602 * Returns the measurement described below.
15604 readonly width: number;
15607 declare var TextMetrics: {
15608 prototype: TextMetrics;
15609 new(): TextMetrics;
15612 interface TextTrackEventMap {
15613 "cuechange": Event;
15616 /** This interface also inherits properties from EventTarget. */
15617 interface TextTrack extends EventTarget {
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.
15621 readonly activeCues: TextTrackCueList | null;
15623 * Returns the text track list of cues, as a TextTrackCueList object.
15625 readonly cues: TextTrackCueList | null;
15627 * Returns the ID of the given track.
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.
15631 * For TextTrack objects corresponding to track elements, this is the ID of the track element.
15633 readonly id: string;
15635 * Returns the text track in-band metadata track dispatch type string.
15637 readonly inBandMetadataTrackDispatchType: string;
15639 * Returns the text track kind string.
15641 readonly kind: TextTrackKind;
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).
15645 readonly label: string;
15647 * Returns the text track language string.
15649 readonly language: string;
15651 * Returns the text track mode, represented by a string from the following list:
15653 * Can be set, to change the mode.
15655 mode: TextTrackMode;
15656 oncuechange: ((this: TextTrack, ev: Event) => any) | null;
15657 readonly sourceBuffer: SourceBuffer | null;
15659 * Adds the given cue to textTrack's text track list of cues.
15661 addCue(cue: TextTrackCue): void;
15663 * Removes the given cue from textTrack's text track list of cues.
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;
15672 declare var TextTrack: {
15673 prototype: TextTrack;
15677 interface TextTrackCueEventMap {
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 {
15685 * Returns the text track cue end time, in seconds.
15691 * Returns the text track cue identifier.
15696 onenter: ((this: TextTrackCue, ev: Event) => any) | null;
15697 onexit: ((this: TextTrackCue, ev: Event) => any) | null;
15699 * Returns true if the text track cue pause-on-exit flag is set, false otherwise.
15703 pauseOnExit: boolean;
15705 * Returns the text track cue start time, in seconds.
15711 * Returns the TextTrack object to which this text track cue belongs, if any, or null otherwise.
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;
15720 declare var TextTrackCue: {
15721 prototype: TextTrackCue;
15722 new(): TextTrackCue;
15725 interface TextTrackCueList {
15727 * Returns the number of cues in the list.
15729 readonly length: number;
15731 * Returns the first text track cue (in text track cue order) with text track cue identifier id.
15733 * Returns null if none of the cues have the given identifier or if the argument is the empty string.
15735 getCueById(id: string): TextTrackCue | null;
15736 [index: number]: TextTrackCue;
15739 declare var TextTrackCueList: {
15740 prototype: TextTrackCueList;
15741 new(): TextTrackCueList;
15744 interface TextTrackListEventMap {
15745 "addtrack": TrackEvent;
15747 "removetrack": TrackEvent;
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;
15763 declare var TextTrackList: {
15764 prototype: TextTrackList;
15765 new(): TextTrackList;
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 {
15771 * Returns the number of ranges in the object.
15773 readonly length: number;
15775 * Returns the time for the end of the range with the given index.
15777 * Throws an "IndexSizeError" DOMException if the index is out of range.
15779 end(index: number): number;
15781 * Returns the time for the start of the range with the given index.
15783 * Throws an "IndexSizeError" DOMException if the index is out of range.
15785 start(index: number): number;
15788 declare var TimeRanges: {
15789 prototype: TimeRanges;
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. */
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;
15812 declare var Touch: {
15814 new(touchInitDict: TouchInit): Touch;
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;
15828 declare var TouchEvent: {
15829 prototype: TouchEvent;
15830 new(type: string, eventInitDict?: TouchEventInit): TouchEvent;
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;
15840 declare var TouchList: {
15841 prototype: TouchList;
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 {
15848 * Returns the track object (TextTrack, AudioTrack, or VideoTrack) to which the event relates.
15850 readonly track: TextTrack | null;
15853 declare var TrackEvent: {
15854 prototype: TrackEvent;
15855 new(type: string, eventInitDict?: TrackEventInit): TrackEvent;
15858 interface TransformStream<I = any, O = any> {
15859 readonly readable: ReadableStream<O>;
15860 readonly writable: WritableStream<I>;
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>;
15868 interface TransformStreamDefaultController<O = any> {
15869 readonly desiredSize: number | null;
15870 enqueue(chunk: O): void;
15871 error(reason?: any): void;
15875 /** Events providing information related to transitions. */
15876 interface TransitionEvent extends Event {
15877 readonly elapsedTime: number;
15878 readonly propertyName: string;
15879 readonly pseudoElement: string;
15882 declare var TransitionEvent: {
15883 prototype: TransitionEvent;
15884 new(type: string, transitionEventInitDict?: TransitionEventInit): TransitionEvent;
15887 /** The nodes of a document subtree and a position within them. */
15888 interface TreeWalker {
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;
15902 declare var TreeWalker: {
15903 prototype: TreeWalker;
15907 /** Simple user interface events. */
15908 interface UIEvent extends Event {
15909 readonly detail: number;
15910 readonly view: Window | null;
15912 readonly which: number;
15915 declare var UIEvent: {
15916 prototype: UIEvent;
15917 new(type: string, eventInitDict?: UIEventInit): UIEvent;
15920 /** The URLÂ interface represents an object providing static methods used for creating object URLs. */
15926 toString(): string;
15927 readonly origin: string;
15933 readonly searchParams: URLSearchParams;
15940 new(url: string, base?: string | URL): URL;
15941 createObjectURL(object: any): string;
15942 revokeObjectURL(url: string): void;
15945 type webkitURL = URL;
15946 declare var webkitURL: typeof URL;
15948 interface URLSearchParams {
15950 * Appends a specified key/value pair as a new search parameter.
15952 append(name: string, value: string): void;
15954 * Deletes the given search parameter, and its associated value, from the list of all search parameters.
15956 delete(name: string): void;
15958 * Returns the first value associated to the given search parameter.
15960 get(name: string): string | null;
15962 * Returns all the values association with a given search parameter.
15964 getAll(name: string): string[];
15966 * Returns a Boolean indicating if such a search parameter exists.
15968 has(name: string): boolean;
15970 * Sets the value associated to a given search parameter to the given value. If there were several values, delete the others.
15972 set(name: string, value: string): void;
15975 * Returns a string containing a query string suitable for use in a URL. Does not include the question mark.
15977 toString(): string;
15978 forEach(callbackfn: (value: string, key: string, parent: URLSearchParams) => void, thisArg?: any): void;
15981 declare var URLSearchParams: {
15982 prototype: URLSearchParams;
15983 new(init?: string[][] | Record<string, string> | string | URLSearchParams): URLSearchParams;
15984 toString(): string;
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;
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[];
16004 requestAnimationFrame(callback: FrameRequestCallback): number;
16005 requestPresent(layers: VRLayer[]): Promise<void>;
16007 submitFrame(pose?: VRPose): void;
16010 declare var VRDisplay: {
16011 prototype: VRDisplay;
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;
16024 declare var VRDisplayCapabilities: {
16025 prototype: VRDisplayCapabilities;
16026 new(): VRDisplayCapabilities;
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;
16035 declare var VRDisplayEvent: {
16036 prototype: VRDisplayEvent;
16037 new(type: string, eventInitDict: VRDisplayEventInit): VRDisplayEvent;
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 {
16043 readonly fieldOfView: VRFieldOfView;
16044 readonly offset: Float32Array;
16045 readonly renderHeight: number;
16046 readonly renderWidth: number;
16049 declare var VREyeParameters: {
16050 prototype: VREyeParameters;
16051 new(): VREyeParameters;
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;
16062 declare var VRFieldOfView: {
16063 prototype: VRFieldOfView;
16064 new(): VRFieldOfView;
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;
16077 declare var VRFrameData: {
16078 prototype: VRFrameData;
16079 new(): VRFrameData;
16082 /** This WebVR API interface represents the state of a VR sensor at a given timestamp (which includes orientation, position, velocity, and acceleration information.) */
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;
16093 declare var VRPose: {
16098 interface VTTCue extends TextTrackCue {
16099 align: AlignSetting;
16100 line: LineAndPositionSetting;
16101 lineAlign: LineAlignSetting;
16102 position: LineAndPositionSetting;
16103 positionAlign: PositionAlignSetting;
16104 region: VTTRegion | null;
16106 snapToLines: boolean;
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;
16116 declare var VTTCue: {
16118 new(startTime: number, endTime: number, text: string): VTTCue;
16121 interface VTTRegion {
16124 regionAnchorX: number;
16125 regionAnchorY: number;
16126 scroll: ScrollSetting;
16127 viewportAnchorX: number;
16128 viewportAnchorY: number;
16132 declare var VTTRegion: {
16133 prototype: VTTRegion;
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;
16152 declare var ValidityState: {
16153 prototype: ValidityState;
16154 new(): ValidityState;
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;
16164 declare var VideoPlaybackQuality: {
16165 prototype: VideoPlaybackQuality;
16166 new(): VideoPlaybackQuality;
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;
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;
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;
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;
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;
16228 interface WEBGL_debug_shaders {
16229 getTranslatedShaderSource(shader: WebGLShader): string;
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;
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;
16275 interface WEBGL_lose_context {
16276 loseContext(): void;
16277 restoreContext(): void;
16280 /** A WaveShaperNode always has exactly one input and one output. */
16281 interface WaveShaperNode extends AudioNode {
16282 curve: Float32Array | null;
16283 oversample: OverSampleType;
16286 declare var WaveShaperNode: {
16287 prototype: WaveShaperNode;
16288 new(context: BaseAudioContext, options?: WaveShaperOptions): WaveShaperNode;
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>;
16296 declare var WebAuthentication: {
16297 prototype: WebAuthentication;
16298 new(): WebAuthentication;
16301 interface WebAuthnAssertion {
16302 readonly authenticatorData: ArrayBuffer;
16303 readonly clientData: ArrayBuffer;
16304 readonly credential: ScopedCredential;
16305 readonly signature: ArrayBuffer;
16308 declare var WebAuthnAssertion: {
16309 prototype: WebAuthnAssertion;
16310 new(): WebAuthnAssertion;
16313 interface WebGL2RenderingContext extends WebGL2RenderingContextBase, WebGL2RenderingContextOverloads, WebGLRenderingContextBase {
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;
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;
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;
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;
17284 declare var WebGLActiveInfo: {
17285 prototype: WebGLActiveInfo;
17286 new(): WebGLActiveInfo;
17289 /** Part of the WebGL API and represents an opaque buffer object storing data such as vertices or colors. */
17290 interface WebGLBuffer extends WebGLObject {
17293 declare var WebGLBuffer: {
17294 prototype: WebGLBuffer;
17295 new(): WebGLBuffer;
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;
17303 declare var WebGLContextEvent: {
17304 prototype: WebGLContextEvent;
17305 new(type: string, eventInit?: WebGLContextEventInit): WebGLContextEvent;
17308 /** Part of the WebGL API and represents a collection of buffers that serve as a rendering destination. */
17309 interface WebGLFramebuffer extends WebGLObject {
17312 declare var WebGLFramebuffer: {
17313 prototype: WebGLFramebuffer;
17314 new(): WebGLFramebuffer;
17317 interface WebGLObject {
17320 declare var WebGLObject: {
17321 prototype: WebGLObject;
17322 new(): WebGLObject;
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 {
17329 declare var WebGLProgram: {
17330 prototype: WebGLProgram;
17331 new(): WebGLProgram;
17334 interface WebGLQuery extends WebGLObject {
17337 declare var WebGLQuery: {
17338 prototype: WebGLQuery;
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 {
17346 declare var WebGLRenderbuffer: {
17347 prototype: WebGLRenderbuffer;
17348 new(): WebGLRenderbuffer;
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 {
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;
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;
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;
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;
18122 interface WebGLSampler extends WebGLObject {
18125 declare var WebGLSampler: {
18126 prototype: WebGLSampler;
18127 new(): WebGLSampler;
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 {
18134 declare var WebGLShader: {
18135 prototype: WebGLShader;
18136 new(): WebGLShader;
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;
18146 declare var WebGLShaderPrecisionFormat: {
18147 prototype: WebGLShaderPrecisionFormat;
18148 new(): WebGLShaderPrecisionFormat;
18151 interface WebGLSync extends WebGLObject {
18154 declare var WebGLSync: {
18155 prototype: WebGLSync;
18159 /** Part of the WebGL API and represents an opaque texture object providing storage and state for texturing operations. */
18160 interface WebGLTexture extends WebGLObject {
18163 declare var WebGLTexture: {
18164 prototype: WebGLTexture;
18165 new(): WebGLTexture;
18168 interface WebGLTransformFeedback extends WebGLObject {
18171 declare var WebGLTransformFeedback: {
18172 prototype: WebGLTransformFeedback;
18173 new(): WebGLTransformFeedback;
18176 /** Part of the WebGL API and represents the location of a uniform variable in a shader program. */
18177 interface WebGLUniformLocation {
18180 declare var WebGLUniformLocation: {
18181 prototype: WebGLUniformLocation;
18182 new(): WebGLUniformLocation;
18185 interface WebGLVertexArrayObject extends WebGLObject {
18188 declare var WebGLVertexArrayObject: {
18189 prototype: WebGLVertexArrayObject;
18190 new(): WebGLVertexArrayObject;
18193 interface WebGLVertexArrayObjectOES extends WebGLObject {
18196 interface WebKitPoint {
18201 declare var WebKitPoint: {
18202 prototype: WebKitPoint;
18203 new(x?: number, y?: number): WebKitPoint;
18206 interface WebSocketEventMap {
18207 "close": CloseEvent;
18209 "message": MessageEvent;
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 {
18216 * Returns a string that indicates how binary data from the WebSocket object is exposed to scripts:
18218 * Can be set, to change how binary data is returned. The default is "blob".
18220 binaryType: BinaryType;
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.
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.)
18226 readonly bufferedAmount: number;
18228 * Returns the extensions selected by the server, if any.
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;
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.
18238 readonly protocol: string;
18240 * Returns the state of the WebSocket object's connection. It can have the values described below.
18242 readonly readyState: number;
18244 * Returns the URL that was used to establish the WebSocket connection.
18246 readonly url: string;
18248 * Closes the WebSocket connection, optionally using code as the the WebSocket connection close code and reason as the the WebSocket connection close reason.
18250 close(code?: number, reason?: string): void;
18252 * Transmits data using the WebSocket connection. data can be a string, a Blob, an ArrayBuffer, or an ArrayBufferView.
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;
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;
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;
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;
18293 interface WindowEventMap extends GlobalEventHandlersEventMap, WindowEventHandlersEventMap {
18295 "afterprint": Event;
18296 "beforeprint": Event;
18297 "beforeunload": BeforeUnloadEvent;
18298 "blur": FocusEvent;
18300 "canplaythrough": 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;
18311 "dragend": DragEvent;
18312 "dragenter": DragEvent;
18313 "dragleave": DragEvent;
18314 "dragover": DragEvent;
18315 "dragstart": DragEvent;
18317 "durationchange": Event;
18320 "error": ErrorEvent;
18321 "focus": FocusEvent;
18322 "hashchange": HashChangeEvent;
18325 "keydown": KeyboardEvent;
18326 "keypress": KeyboardEvent;
18327 "keyup": KeyboardEvent;
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;
18358 "orientationchange": Event;
18359 "pagehide": PageTransitionEvent;
18360 "pageshow": PageTransitionEvent;
18364 "popstate": PopStateEvent;
18365 "progress": ProgressEvent<Window>;
18366 "ratechange": Event;
18367 "readystatechange": ProgressEvent<Window>;
18375 "storage": StorageEvent;
18378 "timeupdate": 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;
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;
18404 readonly event: Event | undefined;
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;
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;
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;
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;
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;
18481 captureEvents(): void;
18483 confirm(message?: string): boolean;
18484 departFocus(navigationReason: NavigationReason, origin: FocusNavigationOrigin): 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;
18496 prompt(message?: string, _default?: string): string | null;
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;
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;
18519 declare var Window: {
18524 interface WindowEventHandlersEventMap {
18525 "afterprint": Event;
18526 "beforeprint": Event;
18527 "beforeunload": BeforeUnloadEvent;
18528 "hashchange": HashChangeEvent;
18529 "languagechange": Event;
18530 "message": MessageEvent;
18531 "messageerror": MessageEvent;
18534 "pagehide": PageTransitionEvent;
18535 "pageshow": PageTransitionEvent;
18536 "popstate": PopStateEvent;
18537 "rejectionhandled": PromiseRejectionEvent;
18538 "storage": StorageEvent;
18539 "unhandledrejection": PromiseRejectionEvent;
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;
18566 interface WindowLocalStorage {
18567 readonly localStorage: Storage;
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;
18589 interface WindowSessionStorage {
18590 readonly sessionStorage: Storage;
18593 interface WorkerEventMap extends AbstractWorkerEventMap {
18594 "message": MessageEvent;
18595 "messageerror": MessageEvent;
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;
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.
18605 postMessage(message: any, transfer: Transferable[]): void;
18606 postMessage(message: any, options?: PostMessageOptions): void;
18608 * Aborts worker's associated global environment.
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;
18617 declare var Worker: {
18619 new(stringUrl: string | URL, options?: WorkerOptions): Worker;
18622 interface Worklet {
18623 addModule(moduleURL: string, options?: WorkletOptions): Promise<void>;
18626 declare var Worklet: {
18627 prototype: Worklet;
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>;
18638 declare var WritableStream: {
18639 prototype: WritableStream;
18640 new<W = any>(underlyingSink?: UnderlyingSink<W>, strategy?: QueuingStrategy<W>): WritableStream<W>;
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;
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>;
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;
18667 declare var XMLDocument: {
18668 prototype: XMLDocument;
18669 new(): XMLDocument;
18672 interface XMLHttpRequestEventMap extends XMLHttpRequestEventTargetEventMap {
18673 "readystatechange": Event;
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;
18680 * Returns client's state.
18682 readonly readyState: number;
18684 * Returns the response's body.
18686 readonly response: any;
18688 * Returns the text response.
18690 * Throws an "InvalidStateError" DOMException if responseType is not the empty string or "text".
18692 readonly responseText: string;
18694 * Returns the response type.
18696 * Can be set to change the response type. Values are: the empty string (default), "arraybuffer", "blob", "document", "json", and "text".
18698 * When set: setting to "document" is ignored if current global object is not a Window object.
18700 * When set: throws an "InvalidStateError" DOMException if state is loading or done.
18702 * When set: throws an "InvalidAccessError" DOMException if the synchronous flag is set and current global object is a Window object.
18704 responseType: XMLHttpRequestResponseType;
18705 readonly responseURL: string;
18707 * Returns the document response.
18709 * Throws an "InvalidStateError" DOMException if responseType is not the empty string or "document".
18711 readonly responseXML: Document | null;
18712 readonly status: number;
18713 readonly statusText: string;
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).
18717 * When set: throws an "InvalidAccessError" DOMException if the synchronous flag is set and current global object is a Window object.
18721 * Returns the associated XMLHttpRequestUpload object. It can be used to gather transmission information when data is transferred to a server.
18723 readonly upload: XMLHttpRequestUpload;
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.
18727 * When set: throws an "InvalidStateError" DOMException if state is not unsent or opened, or if the send() flag is set.
18729 withCredentials: boolean;
18731 * Cancels any network activity.
18734 getAllResponseHeaders(): string;
18735 getResponseHeader(name: string): string | null;
18737 * Sets the request method, request URL, and synchronous flag.
18739 * Throws a "SyntaxError" DOMException if either method is not a valid HTTP method or url cannot be parsed.
18741 * Throws a "SecurityError" DOMException if method is a case-insensitive match for `CONNECT`, `TRACE`, or `TRACK`.
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.
18745 open(method: string, url: string): void;
18746 open(method: string, url: string, async: boolean, username?: string | null, password?: string | null): void;
18748 * Acts as if the `Content-Type` header value for response is mime. (It does not actually change the header though.)
18750 * Throws an "InvalidStateError" DOMException if state is loading or done.
18752 overrideMimeType(mime: string): void;
18754 * Initiates the request. The body argument provides the request body, if any, and is ignored if the request method is GET or HEAD.
18756 * Throws an "InvalidStateError" DOMException if either state is not opened or the send() flag is set.
18758 send(body?: Document | BodyInit | null): void;
18760 * Combines a header in author request headers.
18762 * Throws an "InvalidStateError" DOMException if either state is not opened or the send() flag is set.
18764 * Throws a "SyntaxError" DOMException if name is not a header name or if value is not a header value.
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;
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;
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>;
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;
18812 declare var XMLHttpRequestEventTarget: {
18813 prototype: XMLHttpRequestEventTarget;
18814 new(): XMLHttpRequestEventTarget;
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;
18824 declare var XMLHttpRequestUpload: {
18825 prototype: XMLHttpRequestUpload;
18826 new(): XMLHttpRequestUpload;
18829 /** Provides the serializeToString() method to construct an XML string representing a DOM tree. */
18830 interface XMLSerializer {
18831 serializeToString(root: Node): string;
18834 declare var XMLSerializer: {
18835 prototype: XMLSerializer;
18836 new(): XMLSerializer;
18839 /** The XPathEvaluator interface allows to compile and evaluate XPath expressions. */
18840 interface XPathEvaluator extends XPathEvaluatorBase {
18843 declare var XPathEvaluator: {
18844 prototype: XPathEvaluator;
18845 new(): XPathEvaluator;
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;
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;
18859 declare var XPathExpression: {
18860 prototype: XPathExpression;
18861 new(): XPathExpression;
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;
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;
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;
18909 setParameter(namespaceURI: string, localName: string, value: any): void;
18910 transformToDocument(source: Node): Document;
18911 transformToFragment(source: Node, document: Document): DocumentFragment;
18914 declare var XSLTProcessor: {
18915 prototype: XSLTProcessor;
18916 new(): XSLTProcessor;
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;
18926 declare var webkitRTCPeerConnection: {
18927 prototype: webkitRTCPeerConnection;
18928 new(configuration: RTCConfiguration): webkitRTCPeerConnection;
18931 declare type EventListenerOrEventListenerObject = EventListener | EventListenerObject;
18933 interface Console {
18935 assert(condition?: boolean, ...data: any[]): 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;
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;
18958 declare var console: Console;
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;
18967 declare namespace WebAssembly {
18968 interface CompileError {
18971 var CompileError: {
18972 prototype: CompileError;
18973 new(): CompileError;
18983 new(descriptor: GlobalDescriptor, v?: any): Global;
18986 interface Instance {
18987 readonly exports: Exports;
18991 prototype: Instance;
18992 new(module: Module, importObject?: Imports): Instance;
18995 interface LinkError {
18999 prototype: LinkError;
19004 readonly buffer: ArrayBuffer;
19005 grow(delta: number): number;
19010 new(descriptor: MemoryDescriptor): Memory;
19018 new(bytes: BufferSource): Module;
19019 customSections(moduleObject: Module, sectionName: string): ArrayBuffer[];
19020 exports(moduleObject: Module): ModuleExportDescriptor[];
19021 imports(moduleObject: Module): ModuleImportDescriptor[];
19024 interface RuntimeError {
19027 var RuntimeError: {
19028 prototype: RuntimeError;
19029 new(): RuntimeError;
19033 readonly length: number;
19034 get(index: number): Function | null;
19035 grow(delta: number): number;
19036 set(index: number, value: Function | null): void;
19041 new(descriptor: TableDescriptor): Table;
19044 interface GlobalDescriptor {
19049 interface MemoryDescriptor {
19054 interface ModuleExportDescriptor {
19055 kind: ImportExportKind;
19059 interface ModuleImportDescriptor {
19060 kind: ImportExportKind;
19065 interface TableDescriptor {
19066 element: TableKind;
19071 interface WebAssemblyInstantiatedSource {
19072 instance: Instance;
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;
19092 interface BlobCallback {
19093 (blob: Blob | null): void;
19096 interface CustomElementConstructor {
19097 new (...params: any[]): HTMLElement;
19100 interface DecodeErrorCallback {
19101 (error: DOMException): void;
19104 interface DecodeSuccessCallback {
19105 (decodedData: AudioBuffer): void;
19108 interface EventHandlerNonNull {
19109 (event: Event): any;
19112 interface ForEachCallback {
19113 (keyId: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer | null, status: MediaKeyStatus): void;
19116 interface FrameRequestCallback {
19117 (time: number): void;
19120 interface FunctionStringCallback {
19121 (data: string): void;
19124 interface IntersectionObserverCallback {
19125 (entries: IntersectionObserverEntry[], observer: IntersectionObserver): void;
19128 interface MSLaunchUriCallback {
19132 interface MutationCallback {
19133 (mutations: MutationRecord[], observer: MutationObserver): void;
19136 interface NavigatorUserMediaErrorCallback {
19137 (error: MediaStreamError): void;
19140 interface NavigatorUserMediaSuccessCallback {
19141 (stream: MediaStream): void;
19144 interface NotificationPermissionCallback {
19145 (permission: NotificationPermission): void;
19148 interface OnBeforeUnloadEventHandlerNonNull {
19149 (event: Event): string | null;
19152 interface OnErrorEventHandlerNonNull {
19153 (event: Event | string, source?: string, lineno?: number, colno?: number, error?: Error): any;
19156 interface PerformanceObserverCallback {
19157 (entries: PerformanceObserverEntryList, observer: PerformanceObserver): void;
19160 interface PositionCallback {
19161 (position: Position): void;
19164 interface PositionErrorCallback {
19165 (positionError: PositionError): void;
19168 interface QueuingStrategySizeCallback<T = any> {
19169 (chunk: T): number;
19172 interface RTCPeerConnectionErrorCallback {
19173 (error: DOMException): void;
19176 interface RTCSessionDescriptionCallback {
19177 (description: RTCSessionDescriptionInit): void;
19180 interface RTCStatsCallback {
19181 (report: RTCStatsReport): void;
19184 interface ReadableByteStreamControllerCallback {
19185 (controller: ReadableByteStreamController): void | PromiseLike<void>;
19188 interface ReadableStreamDefaultControllerCallback<R> {
19189 (controller: ReadableStreamDefaultController<R>): void | PromiseLike<void>;
19192 interface ReadableStreamErrorCallback {
19193 (reason: any): void | PromiseLike<void>;
19196 interface TransformStreamDefaultControllerCallback<O> {
19197 (controller: TransformStreamDefaultController<O>): void | PromiseLike<void>;
19200 interface TransformStreamDefaultControllerTransformCallback<I, O> {
19201 (chunk: I, controller: TransformStreamDefaultController<O>): void | PromiseLike<void>;
19204 interface VoidFunction {
19208 interface WritableStreamDefaultControllerCloseCallback {
19209 (): void | PromiseLike<void>;
19212 interface WritableStreamDefaultControllerStartCallback {
19213 (controller: WritableStreamDefaultController): void | PromiseLike<void>;
19216 interface WritableStreamDefaultControllerWriteCallback<W> {
19217 (chunk: W, controller: WritableStreamDefaultController): void | PromiseLike<void>;
19220 interface WritableStreamErrorCallback {
19221 (reason: any): void | PromiseLike<void>;
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;
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;
19251 "del": HTMLModElement;
19252 "details": HTMLDetailsElement;
19253 "dfn": HTMLElement;
19254 "dialog": HTMLDialogElement;
19255 "dir": HTMLDirectoryElement;
19256 "div": HTMLDivElement;
19257 "dl": HTMLDListElement;
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;
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;
19312 "ruby": 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;
19340 "ul": HTMLUListElement;
19341 "var": HTMLElement;
19342 "video": HTMLVideoElement;
19343 "wbr": HTMLElement;
19346 interface HTMLElementDeprecatedTagNameMap {
19347 "listing": HTMLPreElement;
19348 "xmp": HTMLPreElement;
19351 interface SVGElementTagNameMap {
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;
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;
19411 /** @deprecated Directly use HTMLElementTagNameMap or SVGElementTagNameMap as appropriate, instead. */
19412 type ElementTagNameMap = HTMLElementTagNameMap & Pick<SVGElementTagNameMap, Exclude<keyof SVGElementTagNameMap, keyof HTMLElementTagNameMap>>;
19414 declare var Audio: {
19415 new(src?: string): HTMLAudioElement;
19417 declare var Image: {
19418 new(width?: number, height?: number): HTMLImageElement;
19420 declare var Option: {
19421 new(text?: string, value?: string, defaultSelected?: boolean, selected?: boolean): HTMLOptionElement;
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;
19432 declare var event: Event | undefined;
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;
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;
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;
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;
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;
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.
19544 declare function dispatchEvent(event: Event): boolean;
19545 declare var sessionStorage: Storage;
19546 declare var localStorage: Storage;
19548 * Fires when the user aborts the download.
19549 * @param ev The event.
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;
19558 * Fires when the object loses the input focus.
19559 * @param ev The focus event.
19561 declare var onblur: ((this: Window, ev: FocusEvent) => any) | null;
19562 declare var oncancel: ((this: Window, ev: Event) => any) | null;
19564 * Occurs when playback is possible, but would require further buffering.
19565 * @param ev The event.
19567 declare var oncanplay: ((this: Window, ev: Event) => any) | null;
19568 declare var oncanplaythrough: ((this: Window, ev: Event) => any) | null;
19570 * Fires when the contents of the object or selection have changed.
19571 * @param ev The event.
19573 declare var onchange: ((this: Window, ev: Event) => any) | null;
19575 * Fires when the user clicks the left mouse button on the object
19576 * @param ev The mouse event.
19578 declare var onclick: ((this: Window, ev: MouseEvent) => any) | null;
19579 declare var onclose: ((this: Window, ev: Event) => any) | null;
19581 * Fires when the user clicks the right mouse button in the client area, opening the context menu.
19582 * @param ev The mouse event.
19584 declare var oncontextmenu: ((this: Window, ev: MouseEvent) => any) | null;
19585 declare var oncuechange: ((this: Window, ev: Event) => any) | null;
19587 * Fires when the user double-clicks the object.
19588 * @param ev The mouse event.
19590 declare var ondblclick: ((this: Window, ev: MouseEvent) => any) | null;
19592 * Fires on the source object continuously during a drag operation.
19593 * @param ev The event.
19595 declare var ondrag: ((this: Window, ev: DragEvent) => any) | null;
19597 * Fires on the source object when the user releases the mouse at the close of a drag operation.
19598 * @param ev The event.
19600 declare var ondragend: ((this: Window, ev: DragEvent) => any) | null;
19602 * Fires on the target element when the user drags the object to a valid drop target.
19603 * @param ev The drag event.
19605 declare var ondragenter: ((this: Window, ev: DragEvent) => any) | null;
19606 declare var ondragexit: ((this: Window, ev: Event) => any) | null;
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.
19611 declare var ondragleave: ((this: Window, ev: DragEvent) => any) | null;
19613 * Fires on the target element continuously while the user drags the object over a valid drop target.
19614 * @param ev The event.
19616 declare var ondragover: ((this: Window, ev: DragEvent) => any) | null;
19618 * Fires on the source object when the user starts to drag a text selection or selected object.
19619 * @param ev The event.
19621 declare var ondragstart: ((this: Window, ev: DragEvent) => any) | null;
19622 declare var ondrop: ((this: Window, ev: DragEvent) => any) | null;
19624 * Occurs when the duration attribute is updated.
19625 * @param ev The event.
19627 declare var ondurationchange: ((this: Window, ev: Event) => any) | null;
19629 * Occurs when the media element is reset to its initial state.
19630 * @param ev The event.
19632 declare var onemptied: ((this: Window, ev: Event) => any) | null;
19634 * Occurs when the end of playback is reached.
19635 * @param ev The event
19637 declare var onended: ((this: Window, ev: Event) => any) | null;
19639 * Fires when an error occurs during object loading.
19640 * @param ev The event.
19642 declare var onerror: OnErrorEventHandler;
19644 * Fires when the object receives focus.
19645 * @param ev The event.
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;
19652 * Fires when the user presses a key.
19653 * @param ev The keyboard event
19655 declare var onkeydown: ((this: Window, ev: KeyboardEvent) => any) | null;
19657 * Fires when the user presses an alphanumeric key.
19658 * @param ev The event.
19660 declare var onkeypress: ((this: Window, ev: KeyboardEvent) => any) | null;
19662 * Fires when the user releases a key.
19663 * @param ev The keyboard event
19665 declare var onkeyup: ((this: Window, ev: KeyboardEvent) => any) | null;
19667 * Fires immediately after the browser loads the object.
19668 * @param ev The event.
19670 declare var onload: ((this: Window, ev: Event) => any) | null;
19672 * Occurs when media data is loaded at the current playback position.
19673 * @param ev The event.
19675 declare var onloadeddata: ((this: Window, ev: Event) => any) | null;
19677 * Occurs when the duration and dimensions of the media have been determined.
19678 * @param ev The event.
19680 declare var onloadedmetadata: ((this: Window, ev: Event) => any) | null;
19682 * Occurs when Internet Explorer begins looking for media data.
19683 * @param ev The event.
19685 declare var onloadstart: ((this: Window, ev: Event) => any) | null;
19686 declare var onlostpointercapture: ((this: Window, ev: PointerEvent) => any) | null;
19688 * Fires when the user clicks the object with either mouse button.
19689 * @param ev The mouse event.
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;
19695 * Fires when the user moves the mouse over the object.
19696 * @param ev The mouse event.
19698 declare var onmousemove: ((this: Window, ev: MouseEvent) => any) | null;
19700 * Fires when the user moves the mouse pointer outside the boundaries of the object.
19701 * @param ev The mouse event.
19703 declare var onmouseout: ((this: Window, ev: MouseEvent) => any) | null;
19705 * Fires when the user moves the mouse pointer into the object.
19706 * @param ev The mouse event.
19708 declare var onmouseover: ((this: Window, ev: MouseEvent) => any) | null;
19710 * Fires when the user releases a mouse button while the mouse is over the object.
19711 * @param ev The mouse event.
19713 declare var onmouseup: ((this: Window, ev: MouseEvent) => any) | null;
19715 * Occurs when playback is paused.
19716 * @param ev The event.
19718 declare var onpause: ((this: Window, ev: Event) => any) | null;
19720 * Occurs when the play method is requested.
19721 * @param ev The event.
19723 declare var onplay: ((this: Window, ev: Event) => any) | null;
19725 * Occurs when the audio or video has started playing.
19726 * @param ev The event.
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;
19738 * Occurs to indicate progress while downloading media data.
19739 * @param ev The event.
19741 declare var onprogress: ((this: Window, ev: ProgressEvent) => any) | null;
19743 * Occurs when the playback rate is increased or decreased.
19744 * @param ev The event.
19746 declare var onratechange: ((this: Window, ev: Event) => any) | null;
19748 * Fires when the user resets a form.
19749 * @param ev The event.
19751 declare var onreset: ((this: Window, ev: Event) => any) | null;
19752 declare var onresize: ((this: Window, ev: UIEvent) => any) | null;
19754 * Fires when the user repositions the scroll box in the scroll bar on the object.
19755 * @param ev The event.
19757 declare var onscroll: ((this: Window, ev: Event) => any) | null;
19758 declare var onsecuritypolicyviolation: ((this: Window, ev: SecurityPolicyViolationEvent) => any) | null;
19760 * Occurs when the seek operation ends.
19761 * @param ev The event.
19763 declare var onseeked: ((this: Window, ev: Event) => any) | null;
19765 * Occurs when the current playback position is moved.
19766 * @param ev The event.
19768 declare var onseeking: ((this: Window, ev: Event) => any) | null;
19770 * Fires when the current selection changes.
19771 * @param ev The event.
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;
19777 * Occurs when the download has stopped.
19778 * @param ev The event.
19780 declare var onstalled: ((this: Window, ev: Event) => any) | null;
19781 declare var onsubmit: ((this: Window, ev: Event) => any) | null;
19783 * Occurs if the load operation has been intentionally halted.
19784 * @param ev The event.
19786 declare var onsuspend: ((this: Window, ev: Event) => any) | null;
19788 * Occurs to indicate the current playback position.
19789 * @param ev The event.
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;
19802 * Occurs when the volume is changed, or playback is muted or unmuted.
19803 * @param ev The event.
19805 declare var onvolumechange: ((this: Window, ev: Event) => any) | null;
19807 * Occurs when playback stops because the next frame of a video resource is not available.
19808 * @param ev The event.
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;
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";