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 appidExclude?: string;
163 interface AuthenticationExtensionsClientOutputs {
165 credProps?: CredentialPropertiesOutput;
169 interface AuthenticatorSelectionCriteria {
170 authenticatorAttachment?: AuthenticatorAttachment;
171 requireResidentKey?: boolean;
172 residentKey?: ResidentKeyRequirement;
173 userVerification?: UserVerificationRequirement;
176 interface BiquadFilterOptions extends AudioNodeOptions {
181 type?: BiquadFilterType;
184 interface BlobPropertyBag {
185 endings?: EndingType;
189 interface ByteLengthChunk {
193 interface CacheQueryOptions {
194 ignoreMethod?: boolean;
195 ignoreSearch?: boolean;
196 ignoreVary?: boolean;
199 interface CanvasRenderingContext2DSettings {
201 desynchronized?: boolean;
204 interface ChannelMergerOptions extends AudioNodeOptions {
205 numberOfInputs?: number;
208 interface ChannelSplitterOptions extends AudioNodeOptions {
209 numberOfOutputs?: number;
212 interface ClientData {
214 extensions?: WebAuthnExtensions;
215 hashAlg: string | Algorithm;
218 tokenBinding?: string;
221 interface ClientQueryOptions {
222 includeUncontrolled?: boolean;
226 interface ClipboardEventInit extends EventInit {
227 clipboardData?: DataTransfer | null;
230 interface CloseEventInit extends EventInit {
236 interface CompositionEventInit extends UIEventInit {
240 interface ComputedEffectTiming extends EffectTiming {
241 activeDuration?: number;
242 currentIteration?: number | null;
244 localTime?: number | null;
245 progress?: number | null;
248 interface ComputedKeyframe {
249 composite: CompositeOperationOrAuto;
250 computedOffset: number;
252 offset: number | null;
253 [property: string]: string | number | null | undefined;
256 interface ConfirmSiteSpecificExceptionsInformation extends ExceptionInformation {
257 arrayOfDomainStrings?: string[];
260 interface ConstantSourceOptions {
264 interface ConstrainBooleanParameters {
269 interface ConstrainDOMStringParameters {
270 exact?: string | string[];
271 ideal?: string | string[];
274 interface ConstrainDoubleRange extends DoubleRange {
279 interface ConstrainULongRange extends ULongRange {
284 interface ConstrainVideoFacingModeParameters {
285 exact?: VideoFacingModeEnum | VideoFacingModeEnum[];
286 ideal?: VideoFacingModeEnum | VideoFacingModeEnum[];
289 interface ConvolverOptions extends AudioNodeOptions {
290 buffer?: AudioBuffer | null;
291 disableNormalization?: boolean;
294 interface CredentialCreationOptions {
295 publicKey?: PublicKeyCredentialCreationOptions;
296 signal?: AbortSignal;
299 interface CredentialPropertiesOutput {
303 interface CredentialRequestOptions {
304 mediation?: CredentialMediationRequirement;
305 publicKey?: PublicKeyCredentialRequestOptions;
306 signal?: AbortSignal;
309 interface CustomEventInit<T = any> extends EventInit {
313 interface DOMMatrix2DInit {
328 interface DOMMatrixInit extends DOMMatrix2DInit {
342 interface DOMPointInit {
349 interface DOMQuadInit {
356 interface DOMRectInit {
363 interface DelayOptions extends AudioNodeOptions {
365 maxDelayTime?: number;
368 interface DeviceLightEventInit extends EventInit {
372 interface DeviceMotionEventAccelerationInit {
378 interface DeviceMotionEventInit extends EventInit {
379 acceleration?: DeviceMotionEventAccelerationInit;
380 accelerationIncludingGravity?: DeviceMotionEventAccelerationInit;
382 rotationRate?: DeviceMotionEventRotationRateInit;
385 interface DeviceMotionEventRotationRateInit {
386 alpha?: number | null;
387 beta?: number | null;
388 gamma?: number | null;
391 interface DeviceOrientationEventInit extends EventInit {
393 alpha?: number | null;
394 beta?: number | null;
395 gamma?: number | null;
398 interface DevicePermissionDescriptor extends PermissionDescriptor {
400 name: "camera" | "microphone" | "speaker";
403 interface DocumentTimelineOptions {
407 interface DoubleRange {
412 interface DragEventInit extends MouseEventInit {
413 dataTransfer?: DataTransfer | null;
416 interface DynamicsCompressorOptions extends AudioNodeOptions {
424 interface EcKeyAlgorithm extends KeyAlgorithm {
425 namedCurve: NamedCurve;
428 interface EcKeyGenParams extends Algorithm {
429 namedCurve: NamedCurve;
432 interface EcKeyImportParams extends Algorithm {
433 namedCurve: NamedCurve;
436 interface EcdhKeyDeriveParams extends Algorithm {
440 interface EcdsaParams extends Algorithm {
441 hash: HashAlgorithmIdentifier;
444 interface EffectTiming {
446 direction?: PlaybackDirection;
447 duration?: number | string;
451 iterationStart?: number;
455 interface ElementCreationOptions {
459 interface ElementDefinitionOptions {
463 interface ErrorEventInit extends EventInit {
471 interface EventInit {
473 cancelable?: boolean;
477 interface EventListenerOptions {
481 interface EventModifierInit extends UIEventInit {
485 modifierAltGraph?: boolean;
486 modifierCapsLock?: boolean;
487 modifierFn?: boolean;
488 modifierFnLock?: boolean;
489 modifierHyper?: boolean;
490 modifierNumLock?: boolean;
491 modifierScrollLock?: boolean;
492 modifierSuper?: boolean;
493 modifierSymbol?: boolean;
494 modifierSymbolLock?: boolean;
498 interface EventSourceInit {
499 withCredentials?: boolean;
502 interface ExceptionInformation {
503 domain?: string | null;
506 interface FilePropertyBag extends BlobPropertyBag {
507 lastModified?: number;
510 interface FocusEventInit extends UIEventInit {
511 relatedTarget?: EventTarget | null;
514 interface FocusNavigationEventInit extends EventInit {
515 navigationReason?: string | null;
516 originHeight?: number;
519 originWidth?: number;
522 interface FocusNavigationOrigin {
523 originHeight?: number;
526 originWidth?: number;
529 interface FocusOptions {
530 preventScroll?: boolean;
533 interface FullscreenOptions {
534 navigationUI?: FullscreenNavigationUI;
537 interface GainOptions extends AudioNodeOptions {
541 interface GamepadEventInit extends EventInit {
545 interface GetNotificationOptions {
549 interface GetRootNodeOptions {
553 interface HashChangeEventInit extends EventInit {
558 interface HkdfParams extends Algorithm {
559 hash: HashAlgorithmIdentifier;
560 info: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;
561 salt: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;
564 interface HmacImportParams extends Algorithm {
565 hash: HashAlgorithmIdentifier;
569 interface HmacKeyAlgorithm extends KeyAlgorithm {
574 interface HmacKeyGenParams extends Algorithm {
575 hash: HashAlgorithmIdentifier;
579 interface IDBIndexParameters {
580 multiEntry?: boolean;
584 interface IDBObjectStoreParameters {
585 autoIncrement?: boolean;
586 keyPath?: string | string[] | null;
589 interface IDBVersionChangeEventInit extends EventInit {
590 newVersion?: number | null;
594 interface IIRFilterOptions extends AudioNodeOptions {
596 feedforward: number[];
599 interface ImageBitmapOptions {
600 colorSpaceConversion?: ColorSpaceConversion;
601 imageOrientation?: ImageOrientation;
602 premultiplyAlpha?: PremultiplyAlpha;
603 resizeHeight?: number;
604 resizeQuality?: ResizeQuality;
605 resizeWidth?: number;
608 interface ImageBitmapRenderingContextSettings {
612 interface ImageEncodeOptions {
617 interface InputEventInit extends UIEventInit {
618 data?: string | null;
620 isComposing?: boolean;
623 interface IntersectionObserverEntryInit {
624 boundingClientRect: DOMRectInit;
625 intersectionRatio: number;
626 intersectionRect: DOMRectInit;
627 isIntersecting: boolean;
628 rootBounds: DOMRectInit | null;
633 interface IntersectionObserverInit {
634 root?: Element | null;
636 threshold?: number | number[];
639 interface JsonWebKey {
651 oth?: RsaOtherPrimesInfo[];
660 interface KeyAlgorithm {
664 interface KeyboardEventInit extends EventModifierInit {
666 isComposing?: boolean;
675 composite?: CompositeOperationOrAuto;
677 offset?: number | null;
678 [property: string]: string | number | null | undefined;
681 interface KeyframeAnimationOptions extends KeyframeEffectOptions {
685 interface KeyframeEffectOptions extends EffectTiming {
686 composite?: CompositeOperation;
687 iterationComposite?: IterationCompositeOperation;
690 interface MediaElementAudioSourceOptions {
691 mediaElement: HTMLMediaElement;
694 interface MediaEncryptedEventInit extends EventInit {
695 initData?: ArrayBuffer | null;
696 initDataType?: string;
699 interface MediaKeyMessageEventInit extends EventInit {
700 message: ArrayBuffer;
701 messageType: MediaKeyMessageType;
704 interface MediaKeySystemConfiguration {
705 audioCapabilities?: MediaKeySystemMediaCapability[];
706 distinctiveIdentifier?: MediaKeysRequirement;
707 initDataTypes?: string[];
709 persistentState?: MediaKeysRequirement;
710 sessionTypes?: string[];
711 videoCapabilities?: MediaKeySystemMediaCapability[];
714 interface MediaKeySystemMediaCapability {
715 contentType?: string;
719 interface MediaQueryListEventInit extends EventInit {
724 interface MediaStreamAudioSourceOptions {
725 mediaStream: MediaStream;
728 interface MediaStreamConstraints {
729 audio?: boolean | MediaTrackConstraints;
730 peerIdentity?: string;
731 video?: boolean | MediaTrackConstraints;
734 interface MediaStreamErrorEventInit extends EventInit {
735 error?: MediaStreamError | null;
738 interface MediaStreamEventInit extends EventInit {
739 stream?: MediaStream;
742 interface MediaStreamTrackAudioSourceOptions {
743 mediaStreamTrack: MediaStreamTrack;
746 interface MediaStreamTrackEventInit extends EventInit {
747 track: MediaStreamTrack;
750 interface MediaTrackCapabilities {
751 aspectRatio?: DoubleRange;
752 autoGainControl?: boolean[];
753 channelCount?: ULongRange;
755 echoCancellation?: boolean[];
756 facingMode?: string[];
757 frameRate?: DoubleRange;
760 latency?: DoubleRange;
761 noiseSuppression?: boolean[];
762 resizeMode?: string[];
763 sampleRate?: ULongRange;
764 sampleSize?: ULongRange;
768 interface MediaTrackConstraintSet {
769 aspectRatio?: ConstrainDouble;
770 autoGainControl?: ConstrainBoolean;
771 channelCount?: ConstrainULong;
772 deviceId?: ConstrainDOMString;
773 echoCancellation?: ConstrainBoolean;
774 facingMode?: ConstrainDOMString;
775 frameRate?: ConstrainDouble;
776 groupId?: ConstrainDOMString;
777 height?: ConstrainULong;
778 latency?: ConstrainDouble;
779 noiseSuppression?: ConstrainBoolean;
780 resizeMode?: ConstrainDOMString;
781 sampleRate?: ConstrainULong;
782 sampleSize?: ConstrainULong;
783 width?: ConstrainULong;
786 interface MediaTrackConstraints extends MediaTrackConstraintSet {
787 advanced?: MediaTrackConstraintSet[];
790 interface MediaTrackSettings {
791 aspectRatio?: number;
792 autoGainControl?: boolean;
793 channelCount?: number;
795 echoCancellation?: boolean;
801 noiseSuppression?: boolean;
808 interface MediaTrackSupportedConstraints {
809 aspectRatio?: boolean;
810 autoGainControl?: boolean;
811 channelCount?: boolean;
813 echoCancellation?: boolean;
814 facingMode?: boolean;
819 noiseSuppression?: boolean;
820 resizeMode?: boolean;
821 sampleRate?: boolean;
822 sampleSize?: boolean;
826 interface MessageEventInit<T = any> extends EventInit {
828 lastEventId?: string;
830 ports?: MessagePort[];
831 source?: MessageEventSource | null;
834 interface MidiPermissionDescriptor extends PermissionDescriptor {
839 interface MouseEventInit extends EventModifierInit {
846 relatedTarget?: EventTarget | null;
851 interface MultiCacheQueryOptions extends CacheQueryOptions {
855 interface MutationObserverInit {
857 * 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.
859 attributeFilter?: string[];
861 * Set to true if attributes is true or omitted and target's attribute value before the mutation needs to be recorded.
863 attributeOldValue?: boolean;
865 * Set to true if mutations to target's attributes are to be observed. Can be omitted if attributeOldValue or attributeFilter is specified.
867 attributes?: boolean;
869 * Set to true if mutations to target's data are to be observed. Can be omitted if characterDataOldValue is specified.
871 characterData?: boolean;
873 * Set to true if characterData is set to true or omitted and target's data before the mutation needs to be recorded.
875 characterDataOldValue?: boolean;
877 * Set to true if mutations to target's children are to be observed.
881 * Set to true if mutations to not just target, but also target's descendants are to be observed.
886 interface NavigationPreloadState {
888 headerValue?: string;
891 interface NotificationAction {
897 interface NotificationOptions {
898 actions?: NotificationAction[];
902 dir?: NotificationDirection;
907 requireInteraction?: boolean;
911 vibrate?: VibratePattern;
914 interface OfflineAudioCompletionEventInit extends EventInit {
915 renderedBuffer: AudioBuffer;
918 interface OfflineAudioContextOptions {
920 numberOfChannels?: number;
924 interface OptionalEffectTiming {
926 direction?: PlaybackDirection;
927 duration?: number | string;
931 iterationStart?: number;
935 interface OscillatorOptions extends AudioNodeOptions {
938 periodicWave?: PeriodicWave;
939 type?: OscillatorType;
942 interface PageTransitionEventInit extends EventInit {
946 interface PannerOptions extends AudioNodeOptions {
947 coneInnerAngle?: number;
948 coneOuterAngle?: number;
949 coneOuterGain?: number;
950 distanceModel?: DistanceModelType;
951 maxDistance?: number;
952 orientationX?: number;
953 orientationY?: number;
954 orientationZ?: number;
955 panningModel?: PanningModelType;
959 refDistance?: number;
960 rolloffFactor?: number;
963 interface PaymentCurrencyAmount {
965 currencySystem?: string;
969 interface PaymentDetailsBase {
970 displayItems?: PaymentItem[];
971 modifiers?: PaymentDetailsModifier[];
972 shippingOptions?: PaymentShippingOption[];
975 interface PaymentDetailsInit extends PaymentDetailsBase {
980 interface PaymentDetailsModifier {
981 additionalDisplayItems?: PaymentItem[];
983 supportedMethods: string | string[];
987 interface PaymentDetailsUpdate extends PaymentDetailsBase {
992 interface PaymentItem {
993 amount: PaymentCurrencyAmount;
998 interface PaymentMethodData {
1000 supportedMethods: string | string[];
1003 interface PaymentOptions {
1004 requestPayerEmail?: boolean;
1005 requestPayerName?: boolean;
1006 requestPayerPhone?: boolean;
1007 requestShipping?: boolean;
1008 shippingType?: string;
1011 interface PaymentRequestUpdateEventInit extends EventInit {
1014 interface PaymentShippingOption {
1015 amount: PaymentCurrencyAmount;
1021 interface Pbkdf2Params extends Algorithm {
1022 hash: HashAlgorithmIdentifier;
1024 salt: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;
1027 interface PerformanceObserverInit {
1029 entryTypes?: string[];
1033 interface PeriodicWaveConstraints {
1034 disableNormalization?: boolean;
1037 interface PeriodicWaveOptions extends PeriodicWaveConstraints {
1038 imag?: number[] | Float32Array;
1039 real?: number[] | Float32Array;
1042 interface PermissionDescriptor {
1043 name: PermissionName;
1046 interface PipeOptions {
1047 preventAbort?: boolean;
1048 preventCancel?: boolean;
1049 preventClose?: boolean;
1050 signal?: AbortSignal;
1053 interface PointerEventInit extends MouseEventInit {
1055 isPrimary?: boolean;
1057 pointerType?: string;
1059 tangentialPressure?: number;
1066 interface PopStateEventInit extends EventInit {
1070 interface PositionOptions {
1071 enableHighAccuracy?: boolean;
1072 maximumAge?: number;
1076 interface PostMessageOptions {
1080 interface ProgressEventInit extends EventInit {
1081 lengthComputable?: boolean;
1086 interface PromiseRejectionEventInit extends EventInit {
1087 promise: Promise<any>;
1091 interface PropertyIndexedKeyframes {
1092 composite?: CompositeOperationOrAuto | CompositeOperationOrAuto[];
1093 easing?: string | string[];
1094 offset?: number | (number | null)[];
1095 [property: string]: string | string[] | number | null | (number | null)[] | undefined;
1098 interface PublicKeyCredentialCreationOptions {
1099 attestation?: AttestationConveyancePreference;
1100 authenticatorSelection?: AuthenticatorSelectionCriteria;
1101 challenge: BufferSource;
1102 excludeCredentials?: PublicKeyCredentialDescriptor[];
1103 extensions?: AuthenticationExtensionsClientInputs;
1104 pubKeyCredParams: PublicKeyCredentialParameters[];
1105 rp: PublicKeyCredentialRpEntity;
1107 user: PublicKeyCredentialUserEntity;
1110 interface PublicKeyCredentialDescriptor {
1112 transports?: AuthenticatorTransport[];
1113 type: PublicKeyCredentialType;
1116 interface PublicKeyCredentialEntity {
1120 interface PublicKeyCredentialParameters {
1121 alg: COSEAlgorithmIdentifier;
1122 type: PublicKeyCredentialType;
1125 interface PublicKeyCredentialRequestOptions {
1126 allowCredentials?: PublicKeyCredentialDescriptor[];
1127 challenge: BufferSource;
1128 extensions?: AuthenticationExtensionsClientInputs;
1131 userVerification?: UserVerificationRequirement;
1134 interface PublicKeyCredentialRpEntity extends PublicKeyCredentialEntity {
1138 interface PublicKeyCredentialUserEntity extends PublicKeyCredentialEntity {
1139 displayName: string;
1143 interface PushPermissionDescriptor extends PermissionDescriptor {
1145 userVisibleOnly?: boolean;
1148 interface PushSubscriptionJSON {
1150 expirationTime?: number | null;
1151 keys?: Record<string, string>;
1154 interface PushSubscriptionOptionsInit {
1155 applicationServerKey?: BufferSource | string | null;
1156 userVisibleOnly?: boolean;
1159 interface QueuingStrategy<T = any> {
1160 highWaterMark?: number;
1161 size?: QueuingStrategySizeCallback<T>;
1164 interface RTCAnswerOptions extends RTCOfferAnswerOptions {
1167 interface RTCCertificateExpiration {
1171 interface RTCConfiguration {
1172 bundlePolicy?: RTCBundlePolicy;
1173 certificates?: RTCCertificate[];
1174 iceCandidatePoolSize?: number;
1175 iceServers?: RTCIceServer[];
1176 iceTransportPolicy?: RTCIceTransportPolicy;
1177 peerIdentity?: string;
1178 rtcpMuxPolicy?: RTCRtcpMuxPolicy;
1181 interface RTCDTMFToneChangeEventInit extends EventInit {
1185 interface RTCDataChannelEventInit extends EventInit {
1186 channel: RTCDataChannel;
1189 interface RTCDataChannelInit {
1191 maxPacketLifeTime?: number;
1192 maxRetransmits?: number;
1193 negotiated?: boolean;
1195 priority?: RTCPriorityType;
1199 interface RTCDtlsFingerprint {
1204 interface RTCDtlsParameters {
1205 fingerprints?: RTCDtlsFingerprint[];
1209 interface RTCErrorEventInit extends EventInit {
1213 interface RTCErrorInit {
1214 errorDetail: RTCErrorDetailType;
1215 httpRequestStatusCode?: number;
1216 receivedAlert?: number;
1217 sctpCauseCode?: number;
1218 sdpLineNumber?: number;
1222 interface RTCIceCandidateAttributes extends RTCStats {
1223 addressSourceUrl?: string;
1224 candidateType?: RTCStatsIceCandidateType;
1226 portNumber?: number;
1231 interface RTCIceCandidateComplete {
1234 interface RTCIceCandidateDictionary {
1235 foundation?: string;
1237 msMTurnSessionId?: string;
1240 protocol?: RTCIceProtocol;
1241 relatedAddress?: string;
1242 relatedPort?: number;
1243 tcpType?: RTCIceTcpCandidateType;
1244 type?: RTCIceCandidateType;
1247 interface RTCIceCandidateInit {
1249 sdpMLineIndex?: number | null;
1250 sdpMid?: string | null;
1251 usernameFragment?: string | null;
1254 interface RTCIceCandidatePair {
1255 local?: RTCIceCandidate;
1256 remote?: RTCIceCandidate;
1259 interface RTCIceCandidatePairStats extends RTCStats {
1260 availableIncomingBitrate?: number;
1261 availableOutgoingBitrate?: number;
1262 bytesReceived?: number;
1264 localCandidateId?: string;
1265 nominated?: boolean;
1268 remoteCandidateId?: string;
1269 roundTripTime?: number;
1270 state?: RTCStatsIceCandidatePairState;
1271 transportId?: string;
1275 interface RTCIceGatherOptions {
1276 gatherPolicy?: RTCIceGatherPolicy;
1277 iceservers?: RTCIceServer[];
1280 interface RTCIceParameters {
1282 usernameFragment?: string;
1285 interface RTCIceServer {
1286 credential?: string | RTCOAuthCredential;
1287 credentialType?: RTCIceCredentialType;
1288 urls: string | string[];
1292 interface RTCIdentityProviderOptions {
1293 peerIdentity?: string;
1295 usernameHint?: string;
1298 interface RTCInboundRTPStreamStats extends RTCRTPStreamStats {
1299 bytesReceived?: number;
1300 fractionLost?: number;
1302 packetsLost?: number;
1303 packetsReceived?: number;
1306 interface RTCMediaStreamTrackStats extends RTCStats {
1307 audioLevel?: number;
1308 echoReturnLoss?: number;
1309 echoReturnLossEnhancement?: number;
1310 frameHeight?: number;
1311 frameWidth?: number;
1312 framesCorrupted?: number;
1313 framesDecoded?: number;
1314 framesDropped?: number;
1315 framesPerSecond?: number;
1316 framesReceived?: number;
1317 framesSent?: number;
1318 remoteSource?: boolean;
1320 trackIdentifier?: string;
1323 interface RTCOAuthCredential {
1324 accessToken: string;
1328 interface RTCOfferAnswerOptions {
1329 voiceActivityDetection?: boolean;
1332 interface RTCOfferOptions extends RTCOfferAnswerOptions {
1333 iceRestart?: boolean;
1334 offerToReceiveAudio?: boolean;
1335 offerToReceiveVideo?: boolean;
1338 interface RTCOutboundRTPStreamStats extends RTCRTPStreamStats {
1340 packetsSent?: number;
1341 roundTripTime?: number;
1342 targetBitrate?: number;
1345 interface RTCPeerConnectionIceErrorEventInit extends EventInit {
1347 hostCandidate?: string;
1348 statusText?: string;
1352 interface RTCPeerConnectionIceEventInit extends EventInit {
1353 candidate?: RTCIceCandidate | null;
1354 url?: string | null;
1357 interface RTCRTPStreamStats extends RTCStats {
1358 associateStatsId?: string;
1362 mediaTrackId?: string;
1368 transportId?: string;
1371 interface RTCRtcpFeedback {
1376 interface RTCRtcpParameters {
1378 reducedSize?: boolean;
1381 interface RTCRtpCapabilities {
1382 codecs: RTCRtpCodecCapability[];
1383 headerExtensions: RTCRtpHeaderExtensionCapability[];
1386 interface RTCRtpCodecCapability {
1390 sdpFmtpLine?: string;
1393 interface RTCRtpCodecParameters {
1397 payloadType: number;
1398 sdpFmtpLine?: string;
1401 interface RTCRtpCodingParameters {
1405 interface RTCRtpContributingSource {
1406 audioLevel?: number;
1407 rtpTimestamp: number;
1412 interface RTCRtpDecodingParameters extends RTCRtpCodingParameters {
1415 interface RTCRtpEncodingParameters extends RTCRtpCodingParameters {
1417 codecPayloadType?: number;
1419 maxBitrate?: number;
1420 maxFramerate?: number;
1422 scaleResolutionDownBy?: number;
1425 interface RTCRtpFecParameters {
1430 interface RTCRtpHeaderExtension {
1432 preferredEncrypt?: boolean;
1433 preferredId?: number;
1437 interface RTCRtpHeaderExtensionCapability {
1441 interface RTCRtpHeaderExtensionParameters {
1442 encrypted?: boolean;
1447 interface RTCRtpParameters {
1448 codecs: RTCRtpCodecParameters[];
1449 headerExtensions: RTCRtpHeaderExtensionParameters[];
1450 rtcp: RTCRtcpParameters;
1453 interface RTCRtpReceiveParameters extends RTCRtpParameters {
1454 encodings: RTCRtpDecodingParameters[];
1457 interface RTCRtpRtxParameters {
1461 interface RTCRtpSendParameters extends RTCRtpParameters {
1462 degradationPreference?: RTCDegradationPreference;
1463 encodings: RTCRtpEncodingParameters[];
1464 priority?: RTCPriorityType;
1465 transactionId: string;
1468 interface RTCRtpSynchronizationSource extends RTCRtpContributingSource {
1469 voiceActivityFlag?: boolean;
1472 interface RTCRtpTransceiverInit {
1473 direction?: RTCRtpTransceiverDirection;
1474 sendEncodings?: RTCRtpEncodingParameters[];
1475 streams?: MediaStream[];
1478 interface RTCRtpUnhandled {
1480 payloadType?: number;
1484 interface RTCSessionDescriptionInit {
1489 interface RTCSrtpKeyParam {
1497 interface RTCSrtpSdesParameters {
1498 cryptoSuite?: string;
1499 keyParams?: RTCSrtpKeyParam[];
1500 sessionParams?: string[];
1504 interface RTCSsrcRange {
1509 interface RTCStats {
1515 interface RTCStatsEventInit extends EventInit {
1516 report: RTCStatsReport;
1519 interface RTCStatsReport {
1522 interface RTCTrackEventInit extends EventInit {
1523 receiver: RTCRtpReceiver;
1524 streams?: MediaStream[];
1525 track: MediaStreamTrack;
1526 transceiver: RTCRtpTransceiver;
1529 interface RTCTransportStats extends RTCStats {
1530 activeConnection?: boolean;
1531 bytesReceived?: number;
1533 localCertificateId?: string;
1534 remoteCertificateId?: string;
1535 rtcpTransportStatsId?: string;
1536 selectedCandidatePairId?: string;
1539 interface ReadableStreamReadDoneResult<T> {
1544 interface ReadableStreamReadValueResult<T> {
1549 interface RegistrationOptions {
1552 updateViaCache?: ServiceWorkerUpdateViaCache;
1555 interface RequestInit {
1557 * A BodyInit object or null to set request's body.
1559 body?: BodyInit | null;
1561 * A string indicating how the request will interact with the browser's cache to set request's cache.
1563 cache?: RequestCache;
1565 * 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.
1567 credentials?: RequestCredentials;
1569 * A Headers object, an object literal, or an array of two-item arrays to set request's headers.
1571 headers?: HeadersInit;
1573 * A cryptographic hash of the resource to be fetched by request. Sets request's integrity.
1577 * A boolean to set request's keepalive.
1579 keepalive?: boolean;
1581 * A string to set request's method.
1585 * A string to indicate whether the request will use CORS, or will be restricted to same-origin URLs. Sets request's mode.
1589 * 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.
1591 redirect?: RequestRedirect;
1593 * A string whose value is a same-origin URL, "about:client", or the empty string, to set request's referrer.
1597 * A referrer policy to set request's referrerPolicy.
1599 referrerPolicy?: ReferrerPolicy;
1601 * An AbortSignal to set request's signal.
1603 signal?: AbortSignal | null;
1605 * Can only be null. Used to disassociate request from any Window.
1610 interface ResponseInit {
1611 headers?: HeadersInit;
1613 statusText?: string;
1616 interface RsaHashedImportParams extends Algorithm {
1617 hash: HashAlgorithmIdentifier;
1620 interface RsaHashedKeyAlgorithm extends RsaKeyAlgorithm {
1624 interface RsaHashedKeyGenParams extends RsaKeyGenParams {
1625 hash: HashAlgorithmIdentifier;
1628 interface RsaKeyAlgorithm extends KeyAlgorithm {
1629 modulusLength: number;
1630 publicExponent: BigInteger;
1633 interface RsaKeyGenParams extends Algorithm {
1634 modulusLength: number;
1635 publicExponent: BigInteger;
1638 interface RsaOaepParams extends Algorithm {
1639 label?: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;
1642 interface RsaOtherPrimesInfo {
1648 interface RsaPssParams extends Algorithm {
1652 interface SVGBoundingBoxOptions {
1659 interface ScopedCredentialDescriptor {
1660 id: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer | null;
1661 transports?: Transport[];
1662 type: ScopedCredentialType;
1665 interface ScopedCredentialOptions {
1666 excludeList?: ScopedCredentialDescriptor[];
1667 extensions?: WebAuthnExtensions;
1669 timeoutSeconds?: number;
1672 interface ScopedCredentialParameters {
1673 algorithm: string | Algorithm;
1674 type: ScopedCredentialType;
1677 interface ScrollIntoViewOptions extends ScrollOptions {
1678 block?: ScrollLogicalPosition;
1679 inline?: ScrollLogicalPosition;
1682 interface ScrollOptions {
1683 behavior?: ScrollBehavior;
1686 interface ScrollToOptions extends ScrollOptions {
1691 interface SecurityPolicyViolationEventInit extends EventInit {
1692 blockedURI?: string;
1693 columnNumber?: number;
1694 documentURI?: string;
1695 effectiveDirective?: string;
1696 lineNumber?: number;
1697 originalPolicy?: string;
1699 sourceFile?: string;
1700 statusCode?: number;
1701 violatedDirective?: string;
1704 interface ServiceWorkerMessageEventInit extends EventInit {
1706 lastEventId?: string;
1708 ports?: MessagePort[] | null;
1709 source?: ServiceWorker | MessagePort | null;
1712 interface ShadowRootInit {
1713 delegatesFocus?: boolean;
1714 mode: ShadowRootMode;
1717 interface ShareData {
1723 interface SpeechSynthesisErrorEventInit extends SpeechSynthesisEventInit {
1724 error: SpeechSynthesisErrorCode;
1727 interface SpeechSynthesisEventInit extends EventInit {
1729 charLength?: number;
1730 elapsedTime?: number;
1732 utterance: SpeechSynthesisUtterance;
1735 interface StaticRangeInit {
1738 startContainer: Node;
1739 startOffset: number;
1742 interface StereoPannerOptions extends AudioNodeOptions {
1746 interface StorageEstimate {
1751 interface StorageEventInit extends EventInit {
1752 key?: string | null;
1753 newValue?: string | null;
1754 oldValue?: string | null;
1755 storageArea?: Storage | null;
1759 interface StoreExceptionsInformation extends ExceptionInformation {
1760 detailURI?: string | null;
1761 explanationString?: string | null;
1762 siteName?: string | null;
1765 interface StoreSiteSpecificExceptionsInformation extends StoreExceptionsInformation {
1766 arrayOfDomainStrings?: string[];
1769 interface TextDecodeOptions {
1773 interface TextDecoderOptions {
1775 ignoreBOM?: boolean;
1778 interface TextEncoderEncodeIntoResult {
1783 interface TouchEventInit extends EventModifierInit {
1784 changedTouches?: Touch[];
1785 targetTouches?: Touch[];
1789 interface TouchInit {
1790 altitudeAngle?: number;
1791 azimuthAngle?: number;
1800 rotationAngle?: number;
1803 target: EventTarget;
1804 touchType?: TouchType;
1807 interface TrackEventInit extends EventInit {
1808 track?: TextTrack | null;
1811 interface Transformer<I = any, O = any> {
1812 flush?: TransformStreamDefaultControllerCallback<O>;
1813 readableType?: undefined;
1814 start?: TransformStreamDefaultControllerCallback<O>;
1815 transform?: TransformStreamDefaultControllerTransformCallback<I, O>;
1816 writableType?: undefined;
1819 interface TransitionEventInit extends EventInit {
1820 elapsedTime?: number;
1821 propertyName?: string;
1822 pseudoElement?: string;
1825 interface UIEventInit extends EventInit {
1827 view?: Window | null;
1830 interface ULongRange {
1835 interface UnderlyingByteSource {
1836 autoAllocateChunkSize?: number;
1837 cancel?: ReadableStreamErrorCallback;
1838 pull?: ReadableByteStreamControllerCallback;
1839 start?: ReadableByteStreamControllerCallback;
1843 interface UnderlyingSink<W = any> {
1844 abort?: WritableStreamErrorCallback;
1845 close?: WritableStreamDefaultControllerCloseCallback;
1846 start?: WritableStreamDefaultControllerStartCallback;
1848 write?: WritableStreamDefaultControllerWriteCallback<W>;
1851 interface UnderlyingSource<R = any> {
1852 cancel?: ReadableStreamErrorCallback;
1853 pull?: ReadableStreamDefaultControllerCallback<R>;
1854 start?: ReadableStreamDefaultControllerCallback<R>;
1858 interface VRDisplayEventInit extends EventInit {
1860 reason?: VRDisplayEventReason;
1864 leftBounds?: number[] | Float32Array | null;
1865 rightBounds?: number[] | Float32Array | null;
1866 source?: HTMLCanvasElement | null;
1869 interface VRStageParameters {
1870 sittingToStandingTransform?: Float32Array;
1875 interface WaveShaperOptions extends AudioNodeOptions {
1876 curve?: number[] | Float32Array;
1877 oversample?: OverSampleType;
1880 interface WebAuthnExtensions {
1883 interface WebGLContextAttributes {
1885 antialias?: boolean;
1887 desynchronized?: boolean;
1888 failIfMajorPerformanceCaveat?: boolean;
1889 powerPreference?: WebGLPowerPreference;
1890 premultipliedAlpha?: boolean;
1891 preserveDrawingBuffer?: boolean;
1895 interface WebGLContextEventInit extends EventInit {
1896 statusMessage?: string;
1899 interface WheelEventInit extends MouseEventInit {
1906 interface WorkerOptions {
1907 credentials?: RequestCredentials;
1912 interface WorkletOptions {
1913 credentials?: RequestCredentials;
1916 interface EventListener {
1920 type XPathNSResolver = ((prefix: string | null) => string | null) | { lookupNamespaceURI(prefix: string | null): string | null; };
1922 /** 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. */
1923 interface ANGLE_instanced_arrays {
1924 drawArraysInstancedANGLE(mode: GLenum, first: GLint, count: GLsizei, primcount: GLsizei): void;
1925 drawElementsInstancedANGLE(mode: GLenum, count: GLsizei, type: GLenum, offset: GLintptr, primcount: GLsizei): void;
1926 vertexAttribDivisorANGLE(index: GLuint, divisor: GLuint): void;
1927 readonly VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE: GLenum;
1930 /** A controller object that allows you to abort one or more DOM requests as and when desired. */
1931 interface AbortController {
1933 * Returns the AbortSignal object associated with this object.
1935 readonly signal: AbortSignal;
1937 * 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.
1942 declare var AbortController: {
1943 prototype: AbortController;
1944 new(): AbortController;
1947 interface AbortSignalEventMap {
1951 /** 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. */
1952 interface AbortSignal extends EventTarget {
1954 * Returns true if this AbortSignal's AbortController has signaled to abort, and false otherwise.
1956 readonly aborted: boolean;
1957 onabort: ((this: AbortSignal, ev: Event) => any) | null;
1958 addEventListener<K extends keyof AbortSignalEventMap>(type: K, listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
1959 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
1960 removeEventListener<K extends keyof AbortSignalEventMap>(type: K, listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
1961 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
1964 declare var AbortSignal: {
1965 prototype: AbortSignal;
1969 interface AbstractRange {
1971 * Returns true if range is collapsed, and false otherwise.
1973 readonly collapsed: boolean;
1975 * Returns range's end node.
1977 readonly endContainer: Node;
1979 * Returns range's end offset.
1981 readonly endOffset: number;
1983 * Returns range's start node.
1985 readonly startContainer: Node;
1987 * Returns range's start offset.
1989 readonly startOffset: number;
1992 declare var AbstractRange: {
1993 prototype: AbstractRange;
1994 new(): AbstractRange;
1997 interface AbstractWorkerEventMap {
1998 "error": ErrorEvent;
2001 interface AbstractWorker {
2002 onerror: ((this: AbstractWorker, ev: ErrorEvent) => any) | null;
2003 addEventListener<K extends keyof AbstractWorkerEventMap>(type: K, listener: (this: AbstractWorker, ev: AbstractWorkerEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
2004 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
2005 removeEventListener<K extends keyof AbstractWorkerEventMap>(type: K, listener: (this: AbstractWorker, ev: AbstractWorkerEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
2006 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
2009 interface AesCfbParams extends Algorithm {
2010 iv: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;
2013 interface AesCmacParams extends Algorithm {
2017 /** 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. */
2018 interface AnalyserNode extends AudioNode {
2020 readonly frequencyBinCount: number;
2021 maxDecibels: number;
2022 minDecibels: number;
2023 smoothingTimeConstant: number;
2024 getByteFrequencyData(array: Uint8Array): void;
2025 getByteTimeDomainData(array: Uint8Array): void;
2026 getFloatFrequencyData(array: Float32Array): void;
2027 getFloatTimeDomainData(array: Float32Array): void;
2030 declare var AnalyserNode: {
2031 prototype: AnalyserNode;
2032 new(context: BaseAudioContext, options?: AnalyserOptions): AnalyserNode;
2035 interface Animatable {
2036 animate(keyframes: Keyframe[] | PropertyIndexedKeyframes | null, options?: number | KeyframeAnimationOptions): Animation;
2037 getAnimations(): Animation[];
2040 interface AnimationEventMap {
2041 "cancel": AnimationPlaybackEvent;
2042 "finish": AnimationPlaybackEvent;
2045 interface Animation extends EventTarget {
2046 currentTime: number | null;
2047 effect: AnimationEffect | null;
2048 readonly finished: Promise<Animation>;
2050 oncancel: ((this: Animation, ev: AnimationPlaybackEvent) => any) | null;
2051 onfinish: ((this: Animation, ev: AnimationPlaybackEvent) => any) | null;
2052 readonly pending: boolean;
2053 readonly playState: AnimationPlayState;
2054 playbackRate: number;
2055 readonly ready: Promise<Animation>;
2056 startTime: number | null;
2057 timeline: AnimationTimeline | null;
2063 updatePlaybackRate(playbackRate: number): void;
2064 addEventListener<K extends keyof AnimationEventMap>(type: K, listener: (this: Animation, ev: AnimationEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
2065 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
2066 removeEventListener<K extends keyof AnimationEventMap>(type: K, listener: (this: Animation, ev: AnimationEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
2067 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
2070 declare var Animation: {
2071 prototype: Animation;
2072 new(effect?: AnimationEffect | null, timeline?: AnimationTimeline | null): Animation;
2075 interface AnimationEffect {
2076 getComputedTiming(): ComputedEffectTiming;
2077 getTiming(): EffectTiming;
2078 updateTiming(timing?: OptionalEffectTiming): void;
2081 declare var AnimationEffect: {
2082 prototype: AnimationEffect;
2083 new(): AnimationEffect;
2086 /** Events providing information related to animations. */
2087 interface AnimationEvent extends Event {
2088 readonly animationName: string;
2089 readonly elapsedTime: number;
2090 readonly pseudoElement: string;
2093 declare var AnimationEvent: {
2094 prototype: AnimationEvent;
2095 new(type: string, animationEventInitDict?: AnimationEventInit): AnimationEvent;
2098 interface AnimationFrameProvider {
2099 cancelAnimationFrame(handle: number): void;
2100 requestAnimationFrame(callback: FrameRequestCallback): number;
2103 interface AnimationPlaybackEvent extends Event {
2104 readonly currentTime: number | null;
2105 readonly timelineTime: number | null;
2108 declare var AnimationPlaybackEvent: {
2109 prototype: AnimationPlaybackEvent;
2110 new(type: string, eventInitDict?: AnimationPlaybackEventInit): AnimationPlaybackEvent;
2113 interface AnimationTimeline {
2114 readonly currentTime: number | null;
2117 declare var AnimationTimeline: {
2118 prototype: AnimationTimeline;
2119 new(): AnimationTimeline;
2122 interface ApplicationCacheEventMap {
2125 "downloading": Event;
2129 "progress": ProgressEvent<ApplicationCache>;
2130 "updateready": Event;
2133 interface ApplicationCache extends EventTarget {
2135 oncached: ((this: ApplicationCache, ev: Event) => any) | null;
2137 onchecking: ((this: ApplicationCache, ev: Event) => any) | null;
2139 ondownloading: ((this: ApplicationCache, ev: Event) => any) | null;
2141 onerror: ((this: ApplicationCache, ev: Event) => any) | null;
2143 onnoupdate: ((this: ApplicationCache, ev: Event) => any) | null;
2145 onobsolete: ((this: ApplicationCache, ev: Event) => any) | null;
2147 onprogress: ((this: ApplicationCache, ev: ProgressEvent<ApplicationCache>) => any) | null;
2149 onupdateready: ((this: ApplicationCache, ev: Event) => any) | null;
2151 readonly status: number;
2158 readonly CHECKING: number;
2159 readonly DOWNLOADING: number;
2160 readonly IDLE: number;
2161 readonly OBSOLETE: number;
2162 readonly UNCACHED: number;
2163 readonly UPDATEREADY: number;
2164 addEventListener<K extends keyof ApplicationCacheEventMap>(type: K, listener: (this: ApplicationCache, ev: ApplicationCacheEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
2165 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
2166 removeEventListener<K extends keyof ApplicationCacheEventMap>(type: K, listener: (this: ApplicationCache, ev: ApplicationCacheEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
2167 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
2170 declare var ApplicationCache: {
2171 prototype: ApplicationCache;
2172 new(): ApplicationCache;
2173 readonly CHECKING: number;
2174 readonly DOWNLOADING: number;
2175 readonly IDLE: number;
2176 readonly OBSOLETE: number;
2177 readonly UNCACHED: number;
2178 readonly UPDATEREADY: number;
2181 /** 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. */
2182 interface Attr extends Node {
2183 readonly localName: string;
2184 readonly name: string;
2185 readonly namespaceURI: string | null;
2186 readonly ownerDocument: Document;
2187 readonly ownerElement: Element | null;
2188 readonly prefix: string | null;
2189 readonly specified: boolean;
2198 /** 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. */
2199 interface AudioBuffer {
2200 readonly duration: number;
2201 readonly length: number;
2202 readonly numberOfChannels: number;
2203 readonly sampleRate: number;
2204 copyFromChannel(destination: Float32Array, channelNumber: number, bufferOffset?: number): void;
2205 copyToChannel(source: Float32Array, channelNumber: number, bufferOffset?: number): void;
2206 getChannelData(channel: number): Float32Array;
2209 declare var AudioBuffer: {
2210 prototype: AudioBuffer;
2211 new(options: AudioBufferOptions): AudioBuffer;
2214 /** 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. */
2215 interface AudioBufferSourceNode extends AudioScheduledSourceNode {
2216 buffer: AudioBuffer | null;
2217 readonly detune: AudioParam;
2221 readonly playbackRate: AudioParam;
2222 start(when?: number, offset?: number, duration?: number): void;
2223 addEventListener<K extends keyof AudioScheduledSourceNodeEventMap>(type: K, listener: (this: AudioBufferSourceNode, ev: AudioScheduledSourceNodeEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
2224 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
2225 removeEventListener<K extends keyof AudioScheduledSourceNodeEventMap>(type: K, listener: (this: AudioBufferSourceNode, ev: AudioScheduledSourceNodeEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
2226 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
2229 declare var AudioBufferSourceNode: {
2230 prototype: AudioBufferSourceNode;
2231 new(context: BaseAudioContext, options?: AudioBufferSourceOptions): AudioBufferSourceNode;
2234 /** An audio-processing graph built from audio modules linked together, each represented by an AudioNode. */
2235 interface AudioContext extends BaseAudioContext {
2236 readonly baseLatency: number;
2237 readonly outputLatency: number;
2238 close(): Promise<void>;
2239 createMediaElementSource(mediaElement: HTMLMediaElement): MediaElementAudioSourceNode;
2240 createMediaStreamDestination(): MediaStreamAudioDestinationNode;
2241 createMediaStreamSource(mediaStream: MediaStream): MediaStreamAudioSourceNode;
2242 createMediaStreamTrackSource(mediaStreamTrack: MediaStreamTrack): MediaStreamTrackAudioSourceNode;
2243 getOutputTimestamp(): AudioTimestamp;
2244 resume(): Promise<void>;
2245 suspend(): Promise<void>;
2246 addEventListener<K extends keyof BaseAudioContextEventMap>(type: K, listener: (this: AudioContext, ev: BaseAudioContextEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
2247 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
2248 removeEventListener<K extends keyof BaseAudioContextEventMap>(type: K, listener: (this: AudioContext, ev: BaseAudioContextEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
2249 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
2252 declare var AudioContext: {
2253 prototype: AudioContext;
2254 new(contextOptions?: AudioContextOptions): AudioContext;
2257 /** 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. */
2258 interface AudioDestinationNode extends AudioNode {
2259 readonly maxChannelCount: number;
2262 declare var AudioDestinationNode: {
2263 prototype: AudioDestinationNode;
2264 new(): AudioDestinationNode;
2267 /** 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. */
2268 interface AudioListener {
2269 readonly forwardX: AudioParam;
2270 readonly forwardY: AudioParam;
2271 readonly forwardZ: AudioParam;
2272 readonly positionX: AudioParam;
2273 readonly positionY: AudioParam;
2274 readonly positionZ: AudioParam;
2275 readonly upX: AudioParam;
2276 readonly upY: AudioParam;
2277 readonly upZ: AudioParam;
2279 setOrientation(x: number, y: number, z: number, xUp: number, yUp: number, zUp: number): void;
2281 setPosition(x: number, y: number, z: number): void;
2284 declare var AudioListener: {
2285 prototype: AudioListener;
2286 new(): AudioListener;
2289 /** A generic interface for representing an audio processing module. Examples include: */
2290 interface AudioNode extends EventTarget {
2291 channelCount: number;
2292 channelCountMode: ChannelCountMode;
2293 channelInterpretation: ChannelInterpretation;
2294 readonly context: BaseAudioContext;
2295 readonly numberOfInputs: number;
2296 readonly numberOfOutputs: number;
2297 connect(destinationNode: AudioNode, output?: number, input?: number): AudioNode;
2298 connect(destinationParam: AudioParam, output?: number): void;
2300 disconnect(output: number): void;
2301 disconnect(destinationNode: AudioNode): void;
2302 disconnect(destinationNode: AudioNode, output: number): void;
2303 disconnect(destinationNode: AudioNode, output: number, input: number): void;
2304 disconnect(destinationParam: AudioParam): void;
2305 disconnect(destinationParam: AudioParam, output: number): void;
2308 declare var AudioNode: {
2309 prototype: AudioNode;
2313 /** The Web Audio API's AudioParam interface represents an audio-related parameter, usually a parameter of an AudioNode (such as GainNode.gain). */
2314 interface AudioParam {
2315 automationRate: AutomationRate;
2316 readonly defaultValue: number;
2317 readonly maxValue: number;
2318 readonly minValue: number;
2320 cancelAndHoldAtTime(cancelTime: number): AudioParam;
2321 cancelScheduledValues(cancelTime: number): AudioParam;
2322 exponentialRampToValueAtTime(value: number, endTime: number): AudioParam;
2323 linearRampToValueAtTime(value: number, endTime: number): AudioParam;
2324 setTargetAtTime(target: number, startTime: number, timeConstant: number): AudioParam;
2325 setValueAtTime(value: number, startTime: number): AudioParam;
2326 setValueCurveAtTime(values: number[] | Float32Array, startTime: number, duration: number): AudioParam;
2329 declare var AudioParam: {
2330 prototype: AudioParam;
2334 interface AudioParamMap {
2335 forEach(callbackfn: (value: AudioParam, key: string, parent: AudioParamMap) => void, thisArg?: any): void;
2338 declare var AudioParamMap: {
2339 prototype: AudioParamMap;
2340 new(): AudioParamMap;
2343 /** The Web Audio API events that occur when a ScriptProcessorNode input buffer is ready to be processed. */
2344 interface AudioProcessingEvent extends Event {
2345 readonly inputBuffer: AudioBuffer;
2346 readonly outputBuffer: AudioBuffer;
2347 readonly playbackTime: number;
2350 declare var AudioProcessingEvent: {
2351 prototype: AudioProcessingEvent;
2352 new(type: string, eventInitDict: AudioProcessingEventInit): AudioProcessingEvent;
2355 interface AudioScheduledSourceNodeEventMap {
2359 interface AudioScheduledSourceNode extends AudioNode {
2360 onended: ((this: AudioScheduledSourceNode, ev: Event) => any) | null;
2361 start(when?: number): void;
2362 stop(when?: number): void;
2363 addEventListener<K extends keyof AudioScheduledSourceNodeEventMap>(type: K, listener: (this: AudioScheduledSourceNode, ev: AudioScheduledSourceNodeEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
2364 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
2365 removeEventListener<K extends keyof AudioScheduledSourceNodeEventMap>(type: K, listener: (this: AudioScheduledSourceNode, ev: AudioScheduledSourceNodeEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
2366 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
2369 declare var AudioScheduledSourceNode: {
2370 prototype: AudioScheduledSourceNode;
2371 new(): AudioScheduledSourceNode;
2374 interface AudioWorklet extends Worklet {
2377 declare var AudioWorklet: {
2378 prototype: AudioWorklet;
2379 new(): AudioWorklet;
2382 interface AudioWorkletNodeEventMap {
2383 "processorerror": Event;
2386 interface AudioWorkletNode extends AudioNode {
2387 onprocessorerror: ((this: AudioWorkletNode, ev: Event) => any) | null;
2388 readonly parameters: AudioParamMap;
2389 readonly port: MessagePort;
2390 addEventListener<K extends keyof AudioWorkletNodeEventMap>(type: K, listener: (this: AudioWorkletNode, ev: AudioWorkletNodeEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
2391 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
2392 removeEventListener<K extends keyof AudioWorkletNodeEventMap>(type: K, listener: (this: AudioWorkletNode, ev: AudioWorkletNodeEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
2393 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
2396 declare var AudioWorkletNode: {
2397 prototype: AudioWorkletNode;
2398 new(context: BaseAudioContext, name: string, options?: AudioWorkletNodeOptions): AudioWorkletNode;
2401 interface AuthenticatorAssertionResponse extends AuthenticatorResponse {
2402 readonly authenticatorData: ArrayBuffer;
2403 readonly signature: ArrayBuffer;
2404 readonly userHandle: ArrayBuffer | null;
2407 declare var AuthenticatorAssertionResponse: {
2408 prototype: AuthenticatorAssertionResponse;
2409 new(): AuthenticatorAssertionResponse;
2412 interface AuthenticatorAttestationResponse extends AuthenticatorResponse {
2413 readonly attestationObject: ArrayBuffer;
2416 declare var AuthenticatorAttestationResponse: {
2417 prototype: AuthenticatorAttestationResponse;
2418 new(): AuthenticatorAttestationResponse;
2421 interface AuthenticatorResponse {
2422 readonly clientDataJSON: ArrayBuffer;
2425 declare var AuthenticatorResponse: {
2426 prototype: AuthenticatorResponse;
2427 new(): AuthenticatorResponse;
2431 readonly visible: boolean;
2434 declare var BarProp: {
2439 interface BaseAudioContextEventMap {
2440 "statechange": Event;
2443 interface BaseAudioContext extends EventTarget {
2444 readonly audioWorklet: AudioWorklet;
2445 readonly currentTime: number;
2446 readonly destination: AudioDestinationNode;
2447 readonly listener: AudioListener;
2448 onstatechange: ((this: BaseAudioContext, ev: Event) => any) | null;
2449 readonly sampleRate: number;
2450 readonly state: AudioContextState;
2451 createAnalyser(): AnalyserNode;
2452 createBiquadFilter(): BiquadFilterNode;
2453 createBuffer(numberOfChannels: number, length: number, sampleRate: number): AudioBuffer;
2454 createBufferSource(): AudioBufferSourceNode;
2455 createChannelMerger(numberOfInputs?: number): ChannelMergerNode;
2456 createChannelSplitter(numberOfOutputs?: number): ChannelSplitterNode;
2457 createConstantSource(): ConstantSourceNode;
2458 createConvolver(): ConvolverNode;
2459 createDelay(maxDelayTime?: number): DelayNode;
2460 createDynamicsCompressor(): DynamicsCompressorNode;
2461 createGain(): GainNode;
2462 createIIRFilter(feedforward: number[], feedback: number[]): IIRFilterNode;
2463 createOscillator(): OscillatorNode;
2464 createPanner(): PannerNode;
2465 createPeriodicWave(real: number[] | Float32Array, imag: number[] | Float32Array, constraints?: PeriodicWaveConstraints): PeriodicWave;
2466 createScriptProcessor(bufferSize?: number, numberOfInputChannels?: number, numberOfOutputChannels?: number): ScriptProcessorNode;
2467 createStereoPanner(): StereoPannerNode;
2468 createWaveShaper(): WaveShaperNode;
2469 decodeAudioData(audioData: ArrayBuffer, successCallback?: DecodeSuccessCallback | null, errorCallback?: DecodeErrorCallback | null): Promise<AudioBuffer>;
2470 addEventListener<K extends keyof BaseAudioContextEventMap>(type: K, listener: (this: BaseAudioContext, ev: BaseAudioContextEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
2471 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
2472 removeEventListener<K extends keyof BaseAudioContextEventMap>(type: K, listener: (this: BaseAudioContext, ev: BaseAudioContextEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
2473 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
2476 declare var BaseAudioContext: {
2477 prototype: BaseAudioContext;
2478 new(): BaseAudioContext;
2481 /** The beforeunload event is fired when the window, the document and its resources are about to be unloaded. */
2482 interface BeforeUnloadEvent extends Event {
2486 declare var BeforeUnloadEvent: {
2487 prototype: BeforeUnloadEvent;
2488 new(): BeforeUnloadEvent;
2491 interface BhxBrowser {
2492 readonly lastError: DOMException;
2493 checkMatchesGlobExpression(pattern: string, value: string): boolean;
2494 checkMatchesUriExpression(pattern: string, value: string): boolean;
2495 clearLastError(): void;
2496 currentWindowId(): number;
2497 fireExtensionApiTelemetry(functionName: string, isSucceeded: boolean, isSupported: boolean, errorString: string): void;
2498 genericFunction(functionId: number, destination: any, parameters?: string, callbackId?: number): void;
2499 genericSynchronousFunction(functionId: number, parameters?: string): string;
2500 getExtensionId(): string;
2501 getThisAddress(): any;
2502 registerGenericFunctionCallbackHandler(callbackHandler: Function): void;
2503 registerGenericListenerHandler(eventHandler: Function): void;
2504 setLastError(parameters: string): void;
2505 webPlatformGenericFunction(destination: any, parameters?: string, callbackId?: number): void;
2508 declare var BhxBrowser: {
2509 prototype: BhxBrowser;
2513 /** 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. */
2514 interface BiquadFilterNode extends AudioNode {
2515 readonly Q: AudioParam;
2516 readonly detune: AudioParam;
2517 readonly frequency: AudioParam;
2518 readonly gain: AudioParam;
2519 type: BiquadFilterType;
2520 getFrequencyResponse(frequencyHz: Float32Array, magResponse: Float32Array, phaseResponse: Float32Array): void;
2523 declare var BiquadFilterNode: {
2524 prototype: BiquadFilterNode;
2525 new(context: BaseAudioContext, options?: BiquadFilterOptions): BiquadFilterNode;
2528 /** 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. */
2530 readonly size: number;
2531 readonly type: string;
2532 arrayBuffer(): Promise<ArrayBuffer>;
2533 slice(start?: number, end?: number, contentType?: string): Blob;
2534 stream(): ReadableStream;
2535 text(): Promise<string>;
2540 new(blobParts?: BlobPart[], options?: BlobPropertyBag): Blob;
2544 readonly body: ReadableStream<Uint8Array> | null;
2545 readonly bodyUsed: boolean;
2546 arrayBuffer(): Promise<ArrayBuffer>;
2547 blob(): Promise<Blob>;
2548 formData(): Promise<FormData>;
2549 json(): Promise<any>;
2550 text(): Promise<string>;
2553 interface BroadcastChannelEventMap {
2554 "message": MessageEvent;
2555 "messageerror": MessageEvent;
2558 interface BroadcastChannel extends EventTarget {
2560 * Returns the channel name (as passed to the constructor).
2562 readonly name: string;
2563 onmessage: ((this: BroadcastChannel, ev: MessageEvent) => any) | null;
2564 onmessageerror: ((this: BroadcastChannel, ev: MessageEvent) => any) | null;
2566 * Closes the BroadcastChannel object, opening it up to garbage collection.
2570 * Sends the given message to other BroadcastChannel objects set up for this channel. Messages can be structured objects, e.g. nested objects and arrays.
2572 postMessage(message: any): void;
2573 addEventListener<K extends keyof BroadcastChannelEventMap>(type: K, listener: (this: BroadcastChannel, ev: BroadcastChannelEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
2574 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
2575 removeEventListener<K extends keyof BroadcastChannelEventMap>(type: K, listener: (this: BroadcastChannel, ev: BroadcastChannelEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
2576 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
2579 declare var BroadcastChannel: {
2580 prototype: BroadcastChannel;
2581 new(name: string): BroadcastChannel;
2584 /** This Streams API interface provides a built-in byte length queuing strategy that can be used when constructing streams. */
2585 interface ByteLengthQueuingStrategy extends QueuingStrategy<ArrayBufferView> {
2586 highWaterMark: number;
2587 size(chunk: ArrayBufferView): number;
2590 declare var ByteLengthQueuingStrategy: {
2591 prototype: ByteLengthQueuingStrategy;
2592 new(options: { highWaterMark: number }): ByteLengthQueuingStrategy;
2595 /** 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. */
2596 interface CDATASection extends Text {
2599 declare var CDATASection: {
2600 prototype: CDATASection;
2601 new(): CDATASection;
2604 /** A single condition CSS at-rule, which consists of a condition and a statement block. It is a child of CSSGroupingRule. */
2605 interface CSSConditionRule extends CSSGroupingRule {
2606 conditionText: string;
2609 declare var CSSConditionRule: {
2610 prototype: CSSConditionRule;
2611 new(): CSSConditionRule;
2614 interface CSSFontFaceRule extends CSSRule {
2615 readonly style: CSSStyleDeclaration;
2618 declare var CSSFontFaceRule: {
2619 prototype: CSSFontFaceRule;
2620 new(): CSSFontFaceRule;
2623 /** Any CSS at-rule that contains other rules nested within it. */
2624 interface CSSGroupingRule extends CSSRule {
2625 readonly cssRules: CSSRuleList;
2626 deleteRule(index: number): void;
2627 insertRule(rule: string, index?: number): number;
2630 declare var CSSGroupingRule: {
2631 prototype: CSSGroupingRule;
2632 new(): CSSGroupingRule;
2635 interface CSSImportRule extends CSSRule {
2636 readonly href: string;
2637 readonly media: MediaList;
2638 readonly styleSheet: CSSStyleSheet;
2641 declare var CSSImportRule: {
2642 prototype: CSSImportRule;
2643 new(): CSSImportRule;
2646 /** 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). */
2647 interface CSSKeyframeRule extends CSSRule {
2649 readonly style: CSSStyleDeclaration;
2652 declare var CSSKeyframeRule: {
2653 prototype: CSSKeyframeRule;
2654 new(): CSSKeyframeRule;
2657 /** 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). */
2658 interface CSSKeyframesRule extends CSSRule {
2659 readonly cssRules: CSSRuleList;
2661 appendRule(rule: string): void;
2662 deleteRule(select: string): void;
2663 findRule(select: string): CSSKeyframeRule | null;
2666 declare var CSSKeyframesRule: {
2667 prototype: CSSKeyframesRule;
2668 new(): CSSKeyframesRule;
2671 /** 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). */
2672 interface CSSMediaRule extends CSSConditionRule {
2673 readonly media: MediaList;
2676 declare var CSSMediaRule: {
2677 prototype: CSSMediaRule;
2678 new(): CSSMediaRule;
2681 /** An object representing a single CSS @namespace at-rule. It implements the CSSRule interface, with a type value of 10 (CSSRule.NAMESPACE_RULE). */
2682 interface CSSNamespaceRule extends CSSRule {
2683 readonly namespaceURI: string;
2684 readonly prefix: string;
2687 declare var CSSNamespaceRule: {
2688 prototype: CSSNamespaceRule;
2689 new(): CSSNamespaceRule;
2692 /** CSSPageRule is an interface representing a single CSS @page rule. It implements the CSSRule interface with a type value of 6 (CSSRule.PAGE_RULE). */
2693 interface CSSPageRule extends CSSGroupingRule {
2694 selectorText: string;
2695 readonly style: CSSStyleDeclaration;
2698 declare var CSSPageRule: {
2699 prototype: CSSPageRule;
2703 /** A single CSS rule. There are several types of rules, listed in the Type constants section below. */
2706 readonly parentRule: CSSRule | null;
2707 readonly parentStyleSheet: CSSStyleSheet | null;
2708 readonly type: number;
2709 readonly CHARSET_RULE: number;
2710 readonly FONT_FACE_RULE: number;
2711 readonly IMPORT_RULE: number;
2712 readonly KEYFRAMES_RULE: number;
2713 readonly KEYFRAME_RULE: number;
2714 readonly MEDIA_RULE: number;
2715 readonly NAMESPACE_RULE: number;
2716 readonly PAGE_RULE: number;
2717 readonly STYLE_RULE: number;
2718 readonly SUPPORTS_RULE: number;
2721 declare var CSSRule: {
2724 readonly CHARSET_RULE: number;
2725 readonly FONT_FACE_RULE: number;
2726 readonly IMPORT_RULE: number;
2727 readonly KEYFRAMES_RULE: number;
2728 readonly KEYFRAME_RULE: number;
2729 readonly MEDIA_RULE: number;
2730 readonly NAMESPACE_RULE: number;
2731 readonly PAGE_RULE: number;
2732 readonly STYLE_RULE: number;
2733 readonly SUPPORTS_RULE: number;
2736 /** A CSSRuleList is an (indirect-modify only) array-like object containing an ordered collection of CSSRule objects. */
2737 interface CSSRuleList {
2738 readonly length: number;
2739 item(index: number): CSSRule | null;
2740 [index: number]: CSSRule;
2743 declare var CSSRuleList: {
2744 prototype: CSSRuleList;
2748 /** An object that is a CSS declaration block, and exposes style information and various style-related methods and properties. */
2749 interface CSSStyleDeclaration {
2750 alignContent: string;
2753 alignmentBaseline: string;
2756 animationDelay: string;
2757 animationDirection: string;
2758 animationDuration: string;
2759 animationFillMode: string;
2760 animationIterationCount: string;
2761 animationName: string;
2762 animationPlayState: string;
2763 animationTimingFunction: string;
2764 backfaceVisibility: string;
2766 backgroundAttachment: string;
2767 backgroundClip: string;
2768 backgroundColor: string;
2769 backgroundImage: string;
2770 backgroundOrigin: string;
2771 backgroundPosition: string;
2772 backgroundPositionX: string;
2773 backgroundPositionY: string;
2774 backgroundRepeat: string;
2775 backgroundSize: string;
2776 baselineShift: string;
2779 borderBlockEnd: string;
2780 borderBlockEndColor: string;
2781 borderBlockEndStyle: string;
2782 borderBlockEndWidth: string;
2783 borderBlockStart: string;
2784 borderBlockStartColor: string;
2785 borderBlockStartStyle: string;
2786 borderBlockStartWidth: string;
2787 borderBottom: string;
2788 borderBottomColor: string;
2789 borderBottomLeftRadius: string;
2790 borderBottomRightRadius: string;
2791 borderBottomStyle: string;
2792 borderBottomWidth: string;
2793 borderCollapse: string;
2794 borderColor: string;
2795 borderImage: string;
2796 borderImageOutset: string;
2797 borderImageRepeat: string;
2798 borderImageSlice: string;
2799 borderImageSource: string;
2800 borderImageWidth: string;
2801 borderInlineEnd: string;
2802 borderInlineEndColor: string;
2803 borderInlineEndStyle: string;
2804 borderInlineEndWidth: string;
2805 borderInlineStart: string;
2806 borderInlineStartColor: string;
2807 borderInlineStartStyle: string;
2808 borderInlineStartWidth: string;
2810 borderLeftColor: string;
2811 borderLeftStyle: string;
2812 borderLeftWidth: string;
2813 borderRadius: string;
2814 borderRight: string;
2815 borderRightColor: string;
2816 borderRightStyle: string;
2817 borderRightWidth: string;
2818 borderSpacing: string;
2819 borderStyle: string;
2821 borderTopColor: string;
2822 borderTopLeftRadius: string;
2823 borderTopRightRadius: string;
2824 borderTopStyle: string;
2825 borderTopWidth: string;
2826 borderWidth: string;
2831 breakBefore: string;
2832 breakInside: string;
2833 captionSide: string;
2840 colorInterpolation: string;
2841 colorInterpolationFilters: string;
2842 columnCount: string;
2846 columnRuleColor: string;
2847 columnRuleStyle: string;
2848 columnRuleWidth: string;
2850 columnWidth: string;
2853 counterIncrement: string;
2854 counterReset: string;
2860 dominantBaseline: string;
2863 fillOpacity: string;
2868 flexDirection: string;
2875 floodOpacity: string;
2878 fontFeatureSettings: string;
2879 fontKerning: string;
2881 fontSizeAdjust: string;
2882 fontStretch: string;
2884 fontSynthesis: string;
2885 fontVariant: string;
2886 fontVariantCaps: string;
2887 fontVariantEastAsian: string;
2888 fontVariantLigatures: string;
2889 fontVariantNumeric: string;
2890 fontVariantPosition: string;
2893 glyphOrientationVertical: string;
2896 gridAutoColumns: string;
2897 gridAutoFlow: string;
2898 gridAutoRows: string;
2900 gridColumnEnd: string;
2901 gridColumnGap: string;
2902 gridColumnStart: string;
2907 gridRowStart: string;
2908 gridTemplate: string;
2909 gridTemplateAreas: string;
2910 gridTemplateColumns: string;
2911 gridTemplateRows: string;
2914 imageOrientation: string;
2915 imageRendering: string;
2917 justifyContent: string;
2918 justifyItems: string;
2919 justifySelf: string;
2921 readonly length: number;
2922 letterSpacing: string;
2923 lightingColor: string;
2927 listStyleImage: string;
2928 listStylePosition: string;
2929 listStyleType: string;
2931 marginBlockEnd: string;
2932 marginBlockStart: string;
2933 marginBottom: string;
2934 marginInlineEnd: string;
2935 marginInlineStart: string;
2937 marginRight: string;
2942 markerStart: string;
2944 maskComposite: string;
2946 maskPosition: string;
2950 maxBlockSize: string;
2952 maxInlineSize: string;
2954 minBlockSize: string;
2956 minInlineSize: string;
2959 objectPosition: string;
2964 outlineColor: string;
2965 outlineOffset: string;
2966 outlineStyle: string;
2967 outlineWidth: string;
2969 overflowAnchor: string;
2970 overflowWrap: string;
2973 overscrollBehavior: string;
2974 overscrollBehaviorBlock: string;
2975 overscrollBehaviorInline: string;
2976 overscrollBehaviorX: string;
2977 overscrollBehaviorY: string;
2979 paddingBlockEnd: string;
2980 paddingBlockStart: string;
2981 paddingBottom: string;
2982 paddingInlineEnd: string;
2983 paddingInlineStart: string;
2984 paddingLeft: string;
2985 paddingRight: string;
2987 pageBreakAfter: string;
2988 pageBreakBefore: string;
2989 pageBreakInside: string;
2991 readonly parentRule: CSSRule | null;
2992 perspective: string;
2993 perspectiveOrigin: string;
2994 placeContent: string;
2997 pointerEvents: string;
3005 rubyPosition: string;
3007 scrollBehavior: string;
3008 shapeRendering: string;
3010 stopOpacity: string;
3012 strokeDasharray: string;
3013 strokeDashoffset: string;
3014 strokeLinecap: string;
3015 strokeLinejoin: string;
3016 strokeMiterlimit: string;
3017 strokeOpacity: string;
3018 strokeWidth: string;
3020 tableLayout: string;
3022 textAlignLast: string;
3024 textCombineUpright: string;
3025 textDecoration: string;
3026 textDecorationColor: string;
3027 textDecorationLine: string;
3028 textDecorationStyle: string;
3029 textEmphasis: string;
3030 textEmphasisColor: string;
3031 textEmphasisPosition: string;
3032 textEmphasisStyle: string;
3034 textJustify: string;
3035 textOrientation: string;
3036 textOverflow: string;
3037 textRendering: string;
3039 textTransform: string;
3040 textUnderlinePosition: string;
3042 touchAction: string;
3044 transformBox: string;
3045 transformOrigin: string;
3046 transformStyle: string;
3048 transitionDelay: string;
3049 transitionDuration: string;
3050 transitionProperty: string;
3051 transitionTimingFunction: string;
3053 unicodeBidi: string;
3055 verticalAlign: string;
3058 webkitAlignContent: string;
3060 webkitAlignItems: string;
3062 webkitAlignSelf: string;
3064 webkitAnimation: string;
3066 webkitAnimationDelay: string;
3068 webkitAnimationDirection: string;
3070 webkitAnimationDuration: string;
3072 webkitAnimationFillMode: string;
3074 webkitAnimationIterationCount: string;
3076 webkitAnimationName: string;
3078 webkitAnimationPlayState: string;
3080 webkitAnimationTimingFunction: string;
3082 webkitAppearance: string;
3084 webkitBackfaceVisibility: string;
3086 webkitBackgroundClip: string;
3088 webkitBackgroundOrigin: string;
3090 webkitBackgroundSize: string;
3092 webkitBorderBottomLeftRadius: string;
3094 webkitBorderBottomRightRadius: string;
3096 webkitBorderRadius: string;
3098 webkitBorderTopLeftRadius: string;
3100 webkitBorderTopRightRadius: string;
3102 webkitBoxAlign: string;
3104 webkitBoxFlex: string;
3106 webkitBoxOrdinalGroup: string;
3108 webkitBoxOrient: string;
3110 webkitBoxPack: string;
3112 webkitBoxShadow: string;
3114 webkitBoxSizing: string;
3116 webkitFilter: string;
3120 webkitFlexBasis: string;
3122 webkitFlexDirection: string;
3124 webkitFlexFlow: string;
3126 webkitFlexGrow: string;
3128 webkitFlexShrink: string;
3130 webkitFlexWrap: string;
3132 webkitJustifyContent: string;
3133 webkitLineClamp: string;
3137 webkitMaskBoxImage: string;
3139 webkitMaskBoxImageOutset: string;
3141 webkitMaskBoxImageRepeat: string;
3143 webkitMaskBoxImageSlice: string;
3145 webkitMaskBoxImageSource: string;
3147 webkitMaskBoxImageWidth: string;
3149 webkitMaskClip: string;
3151 webkitMaskComposite: string;
3153 webkitMaskImage: string;
3155 webkitMaskOrigin: string;
3157 webkitMaskPosition: string;
3159 webkitMaskRepeat: string;
3161 webkitMaskSize: string;
3163 webkitOrder: string;
3165 webkitPerspective: string;
3167 webkitPerspectiveOrigin: string;
3168 webkitTapHighlightColor: string;
3170 webkitTextFillColor: string;
3172 webkitTextSizeAdjust: string;
3174 webkitTextStroke: string;
3176 webkitTextStrokeColor: string;
3178 webkitTextStrokeWidth: string;
3180 webkitTransform: string;
3182 webkitTransformOrigin: string;
3184 webkitTransformStyle: string;
3186 webkitTransition: string;
3188 webkitTransitionDelay: string;
3190 webkitTransitionDuration: string;
3192 webkitTransitionProperty: string;
3194 webkitTransitionTimingFunction: string;
3196 webkitUserSelect: string;
3202 wordSpacing: string;
3204 writingMode: string;
3208 getPropertyPriority(property: string): string;
3209 getPropertyValue(property: string): string;
3210 item(index: number): string;
3211 removeProperty(property: string): string;
3212 setProperty(property: string, value: string | null, priority?: string): void;
3213 [index: number]: string;
3216 declare var CSSStyleDeclaration: {
3217 prototype: CSSStyleDeclaration;
3218 new(): CSSStyleDeclaration;
3221 /** CSSStyleRule represents a single CSS style rule. It implements the CSSRule interface with a type value of 1 (CSSRule.STYLE_RULE). */
3222 interface CSSStyleRule extends CSSRule {
3223 selectorText: string;
3224 readonly style: CSSStyleDeclaration;
3227 declare var CSSStyleRule: {
3228 prototype: CSSStyleRule;
3229 new(): CSSStyleRule;
3232 /** A single CSS style sheet. It inherits properties and methods from its parent, StyleSheet. */
3233 interface CSSStyleSheet extends StyleSheet {
3234 readonly cssRules: CSSRuleList;
3235 readonly ownerRule: CSSRule | null;
3236 readonly rules: CSSRuleList;
3237 addRule(selector?: string, style?: string, index?: number): number;
3238 deleteRule(index: number): void;
3239 insertRule(rule: string, index?: number): number;
3240 removeRule(index?: number): void;
3243 declare var CSSStyleSheet: {
3244 prototype: CSSStyleSheet;
3245 new(): CSSStyleSheet;
3248 /** 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). */
3249 interface CSSSupportsRule extends CSSConditionRule {
3252 declare var CSSSupportsRule: {
3253 prototype: CSSSupportsRule;
3254 new(): CSSSupportsRule;
3257 /** 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. */
3259 add(request: RequestInfo): Promise<void>;
3260 addAll(requests: RequestInfo[]): Promise<void>;
3261 delete(request: RequestInfo, options?: CacheQueryOptions): Promise<boolean>;
3262 keys(request?: RequestInfo, options?: CacheQueryOptions): Promise<ReadonlyArray<Request>>;
3263 match(request: RequestInfo, options?: CacheQueryOptions): Promise<Response | undefined>;
3264 matchAll(request?: RequestInfo, options?: CacheQueryOptions): Promise<ReadonlyArray<Response>>;
3265 put(request: RequestInfo, response: Response): Promise<void>;
3268 declare var Cache: {
3273 /** The storage for Cache objects. */
3274 interface CacheStorage {
3275 delete(cacheName: string): Promise<boolean>;
3276 has(cacheName: string): Promise<boolean>;
3277 keys(): Promise<string[]>;
3278 match(request: RequestInfo, options?: MultiCacheQueryOptions): Promise<Response | undefined>;
3279 open(cacheName: string): Promise<Cache>;
3282 declare var CacheStorage: {
3283 prototype: CacheStorage;
3284 new(): CacheStorage;
3287 interface CanvasCompositing {
3288 globalAlpha: number;
3289 globalCompositeOperation: string;
3292 interface CanvasDrawImage {
3293 drawImage(image: CanvasImageSource, dx: number, dy: number): void;
3294 drawImage(image: CanvasImageSource, dx: number, dy: number, dw: number, dh: number): void;
3295 drawImage(image: CanvasImageSource, sx: number, sy: number, sw: number, sh: number, dx: number, dy: number, dw: number, dh: number): void;
3298 interface CanvasDrawPath {
3300 clip(fillRule?: CanvasFillRule): void;
3301 clip(path: Path2D, fillRule?: CanvasFillRule): void;
3302 fill(fillRule?: CanvasFillRule): void;
3303 fill(path: Path2D, fillRule?: CanvasFillRule): void;
3304 isPointInPath(x: number, y: number, fillRule?: CanvasFillRule): boolean;
3305 isPointInPath(path: Path2D, x: number, y: number, fillRule?: CanvasFillRule): boolean;
3306 isPointInStroke(x: number, y: number): boolean;
3307 isPointInStroke(path: Path2D, x: number, y: number): boolean;
3309 stroke(path: Path2D): void;
3312 interface CanvasFillStrokeStyles {
3313 fillStyle: string | CanvasGradient | CanvasPattern;
3314 strokeStyle: string | CanvasGradient | CanvasPattern;
3315 createLinearGradient(x0: number, y0: number, x1: number, y1: number): CanvasGradient;
3316 createPattern(image: CanvasImageSource, repetition: string | null): CanvasPattern | null;
3317 createRadialGradient(x0: number, y0: number, r0: number, x1: number, y1: number, r1: number): CanvasGradient;
3320 interface CanvasFilters {
3324 /** An opaque object describing a gradient. It is returned by the methods CanvasRenderingContext2D.createLinearGradient() or CanvasRenderingContext2D.createRadialGradient(). */
3325 interface CanvasGradient {
3327 * 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.
3329 * Throws an "IndexSizeError" DOMException if the offset is out of range. Throws a "SyntaxError" DOMException if the color cannot be parsed.
3331 addColorStop(offset: number, color: string): void;
3334 declare var CanvasGradient: {
3335 prototype: CanvasGradient;
3336 new(): CanvasGradient;
3339 interface CanvasImageData {
3340 createImageData(sw: number, sh: number): ImageData;
3341 createImageData(imagedata: ImageData): ImageData;
3342 getImageData(sx: number, sy: number, sw: number, sh: number): ImageData;
3343 putImageData(imagedata: ImageData, dx: number, dy: number): void;
3344 putImageData(imagedata: ImageData, dx: number, dy: number, dirtyX: number, dirtyY: number, dirtyWidth: number, dirtyHeight: number): void;
3347 interface CanvasImageSmoothing {
3348 imageSmoothingEnabled: boolean;
3349 imageSmoothingQuality: ImageSmoothingQuality;
3352 interface CanvasPath {
3353 arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, anticlockwise?: boolean): void;
3354 arcTo(x1: number, y1: number, x2: number, y2: number, radius: number): void;
3355 bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number): void;
3357 ellipse(x: number, y: number, radiusX: number, radiusY: number, rotation: number, startAngle: number, endAngle: number, anticlockwise?: boolean): void;
3358 lineTo(x: number, y: number): void;
3359 moveTo(x: number, y: number): void;
3360 quadraticCurveTo(cpx: number, cpy: number, x: number, y: number): void;
3361 rect(x: number, y: number, w: number, h: number): void;
3364 interface CanvasPathDrawingStyles {
3365 lineCap: CanvasLineCap;
3366 lineDashOffset: number;
3367 lineJoin: CanvasLineJoin;
3370 getLineDash(): number[];
3371 setLineDash(segments: number[]): void;
3374 /** An opaque object describing a pattern, based on an image, a canvas, or a video, created by the CanvasRenderingContext2D.createPattern() method. */
3375 interface CanvasPattern {
3377 * Sets the transformation matrix that will be used when rendering the pattern during a fill or stroke painting operation.
3379 setTransform(transform?: DOMMatrix2DInit): void;
3382 declare var CanvasPattern: {
3383 prototype: CanvasPattern;
3384 new(): CanvasPattern;
3387 interface CanvasRect {
3388 clearRect(x: number, y: number, w: number, h: number): void;
3389 fillRect(x: number, y: number, w: number, h: number): void;
3390 strokeRect(x: number, y: number, w: number, h: number): void;
3393 /** 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. */
3394 interface CanvasRenderingContext2D extends CanvasCompositing, CanvasDrawImage, CanvasDrawPath, CanvasFillStrokeStyles, CanvasFilters, CanvasImageData, CanvasImageSmoothing, CanvasPath, CanvasPathDrawingStyles, CanvasRect, CanvasShadowStyles, CanvasState, CanvasText, CanvasTextDrawingStyles, CanvasTransform, CanvasUserInterface {
3395 readonly canvas: HTMLCanvasElement;
3398 declare var CanvasRenderingContext2D: {
3399 prototype: CanvasRenderingContext2D;
3400 new(): CanvasRenderingContext2D;
3403 interface CanvasShadowStyles {
3405 shadowColor: string;
3406 shadowOffsetX: number;
3407 shadowOffsetY: number;
3410 interface CanvasState {
3415 interface CanvasText {
3416 fillText(text: string, x: number, y: number, maxWidth?: number): void;
3417 measureText(text: string): TextMetrics;
3418 strokeText(text: string, x: number, y: number, maxWidth?: number): void;
3421 interface CanvasTextDrawingStyles {
3422 direction: CanvasDirection;
3424 textAlign: CanvasTextAlign;
3425 textBaseline: CanvasTextBaseline;
3428 interface CanvasTransform {
3429 getTransform(): DOMMatrix;
3430 resetTransform(): void;
3431 rotate(angle: number): void;
3432 scale(x: number, y: number): void;
3433 setTransform(a: number, b: number, c: number, d: number, e: number, f: number): void;
3434 setTransform(transform?: DOMMatrix2DInit): void;
3435 transform(a: number, b: number, c: number, d: number, e: number, f: number): void;
3436 translate(x: number, y: number): void;
3439 interface CanvasUserInterface {
3440 drawFocusIfNeeded(element: Element): void;
3441 drawFocusIfNeeded(path: Path2D, element: Element): void;
3442 scrollPathIntoView(): void;
3443 scrollPathIntoView(path: Path2D): void;
3446 interface CaretPosition {
3447 readonly offset: number;
3448 readonly offsetNode: Node;
3449 getClientRect(): DOMRect | null;
3452 declare var CaretPosition: {
3453 prototype: CaretPosition;
3454 new(): CaretPosition;
3457 /** 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. */
3458 interface ChannelMergerNode extends AudioNode {
3461 declare var ChannelMergerNode: {
3462 prototype: ChannelMergerNode;
3463 new(context: BaseAudioContext, options?: ChannelMergerOptions): ChannelMergerNode;
3466 /** 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. */
3467 interface ChannelSplitterNode extends AudioNode {
3470 declare var ChannelSplitterNode: {
3471 prototype: ChannelSplitterNode;
3472 new(context: BaseAudioContext, options?: ChannelSplitterOptions): ChannelSplitterNode;
3475 /** 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. */
3476 interface CharacterData extends Node, ChildNode, NonDocumentTypeChildNode {
3478 readonly length: number;
3479 readonly ownerDocument: Document;
3480 appendData(data: string): void;
3481 deleteData(offset: number, count: number): void;
3482 insertData(offset: number, data: string): void;
3483 replaceData(offset: number, count: number, data: string): void;
3484 substringData(offset: number, count: number): string;
3487 declare var CharacterData: {
3488 prototype: CharacterData;
3489 new(): CharacterData;
3492 interface ChildNode extends Node {
3494 * Inserts nodes just after node, while replacing strings in nodes with equivalent Text nodes.
3496 * Throws a "HierarchyRequestError" DOMException if the constraints of the node tree are violated.
3498 after(...nodes: (Node | string)[]): void;
3500 * Inserts nodes just before node, while replacing strings in nodes with equivalent Text nodes.
3502 * Throws a "HierarchyRequestError" DOMException if the constraints of the node tree are violated.
3504 before(...nodes: (Node | string)[]): void;
3510 * Replaces node with nodes, while replacing strings in nodes with equivalent Text nodes.
3512 * Throws a "HierarchyRequestError" DOMException if the constraints of the node tree are violated.
3514 replaceWith(...nodes: (Node | string)[]): void;
3517 interface ClientRect {
3519 readonly height: number;
3523 readonly width: number;
3526 declare var ClientRect: {
3527 prototype: ClientRect;
3531 interface ClientRectList {
3532 readonly length: number;
3533 item(index: number): ClientRect;
3534 [index: number]: ClientRect;
3537 declare var ClientRectList: {
3538 prototype: ClientRectList;
3539 new(): ClientRectList;
3542 interface Clipboard extends EventTarget {
3543 readText(): Promise<string>;
3544 writeText(data: string): Promise<void>;
3547 declare var Clipboard: {
3548 prototype: Clipboard;
3552 /** Events providing information related to modification of the clipboard, that is cut, copy, and paste events. */
3553 interface ClipboardEvent extends Event {
3554 readonly clipboardData: DataTransfer | null;
3557 declare var ClipboardEvent: {
3558 prototype: ClipboardEvent;
3559 new(type: string, eventInitDict?: ClipboardEventInit): ClipboardEvent;
3562 /** 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. */
3563 interface CloseEvent extends Event {
3565 * Returns the WebSocket connection close code provided by the server.
3567 readonly code: number;
3569 * Returns the WebSocket connection close reason provided by the server.
3571 readonly reason: string;
3573 * Returns true if the connection closed cleanly; false otherwise.
3575 readonly wasClean: boolean;
3578 declare var CloseEvent: {
3579 prototype: CloseEvent;
3580 new(type: string, eventInitDict?: CloseEventInit): CloseEvent;
3583 /** Textual notations within markup; although it is generally not visually shown, such comments are available to be read in the source view. */
3584 interface Comment extends CharacterData {
3587 declare var Comment: {
3589 new(data?: string): Comment;
3592 /** The DOM CompositionEvent represents events that occur due to the user indirectly entering text. */
3593 interface CompositionEvent extends UIEvent {
3594 readonly data: string;
3597 declare var CompositionEvent: {
3598 prototype: CompositionEvent;
3599 new(type: string, eventInitDict?: CompositionEventInit): CompositionEvent;
3602 interface ConcatParams extends Algorithm {
3603 algorithmId: Uint8Array;
3604 hash?: string | Algorithm;
3605 partyUInfo: Uint8Array;
3606 partyVInfo: Uint8Array;
3607 privateInfo?: Uint8Array;
3608 publicInfo?: Uint8Array;
3611 interface ConstantSourceNode extends AudioScheduledSourceNode {
3612 readonly offset: AudioParam;
3613 addEventListener<K extends keyof AudioScheduledSourceNodeEventMap>(type: K, listener: (this: ConstantSourceNode, ev: AudioScheduledSourceNodeEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
3614 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
3615 removeEventListener<K extends keyof AudioScheduledSourceNodeEventMap>(type: K, listener: (this: ConstantSourceNode, ev: AudioScheduledSourceNodeEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
3616 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
3619 declare var ConstantSourceNode: {
3620 prototype: ConstantSourceNode;
3621 new(context: BaseAudioContext, options?: ConstantSourceOptions): ConstantSourceNode;
3624 /** 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. */
3625 interface ConvolverNode extends AudioNode {
3626 buffer: AudioBuffer | null;
3630 declare var ConvolverNode: {
3631 prototype: ConvolverNode;
3632 new(context: BaseAudioContext, options?: ConvolverOptions): ConvolverNode;
3635 /** This Streams API interface provides a built-in byte length queuing strategy that can be used when constructing streams. */
3636 interface CountQueuingStrategy extends QueuingStrategy {
3637 highWaterMark: number;
3638 size(chunk: any): 1;
3641 declare var CountQueuingStrategy: {
3642 prototype: CountQueuingStrategy;
3643 new(options: { highWaterMark: number }): CountQueuingStrategy;
3646 interface Credential {
3647 readonly id: string;
3648 readonly type: string;
3651 declare var Credential: {
3652 prototype: Credential;
3656 interface CredentialsContainer {
3657 create(options?: CredentialCreationOptions): Promise<Credential | null>;
3658 get(options?: CredentialRequestOptions): Promise<Credential | null>;
3659 preventSilentAccess(): Promise<void>;
3660 store(credential: Credential): Promise<Credential>;
3663 declare var CredentialsContainer: {
3664 prototype: CredentialsContainer;
3665 new(): CredentialsContainer;
3668 /** Basic cryptography features available in the current context. It allows access to a cryptographically strong random number generator and to cryptographic primitives. */
3670 readonly subtle: SubtleCrypto;
3671 getRandomValues<T extends Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | null>(array: T): T;
3674 declare var Crypto: {
3679 /** The CryptoKey dictionary of the Web Crypto API represents a cryptographic key. */
3680 interface CryptoKey {
3681 readonly algorithm: KeyAlgorithm;
3682 readonly extractable: boolean;
3683 readonly type: KeyType;
3684 readonly usages: KeyUsage[];
3687 declare var CryptoKey: {
3688 prototype: CryptoKey;
3692 /** The CryptoKeyPair dictionary of the Web Crypto API represents a key pair for an asymmetric cryptography algorithm, also known as a public-key algorithm. */
3693 interface CryptoKeyPair {
3694 privateKey: CryptoKey;
3695 publicKey: CryptoKey;
3698 declare var CryptoKeyPair: {
3699 prototype: CryptoKeyPair;
3700 new(): CryptoKeyPair;
3703 interface CustomElementRegistry {
3704 define(name: string, constructor: CustomElementConstructor, options?: ElementDefinitionOptions): void;
3705 get(name: string): any;
3706 upgrade(root: Node): void;
3707 whenDefined(name: string): Promise<void>;
3710 declare var CustomElementRegistry: {
3711 prototype: CustomElementRegistry;
3712 new(): CustomElementRegistry;
3715 interface CustomEvent<T = any> extends Event {
3717 * Returns any custom data event was created with. Typically used for synthetic events.
3720 initCustomEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, detailArg: T): void;
3723 declare var CustomEvent: {
3724 prototype: CustomEvent;
3725 new<T>(typeArg: string, eventInitDict?: CustomEventInit<T>): CustomEvent<T>;
3728 /** An error object that contains an error name. */
3729 interface DOMError {
3730 readonly name: string;
3734 declare var DOMError: {
3735 prototype: DOMError;
3739 /** An abnormal event (called an exception) which occurs as a result of calling a method or accessing a property of a web API. */
3740 interface DOMException {
3741 readonly code: number;
3742 readonly message: string;
3743 readonly name: string;
3744 readonly ABORT_ERR: number;
3745 readonly DATA_CLONE_ERR: number;
3746 readonly DOMSTRING_SIZE_ERR: number;
3747 readonly HIERARCHY_REQUEST_ERR: number;
3748 readonly INDEX_SIZE_ERR: number;
3749 readonly INUSE_ATTRIBUTE_ERR: number;
3750 readonly INVALID_ACCESS_ERR: number;
3751 readonly INVALID_CHARACTER_ERR: number;
3752 readonly INVALID_MODIFICATION_ERR: number;
3753 readonly INVALID_NODE_TYPE_ERR: number;
3754 readonly INVALID_STATE_ERR: number;
3755 readonly NAMESPACE_ERR: number;
3756 readonly NETWORK_ERR: number;
3757 readonly NOT_FOUND_ERR: number;
3758 readonly NOT_SUPPORTED_ERR: number;
3759 readonly NO_DATA_ALLOWED_ERR: number;
3760 readonly NO_MODIFICATION_ALLOWED_ERR: number;
3761 readonly QUOTA_EXCEEDED_ERR: number;
3762 readonly SECURITY_ERR: number;
3763 readonly SYNTAX_ERR: number;
3764 readonly TIMEOUT_ERR: number;
3765 readonly TYPE_MISMATCH_ERR: number;
3766 readonly URL_MISMATCH_ERR: number;
3767 readonly VALIDATION_ERR: number;
3768 readonly WRONG_DOCUMENT_ERR: number;
3771 declare var DOMException: {
3772 prototype: DOMException;
3773 new(message?: string, name?: string): DOMException;
3774 readonly ABORT_ERR: number;
3775 readonly DATA_CLONE_ERR: number;
3776 readonly DOMSTRING_SIZE_ERR: number;
3777 readonly HIERARCHY_REQUEST_ERR: number;
3778 readonly INDEX_SIZE_ERR: number;
3779 readonly INUSE_ATTRIBUTE_ERR: number;
3780 readonly INVALID_ACCESS_ERR: number;
3781 readonly INVALID_CHARACTER_ERR: number;
3782 readonly INVALID_MODIFICATION_ERR: number;
3783 readonly INVALID_NODE_TYPE_ERR: number;
3784 readonly INVALID_STATE_ERR: number;
3785 readonly NAMESPACE_ERR: number;
3786 readonly NETWORK_ERR: number;
3787 readonly NOT_FOUND_ERR: number;
3788 readonly NOT_SUPPORTED_ERR: number;
3789 readonly NO_DATA_ALLOWED_ERR: number;
3790 readonly NO_MODIFICATION_ALLOWED_ERR: number;
3791 readonly QUOTA_EXCEEDED_ERR: number;
3792 readonly SECURITY_ERR: number;
3793 readonly SYNTAX_ERR: number;
3794 readonly TIMEOUT_ERR: number;
3795 readonly TYPE_MISMATCH_ERR: number;
3796 readonly URL_MISMATCH_ERR: number;
3797 readonly VALIDATION_ERR: number;
3798 readonly WRONG_DOCUMENT_ERR: number;
3801 /** An object providing methods which are not dependent on any particular document. Such an object is returned by the Document.implementation property. */
3802 interface DOMImplementation {
3803 createDocument(namespace: string | null, qualifiedName: string | null, doctype?: DocumentType | null): XMLDocument;
3804 createDocumentType(qualifiedName: string, publicId: string, systemId: string): DocumentType;
3805 createHTMLDocument(title?: string): Document;
3807 hasFeature(...args: any[]): true;
3810 declare var DOMImplementation: {
3811 prototype: DOMImplementation;
3812 new(): DOMImplementation;
3815 interface DOML2DeprecatedColorProperty {
3819 interface DOMMatrix extends DOMMatrixReadOnly {
3842 invertSelf(): DOMMatrix;
3843 multiplySelf(other?: DOMMatrixInit): DOMMatrix;
3844 preMultiplySelf(other?: DOMMatrixInit): DOMMatrix;
3845 rotateAxisAngleSelf(x?: number, y?: number, z?: number, angle?: number): DOMMatrix;
3846 rotateFromVectorSelf(x?: number, y?: number): DOMMatrix;
3847 rotateSelf(rotX?: number, rotY?: number, rotZ?: number): DOMMatrix;
3848 scale3dSelf(scale?: number, originX?: number, originY?: number, originZ?: number): DOMMatrix;
3849 scaleSelf(scaleX?: number, scaleY?: number, scaleZ?: number, originX?: number, originY?: number, originZ?: number): DOMMatrix;
3850 setMatrixValue(transformList: string): DOMMatrix;
3851 skewXSelf(sx?: number): DOMMatrix;
3852 skewYSelf(sy?: number): DOMMatrix;
3853 translateSelf(tx?: number, ty?: number, tz?: number): DOMMatrix;
3856 declare var DOMMatrix: {
3857 prototype: DOMMatrix;
3858 new(init?: string | number[]): DOMMatrix;
3859 fromFloat32Array(array32: Float32Array): DOMMatrix;
3860 fromFloat64Array(array64: Float64Array): DOMMatrix;
3861 fromMatrix(other?: DOMMatrixInit): DOMMatrix;
3864 type SVGMatrix = DOMMatrix;
3865 declare var SVGMatrix: typeof DOMMatrix;
3867 type WebKitCSSMatrix = DOMMatrix;
3868 declare var WebKitCSSMatrix: typeof DOMMatrix;
3870 interface DOMMatrixReadOnly {
3877 readonly is2D: boolean;
3878 readonly isIdentity: boolean;
3879 readonly m11: number;
3880 readonly m12: number;
3881 readonly m13: number;
3882 readonly m14: number;
3883 readonly m21: number;
3884 readonly m22: number;
3885 readonly m23: number;
3886 readonly m24: number;
3887 readonly m31: number;
3888 readonly m32: number;
3889 readonly m33: number;
3890 readonly m34: number;
3891 readonly m41: number;
3892 readonly m42: number;
3893 readonly m43: number;
3894 readonly m44: number;
3897 inverse(): DOMMatrix;
3898 multiply(other?: DOMMatrixInit): DOMMatrix;
3899 rotate(rotX?: number, rotY?: number, rotZ?: number): DOMMatrix;
3900 rotateAxisAngle(x?: number, y?: number, z?: number, angle?: number): DOMMatrix;
3901 rotateFromVector(x?: number, y?: number): DOMMatrix;
3902 scale(scaleX?: number, scaleY?: number, scaleZ?: number, originX?: number, originY?: number, originZ?: number): DOMMatrix;
3903 scale3d(scale?: number, originX?: number, originY?: number, originZ?: number): DOMMatrix;
3905 scaleNonUniform(scaleX?: number, scaleY?: number): DOMMatrix;
3906 skewX(sx?: number): DOMMatrix;
3907 skewY(sy?: number): DOMMatrix;
3908 toFloat32Array(): Float32Array;
3909 toFloat64Array(): Float64Array;
3911 transformPoint(point?: DOMPointInit): DOMPoint;
3912 translate(tx?: number, ty?: number, tz?: number): DOMMatrix;
3916 declare var DOMMatrixReadOnly: {
3917 prototype: DOMMatrixReadOnly;
3918 new(init?: string | number[]): DOMMatrixReadOnly;
3919 fromFloat32Array(array32: Float32Array): DOMMatrixReadOnly;
3920 fromFloat64Array(array64: Float64Array): DOMMatrixReadOnly;
3921 fromMatrix(other?: DOMMatrixInit): DOMMatrixReadOnly;
3925 /** Provides the ability to parse XML or HTML source code from a string into a DOM Document. */
3926 interface DOMParser {
3928 * Parses string using either the HTML or XML parser, according to type, and returns the resulting Document. type can be "text/html" (which will invoke the HTML parser), or any of "text/xml", "application/xml", "application/xhtml+xml", or "image/svg+xml" (which will invoke the XML parser).
3930 * For the XML parser, if string cannot be parsed, then the returned Document will contain elements describing the resulting error.
3932 * Note that script elements are not evaluated during parsing, and the resulting document's encoding will always be UTF-8.
3934 * Values other than the above for type will cause a TypeError exception to be thrown.
3936 parseFromString(string: string, type: DOMParserSupportedType): Document;
3939 declare var DOMParser: {
3940 prototype: DOMParser;
3944 interface DOMPoint extends DOMPointReadOnly {
3951 declare var DOMPoint: {
3952 prototype: DOMPoint;
3953 new(x?: number, y?: number, z?: number, w?: number): DOMPoint;
3954 fromPoint(other?: DOMPointInit): DOMPoint;
3957 type SVGPoint = DOMPoint;
3958 declare var SVGPoint: typeof DOMPoint;
3960 interface DOMPointReadOnly {
3965 matrixTransform(matrix?: DOMMatrixInit): DOMPoint;
3969 declare var DOMPointReadOnly: {
3970 prototype: DOMPointReadOnly;
3971 new(x?: number, y?: number, z?: number, w?: number): DOMPointReadOnly;
3972 fromPoint(other?: DOMPointInit): DOMPointReadOnly;
3976 readonly p1: DOMPoint;
3977 readonly p2: DOMPoint;
3978 readonly p3: DOMPoint;
3979 readonly p4: DOMPoint;
3980 getBounds(): DOMRect;
3984 declare var DOMQuad: {
3986 new(p1?: DOMPointInit, p2?: DOMPointInit, p3?: DOMPointInit, p4?: DOMPointInit): DOMQuad;
3987 fromQuad(other?: DOMQuadInit): DOMQuad;
3988 fromRect(other?: DOMRectInit): DOMQuad;
3991 interface DOMRect extends DOMRectReadOnly {
3998 declare var DOMRect: {
4000 new(x?: number, y?: number, width?: number, height?: number): DOMRect;
4001 fromRect(other?: DOMRectInit): DOMRect;
4004 type SVGRect = DOMRect;
4005 declare var SVGRect: typeof DOMRect;
4007 interface DOMRectList {
4008 readonly length: number;
4009 item(index: number): DOMRect | null;
4010 [index: number]: DOMRect;
4013 declare var DOMRectList: {
4014 prototype: DOMRectList;
4018 interface DOMRectReadOnly {
4019 readonly bottom: number;
4020 readonly height: number;
4021 readonly left: number;
4022 readonly right: number;
4023 readonly top: number;
4024 readonly width: number;
4030 declare var DOMRectReadOnly: {
4031 prototype: DOMRectReadOnly;
4032 new(x?: number, y?: number, width?: number, height?: number): DOMRectReadOnly;
4033 fromRect(other?: DOMRectInit): DOMRectReadOnly;
4036 interface DOMSettableTokenList extends DOMTokenList {
4040 declare var DOMSettableTokenList: {
4041 prototype: DOMSettableTokenList;
4042 new(): DOMSettableTokenList;
4045 /** A type returned by some APIs which contains a list of DOMString (strings). */
4046 interface DOMStringList {
4048 * Returns the number of strings in strings.
4050 readonly length: number;
4052 * Returns true if strings contains string, and false otherwise.
4054 contains(string: string): boolean;
4056 * Returns the string with index index from strings.
4058 item(index: number): string | null;
4059 [index: number]: string;
4062 declare var DOMStringList: {
4063 prototype: DOMStringList;
4064 new(): DOMStringList;
4067 /** Used by the dataset HTML attribute to represent data for custom attributes added to elements. */
4068 interface DOMStringMap {
4069 [name: string]: string | undefined;
4072 declare var DOMStringMap: {
4073 prototype: DOMStringMap;
4074 new(): DOMStringMap;
4077 /** 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. */
4078 interface DOMTokenList {
4080 * Returns the number of tokens.
4082 readonly length: number;
4084 * Returns the associated set as string.
4086 * Can be set, to change the associated attribute.
4091 * Adds all arguments passed, except those already present.
4093 * Throws a "SyntaxError" DOMException if one of the arguments is the empty string.
4095 * Throws an "InvalidCharacterError" DOMException if one of the arguments contains any ASCII whitespace.
4097 add(...tokens: string[]): void;
4099 * Returns true if token is present, and false otherwise.
4101 contains(token: string): boolean;
4103 * Returns the token with index index.
4105 item(index: number): string | null;
4107 * Removes arguments passed, if they are present.
4109 * Throws a "SyntaxError" DOMException if one of the arguments is the empty string.
4111 * Throws an "InvalidCharacterError" DOMException if one of the arguments contains any ASCII whitespace.
4113 remove(...tokens: string[]): void;
4115 * Replaces token with newToken.
4117 * Returns true if token was replaced with newToken, and false otherwise.
4119 * Throws a "SyntaxError" DOMException if one of the arguments is the empty string.
4121 * Throws an "InvalidCharacterError" DOMException if one of the arguments contains any ASCII whitespace.
4123 replace(oldToken: string, newToken: string): void;
4125 * Returns true if token is in the associated attribute's supported tokens. Returns false otherwise.
4127 * Throws a TypeError if the associated attribute has no supported tokens defined.
4129 supports(token: string): boolean;
4131 * 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()).
4133 * Returns true if token is now present, and false otherwise.
4135 * Throws a "SyntaxError" DOMException if token is empty.
4137 * Throws an "InvalidCharacterError" DOMException if token contains any spaces.
4139 toggle(token: string, force?: boolean): boolean;
4140 forEach(callbackfn: (value: string, key: number, parent: DOMTokenList) => void, thisArg?: any): void;
4141 [index: number]: string;
4144 declare var DOMTokenList: {
4145 prototype: DOMTokenList;
4146 new(): DOMTokenList;
4149 interface DataCue extends TextTrackCue {
4151 addEventListener<K extends keyof TextTrackCueEventMap>(type: K, listener: (this: DataCue, ev: TextTrackCueEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
4152 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
4153 removeEventListener<K extends keyof TextTrackCueEventMap>(type: K, listener: (this: DataCue, ev: TextTrackCueEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
4154 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
4157 declare var DataCue: {
4162 /** 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. */
4163 interface DataTransfer {
4165 * 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.
4167 * Can be set, to change the selected operation.
4169 * The possible values are "none", "copy", "link", and "move".
4171 dropEffect: "none" | "copy" | "link" | "move";
4173 * Returns the kinds of operations that are to be allowed.
4175 * Can be set (during the dragstart event), to change the allowed operations.
4177 * The possible values are "none", "copy", "copyLink", "copyMove", "link", "linkMove", "move", "all", and "uninitialized",
4179 effectAllowed: "none" | "copy" | "copyLink" | "copyMove" | "link" | "linkMove" | "move" | "all" | "uninitialized";
4181 * Returns a FileList of the files being dragged, if any.
4183 readonly files: FileList;
4185 * Returns a DataTransferItemList object, with the drag data.
4187 readonly items: DataTransferItemList;
4189 * 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".
4191 readonly types: ReadonlyArray<string>;
4193 * Removes the data of the specified formats. Removes all data if the argument is omitted.
4195 clearData(format?: string): void;
4197 * Returns the specified data. If there is no such data, returns the empty string.
4199 getData(format: string): string;
4201 * Adds the specified data.
4203 setData(format: string, data: string): void;
4205 * Uses the given element to update the drag feedback, replacing any previously specified feedback.
4207 setDragImage(image: Element, x: number, y: number): void;
4210 declare var DataTransfer: {
4211 prototype: DataTransfer;
4212 new(): DataTransfer;
4215 /** 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. */
4216 interface DataTransferItem {
4218 * Returns the drag data item kind, one of: "string", "file".
4220 readonly kind: string;
4222 * Returns the drag data item type string.
4224 readonly type: string;
4226 * Returns a File object, if the drag data item kind is File.
4228 getAsFile(): File | null;
4230 * Invokes the callback with the string data as the argument, if the drag data item kind is text.
4232 getAsString(callback: FunctionStringCallback | null): void;
4233 webkitGetAsEntry(): any;
4236 declare var DataTransferItem: {
4237 prototype: DataTransferItem;
4238 new(): DataTransferItem;
4241 /** 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. */
4242 interface DataTransferItemList {
4244 * Returns the number of items in the drag data store.
4246 readonly length: number;
4248 * 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.
4250 add(data: string, type: string): DataTransferItem | null;
4251 add(data: File): DataTransferItem | null;
4253 * Removes all the entries in the drag data store.
4256 item(index: number): DataTransferItem;
4258 * Removes the indexth entry in the drag data store.
4260 remove(index: number): void;
4261 [name: number]: DataTransferItem;
4264 declare var DataTransferItemList: {
4265 prototype: DataTransferItemList;
4266 new(): DataTransferItemList;
4269 interface DeferredPermissionRequest {
4270 readonly id: number;
4271 readonly type: MSWebViewPermissionType;
4272 readonly uri: string;
4277 declare var DeferredPermissionRequest: {
4278 prototype: DeferredPermissionRequest;
4279 new(): DeferredPermissionRequest;
4282 /** 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. */
4283 interface DelayNode extends AudioNode {
4284 readonly delayTime: AudioParam;
4287 declare var DelayNode: {
4288 prototype: DelayNode;
4289 new(context: BaseAudioContext, options?: DelayOptions): DelayNode;
4292 /** Provides information about the amount of acceleration the device is experiencing along all three axes. */
4293 interface DeviceAcceleration {
4294 readonly x: number | null;
4295 readonly y: number | null;
4296 readonly z: number | null;
4299 declare var DeviceAcceleration: {
4300 prototype: DeviceAcceleration;
4301 new(): DeviceAcceleration;
4304 /** 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. */
4305 interface DeviceLightEvent extends Event {
4306 readonly value: number;
4309 declare var DeviceLightEvent: {
4310 prototype: DeviceLightEvent;
4311 new(typeArg: string, eventInitDict?: DeviceLightEventInit): DeviceLightEvent;
4314 /** The DeviceMotionEvent provides web developers with information about the speed of changes for the device's position and orientation. */
4315 interface DeviceMotionEvent extends Event {
4316 readonly acceleration: DeviceMotionEventAcceleration | null;
4317 readonly accelerationIncludingGravity: DeviceMotionEventAcceleration | null;
4318 readonly interval: number;
4319 readonly rotationRate: DeviceMotionEventRotationRate | null;
4322 declare var DeviceMotionEvent: {
4323 prototype: DeviceMotionEvent;
4324 new(type: string, eventInitDict?: DeviceMotionEventInit): DeviceMotionEvent;
4325 requestPermission(): Promise<PermissionState>;
4328 interface DeviceMotionEventAcceleration {
4329 readonly x: number | null;
4330 readonly y: number | null;
4331 readonly z: number | null;
4334 interface DeviceMotionEventRotationRate {
4335 readonly alpha: number | null;
4336 readonly beta: number | null;
4337 readonly gamma: number | null;
4340 /** The DeviceOrientationEvent provides web developers with information from the physical orientation of the device running the web page. */
4341 interface DeviceOrientationEvent extends Event {
4342 readonly absolute: boolean;
4343 readonly alpha: number | null;
4344 readonly beta: number | null;
4345 readonly gamma: number | null;
4348 declare var DeviceOrientationEvent: {
4349 prototype: DeviceOrientationEvent;
4350 new(type: string, eventInitDict?: DeviceOrientationEventInit): DeviceOrientationEvent;
4351 requestPermission(): Promise<PermissionState>;
4354 /** Provides information about the rate at which the device is rotating around all three axes. */
4355 interface DeviceRotationRate {
4356 readonly alpha: number | null;
4357 readonly beta: number | null;
4358 readonly gamma: number | null;
4361 declare var DeviceRotationRate: {
4362 prototype: DeviceRotationRate;
4363 new(): DeviceRotationRate;
4366 interface DhImportKeyParams extends Algorithm {
4367 generator: Uint8Array;
4371 interface DhKeyAlgorithm extends KeyAlgorithm {
4372 generator: Uint8Array;
4376 interface DhKeyDeriveParams extends Algorithm {
4380 interface DhKeyGenParams extends Algorithm {
4381 generator: Uint8Array;
4385 interface DocumentEventMap extends GlobalEventHandlersEventMap, DocumentAndElementEventHandlersEventMap {
4386 "fullscreenchange": Event;
4387 "fullscreenerror": Event;
4388 "pointerlockchange": Event;
4389 "pointerlockerror": Event;
4390 "readystatechange": Event;
4391 "visibilitychange": Event;
4394 /** Any web page loaded in the browser and serves as an entry point into the web page's content, which is the DOM tree. */
4395 interface Document extends Node, DocumentAndElementEventHandlers, DocumentOrShadowRoot, GlobalEventHandlers, NonElementParentNode, ParentNode, XPathEvaluatorBase {
4397 * Sets or gets the URL for the current document.
4399 readonly URL: string;
4401 * Sets or gets the color of all active links in the document.
4406 * Returns a reference to the collection of elements contained by the object.
4409 readonly all: HTMLAllCollection;
4411 * Retrieves a collection of all a objects that have a name and/or id property. Objects in this collection are in HTML source order.
4414 readonly anchors: HTMLCollectionOf<HTMLAnchorElement>;
4416 * Retrieves a collection of all applet objects in the document.
4419 readonly applets: HTMLCollectionOf<HTMLAppletElement>;
4421 * Deprecated. Sets or retrieves a value that indicates the background color behind the object.
4426 * Specifies the beginning and end of the document body.
4430 * Returns document's encoding.
4432 readonly characterSet: string;
4434 * Gets or sets the character set used to encode the object.
4436 readonly charset: string;
4438 * Gets a value that indicates whether standards-compliant mode is switched on for the object.
4440 readonly compatMode: string;
4442 * Returns document's content type.
4444 readonly contentType: string;
4446 * 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.
4448 * Can be set, to add a new cookie to the element's set of HTTP cookies.
4450 * 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.
4454 * 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.
4456 * 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.
4458 readonly currentScript: HTMLOrSVGScriptElement | null;
4459 readonly defaultView: (WindowProxy & typeof globalThis) | null;
4461 * Sets or gets a value that indicates whether the document can be edited.
4465 * Sets or retrieves a value that indicates the reading order of the object.
4469 * Gets an object representing the document type declaration associated with the current document.
4471 readonly doctype: DocumentType | null;
4473 * Gets a reference to the root node of the document.
4475 readonly documentElement: HTMLElement;
4477 * Returns document's URL.
4479 readonly documentURI: string;
4481 * Sets or gets the security domain of the document.
4485 * Retrieves a collection of all embed objects in the document.
4487 readonly embeds: HTMLCollectionOf<HTMLEmbedElement>;
4489 * Sets or gets the foreground (text) color of the document.
4494 * Retrieves a collection, in source order, of all form objects in the document.
4496 readonly forms: HTMLCollectionOf<HTMLFormElement>;
4498 readonly fullscreen: boolean;
4500 * Returns true if document has the ability to display elements fullscreen and fullscreen is supported, or false otherwise.
4502 readonly fullscreenEnabled: boolean;
4504 * Returns the head element.
4506 readonly head: HTMLHeadElement;
4507 readonly hidden: boolean;
4509 * Retrieves a collection, in source order, of img objects in the document.
4511 readonly images: HTMLCollectionOf<HTMLImageElement>;
4513 * Gets the implementation object of the current document.
4515 readonly implementation: DOMImplementation;
4517 * Returns the character encoding used to create the webpage that is loaded into the document object.
4519 readonly inputEncoding: string;
4521 * Gets the date that the page was last modified, if the page supplies one.
4523 readonly lastModified: string;
4525 * Sets or gets the color of the document links.
4530 * Retrieves a collection of all a objects that specify the href property and all area objects in the document.
4532 readonly links: HTMLCollectionOf<HTMLAnchorElement | HTMLAreaElement>;
4534 * Contains information about the current URL.
4537 onfullscreenchange: ((this: Document, ev: Event) => any) | null;
4538 onfullscreenerror: ((this: Document, ev: Event) => any) | null;
4539 onpointerlockchange: ((this: Document, ev: Event) => any) | null;
4540 onpointerlockerror: ((this: Document, ev: Event) => any) | null;
4542 * Fires when the state of the object has changed.
4543 * @param ev The event
4545 onreadystatechange: ((this: Document, ev: Event) => any) | null;
4546 onvisibilitychange: ((this: Document, ev: Event) => any) | null;
4547 readonly ownerDocument: null;
4549 * Return an HTMLCollection of the embed elements in the Document.
4551 readonly plugins: HTMLCollectionOf<HTMLEmbedElement>;
4553 * Retrieves a value that indicates the current state of the object.
4555 readonly readyState: DocumentReadyState;
4557 * Gets the URL of the location that referred the user to the current page.
4559 readonly referrer: string;
4561 * Retrieves a collection of all script objects in the document.
4563 readonly scripts: HTMLCollectionOf<HTMLScriptElement>;
4564 readonly scrollingElement: Element | null;
4565 readonly timeline: DocumentTimeline;
4567 * Contains the title of the document.
4570 readonly visibilityState: VisibilityState;
4572 * Sets or gets the color of the links that the user has visited.
4577 * Moves node from another document and returns it.
4579 * If node is a document, throws a "NotSupportedError" DOMException or, if node is a shadow root, throws a "HierarchyRequestError" DOMException.
4581 adoptNode<T extends Node>(source: T): T;
4583 captureEvents(): void;
4584 caretPositionFromPoint(x: number, y: number): CaretPosition | null;
4586 caretRangeFromPoint(x: number, y: number): Range;
4590 * Closes an output stream and forces the sent data to display.
4594 * Creates an attribute object with a specified name.
4595 * @param name String that sets the attribute object's name.
4597 createAttribute(localName: string): Attr;
4598 createAttributeNS(namespace: string | null, qualifiedName: string): Attr;
4600 * Returns a CDATASection node whose data is data.
4602 createCDATASection(data: string): CDATASection;
4604 * Creates a comment object with the specified data.
4605 * @param data Sets the comment object's data.
4607 createComment(data: string): Comment;
4609 * Creates a new document.
4611 createDocumentFragment(): DocumentFragment;
4613 * Creates an instance of the element for the specified tag.
4614 * @param tagName The name of an element.
4616 createElement<K extends keyof HTMLElementTagNameMap>(tagName: K, options?: ElementCreationOptions): HTMLElementTagNameMap[K];
4618 createElement<K extends keyof HTMLElementDeprecatedTagNameMap>(tagName: K, options?: ElementCreationOptions): HTMLElementDeprecatedTagNameMap[K];
4619 createElement(tagName: string, options?: ElementCreationOptions): HTMLElement;
4621 * 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.
4623 * If localName does not match the Name production an "InvalidCharacterError" DOMException will be thrown.
4625 * If one of the following conditions is true a "NamespaceError" DOMException will be thrown:
4627 * localName does not match the QName production.
4628 * Namespace prefix is not null and namespace is the empty string.
4629 * Namespace prefix is "xml" and namespace is not the XML namespace.
4630 * qualifiedName or namespace prefix is "xmlns" and namespace is not the XMLNS namespace.
4631 * namespace is the XMLNS namespace and neither qualifiedName nor namespace prefix is "xmlns".
4633 * When supplied, options's is can be used to create a customized built-in element.
4635 createElementNS(namespaceURI: "http://www.w3.org/1999/xhtml", qualifiedName: string): HTMLElement;
4636 createElementNS<K extends keyof SVGElementTagNameMap>(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: K): SVGElementTagNameMap[K];
4637 createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: string): SVGElement;
4638 createElementNS(namespaceURI: string | null, qualifiedName: string, options?: ElementCreationOptions): Element;
4639 createElementNS(namespace: string | null, qualifiedName: string, options?: string | ElementCreationOptions): Element;
4640 createEvent(eventInterface: "AnimationEvent"): AnimationEvent;
4641 createEvent(eventInterface: "AnimationPlaybackEvent"): AnimationPlaybackEvent;
4642 createEvent(eventInterface: "AudioProcessingEvent"): AudioProcessingEvent;
4643 createEvent(eventInterface: "BeforeUnloadEvent"): BeforeUnloadEvent;
4644 createEvent(eventInterface: "ClipboardEvent"): ClipboardEvent;
4645 createEvent(eventInterface: "CloseEvent"): CloseEvent;
4646 createEvent(eventInterface: "CompositionEvent"): CompositionEvent;
4647 createEvent(eventInterface: "CustomEvent"): CustomEvent;
4648 createEvent(eventInterface: "DeviceLightEvent"): DeviceLightEvent;
4649 createEvent(eventInterface: "DeviceMotionEvent"): DeviceMotionEvent;
4650 createEvent(eventInterface: "DeviceOrientationEvent"): DeviceOrientationEvent;
4651 createEvent(eventInterface: "DragEvent"): DragEvent;
4652 createEvent(eventInterface: "ErrorEvent"): ErrorEvent;
4653 createEvent(eventInterface: "Event"): Event;
4654 createEvent(eventInterface: "Events"): Event;
4655 createEvent(eventInterface: "FocusEvent"): FocusEvent;
4656 createEvent(eventInterface: "FocusNavigationEvent"): FocusNavigationEvent;
4657 createEvent(eventInterface: "GamepadEvent"): GamepadEvent;
4658 createEvent(eventInterface: "HashChangeEvent"): HashChangeEvent;
4659 createEvent(eventInterface: "IDBVersionChangeEvent"): IDBVersionChangeEvent;
4660 createEvent(eventInterface: "InputEvent"): InputEvent;
4661 createEvent(eventInterface: "KeyboardEvent"): KeyboardEvent;
4662 createEvent(eventInterface: "ListeningStateChangedEvent"): ListeningStateChangedEvent;
4663 createEvent(eventInterface: "MSGestureEvent"): MSGestureEvent;
4664 createEvent(eventInterface: "MSMediaKeyMessageEvent"): MSMediaKeyMessageEvent;
4665 createEvent(eventInterface: "MSMediaKeyNeededEvent"): MSMediaKeyNeededEvent;
4666 createEvent(eventInterface: "MSPointerEvent"): MSPointerEvent;
4667 createEvent(eventInterface: "MediaEncryptedEvent"): MediaEncryptedEvent;
4668 createEvent(eventInterface: "MediaKeyMessageEvent"): MediaKeyMessageEvent;
4669 createEvent(eventInterface: "MediaQueryListEvent"): MediaQueryListEvent;
4670 createEvent(eventInterface: "MediaStreamErrorEvent"): MediaStreamErrorEvent;
4671 createEvent(eventInterface: "MediaStreamEvent"): MediaStreamEvent;
4672 createEvent(eventInterface: "MediaStreamTrackEvent"): MediaStreamTrackEvent;
4673 createEvent(eventInterface: "MessageEvent"): MessageEvent;
4674 createEvent(eventInterface: "MouseEvent"): MouseEvent;
4675 createEvent(eventInterface: "MouseEvents"): MouseEvent;
4676 createEvent(eventInterface: "MutationEvent"): MutationEvent;
4677 createEvent(eventInterface: "MutationEvents"): MutationEvent;
4678 createEvent(eventInterface: "OfflineAudioCompletionEvent"): OfflineAudioCompletionEvent;
4679 createEvent(eventInterface: "OverflowEvent"): OverflowEvent;
4680 createEvent(eventInterface: "PageTransitionEvent"): PageTransitionEvent;
4681 createEvent(eventInterface: "PaymentRequestUpdateEvent"): PaymentRequestUpdateEvent;
4682 createEvent(eventInterface: "PermissionRequestedEvent"): PermissionRequestedEvent;
4683 createEvent(eventInterface: "PointerEvent"): PointerEvent;
4684 createEvent(eventInterface: "PopStateEvent"): PopStateEvent;
4685 createEvent(eventInterface: "ProgressEvent"): ProgressEvent;
4686 createEvent(eventInterface: "PromiseRejectionEvent"): PromiseRejectionEvent;
4687 createEvent(eventInterface: "RTCDTMFToneChangeEvent"): RTCDTMFToneChangeEvent;
4688 createEvent(eventInterface: "RTCDataChannelEvent"): RTCDataChannelEvent;
4689 createEvent(eventInterface: "RTCDtlsTransportStateChangedEvent"): RTCDtlsTransportStateChangedEvent;
4690 createEvent(eventInterface: "RTCErrorEvent"): RTCErrorEvent;
4691 createEvent(eventInterface: "RTCIceCandidatePairChangedEvent"): RTCIceCandidatePairChangedEvent;
4692 createEvent(eventInterface: "RTCIceGathererEvent"): RTCIceGathererEvent;
4693 createEvent(eventInterface: "RTCIceTransportStateChangedEvent"): RTCIceTransportStateChangedEvent;
4694 createEvent(eventInterface: "RTCPeerConnectionIceErrorEvent"): RTCPeerConnectionIceErrorEvent;
4695 createEvent(eventInterface: "RTCPeerConnectionIceEvent"): RTCPeerConnectionIceEvent;
4696 createEvent(eventInterface: "RTCSsrcConflictEvent"): RTCSsrcConflictEvent;
4697 createEvent(eventInterface: "RTCStatsEvent"): RTCStatsEvent;
4698 createEvent(eventInterface: "RTCTrackEvent"): RTCTrackEvent;
4699 createEvent(eventInterface: "SVGZoomEvent"): SVGZoomEvent;
4700 createEvent(eventInterface: "SVGZoomEvents"): SVGZoomEvent;
4701 createEvent(eventInterface: "SecurityPolicyViolationEvent"): SecurityPolicyViolationEvent;
4702 createEvent(eventInterface: "ServiceWorkerMessageEvent"): ServiceWorkerMessageEvent;
4703 createEvent(eventInterface: "SpeechRecognitionEvent"): SpeechRecognitionEvent;
4704 createEvent(eventInterface: "SpeechSynthesisErrorEvent"): SpeechSynthesisErrorEvent;
4705 createEvent(eventInterface: "SpeechSynthesisEvent"): SpeechSynthesisEvent;
4706 createEvent(eventInterface: "StorageEvent"): StorageEvent;
4707 createEvent(eventInterface: "TextEvent"): TextEvent;
4708 createEvent(eventInterface: "TouchEvent"): TouchEvent;
4709 createEvent(eventInterface: "TrackEvent"): TrackEvent;
4710 createEvent(eventInterface: "TransitionEvent"): TransitionEvent;
4711 createEvent(eventInterface: "UIEvent"): UIEvent;
4712 createEvent(eventInterface: "UIEvents"): UIEvent;
4713 createEvent(eventInterface: "VRDisplayEvent"): VRDisplayEvent;
4714 createEvent(eventInterface: "VRDisplayEvent "): VRDisplayEvent ;
4715 createEvent(eventInterface: "WebGLContextEvent"): WebGLContextEvent;
4716 createEvent(eventInterface: "WheelEvent"): WheelEvent;
4717 createEvent(eventInterface: string): Event;
4719 * Creates a NodeIterator object that you can use to traverse filtered lists of nodes or elements in a document.
4720 * @param root The root element or node to start traversing on.
4721 * @param whatToShow The type of nodes or elements to appear in the node list
4722 * @param filter A custom NodeFilter function to use. For more information, see filter. Use null for no filter.
4723 * @param entityReferenceExpansion A flag that specifies whether entity reference nodes are expanded.
4725 createNodeIterator(root: Node, whatToShow?: number, filter?: NodeFilter | null): NodeIterator;
4727 * 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.
4729 createProcessingInstruction(target: string, data: string): ProcessingInstruction;
4731 * Returns an empty range object that has both of its boundary points positioned at the beginning of the document.
4733 createRange(): Range;
4735 * Creates a text string from the specified value.
4736 * @param data String that specifies the nodeValue property of the text node.
4738 createTextNode(data: string): Text;
4740 * Creates a TreeWalker object that you can use to traverse filtered lists of nodes or elements in a document.
4741 * @param root The root element or node to start traversing on.
4742 * @param whatToShow The type of nodes or elements to appear in the node list. For more information, see whatToShow.
4743 * @param filter A custom NodeFilter function to use.
4744 * @param entityReferenceExpansion A flag that specifies whether entity reference nodes are expanded.
4746 createTreeWalker(root: Node, whatToShow?: number, filter?: NodeFilter | null): TreeWalker;
4748 createTreeWalker(root: Node, whatToShow: number, filter: NodeFilter | null, entityReferenceExpansion?: boolean): TreeWalker;
4750 * Returns the element for the specified x coordinate and the specified y coordinate.
4751 * @param x The x-offset
4752 * @param y The y-offset
4754 elementFromPoint(x: number, y: number): Element | null;
4755 elementsFromPoint(x: number, y: number): Element[];
4757 * Executes a command on the current document, current selection, or the given range.
4758 * @param commandId String that specifies the command to execute. This command can be any of the command identifiers that can be executed in script.
4759 * @param showUI Display the user interface, defaults to false.
4760 * @param value Value to assign.
4762 execCommand(commandId: string, showUI?: boolean, value?: string): boolean;
4764 * Stops document's fullscreen element from being displayed fullscreen and resolves promise when done.
4766 exitFullscreen(): Promise<void>;
4767 exitPointerLock(): void;
4768 getAnimations(): Animation[];
4770 * Returns a reference to the first object with the specified value of the ID or NAME attribute.
4771 * @param elementId String that specifies the ID value. Case-insensitive.
4773 getElementById(elementId: string): HTMLElement | null;
4775 * 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.
4777 getElementsByClassName(classNames: string): HTMLCollectionOf<Element>;
4779 * Gets a collection of objects based on the value of the NAME or ID attribute.
4780 * @param elementName Gets a collection of objects based on the value of the NAME or ID attribute.
4782 getElementsByName(elementName: string): NodeListOf<HTMLElement>;
4784 * Retrieves a collection of objects based on the specified element name.
4785 * @param name Specifies the name of an element.
4787 getElementsByTagName<K extends keyof HTMLElementTagNameMap>(qualifiedName: K): HTMLCollectionOf<HTMLElementTagNameMap[K]>;
4788 getElementsByTagName<K extends keyof SVGElementTagNameMap>(qualifiedName: K): HTMLCollectionOf<SVGElementTagNameMap[K]>;
4789 getElementsByTagName(qualifiedName: string): HTMLCollectionOf<Element>;
4791 * If namespace and localName are "*" returns a HTMLCollection of all descendant elements.
4793 * If only namespace is "*" returns a HTMLCollection of all descendant elements whose local name is localName.
4795 * If only localName is "*" returns a HTMLCollection of all descendant elements whose namespace is namespace.
4797 * Otherwise, returns a HTMLCollection of all descendant elements whose namespace is namespace and local name is localName.
4799 getElementsByTagNameNS(namespaceURI: "http://www.w3.org/1999/xhtml", localName: string): HTMLCollectionOf<HTMLElement>;
4800 getElementsByTagNameNS(namespaceURI: "http://www.w3.org/2000/svg", localName: string): HTMLCollectionOf<SVGElement>;
4801 getElementsByTagNameNS(namespaceURI: string, localName: string): HTMLCollectionOf<Element>;
4803 * Returns an object representing the current selection of the document that is loaded into the object displaying a webpage.
4805 getSelection(): Selection | null;
4807 * Gets a value indicating whether the object currently has focus.
4809 hasFocus(): boolean;
4811 * Returns a copy of node. If deep is true, the copy also includes the node's descendants.
4813 * If node is a document or a shadow root, throws a "NotSupportedError" DOMException.
4815 importNode<T extends Node>(importedNode: T, deep: boolean): T;
4817 * 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.
4818 * @param url Specifies a MIME type for the document.
4819 * @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.
4820 * @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.
4821 * @param replace Specifies whether the existing entry for the document is replaced in the history list.
4823 open(url?: string, name?: string, features?: string, replace?: boolean): Document;
4825 * Returns a Boolean value that indicates whether a specified command can be successfully executed using execCommand, given the current state of the document.
4826 * @param commandId Specifies a command identifier.
4828 queryCommandEnabled(commandId: string): boolean;
4830 * Returns a Boolean value that indicates whether the specified command is in the indeterminate state.
4831 * @param commandId String that specifies a command identifier.
4833 queryCommandIndeterm(commandId: string): boolean;
4835 * Returns a Boolean value that indicates the current state of the command.
4836 * @param commandId String that specifies a command identifier.
4838 queryCommandState(commandId: string): boolean;
4840 * Returns a Boolean value that indicates whether the current command is supported on the current range.
4841 * @param commandId Specifies a command identifier.
4843 queryCommandSupported(commandId: string): boolean;
4845 * Returns the current value of the document, range, or current selection for the given command.
4846 * @param commandId String that specifies a command identifier.
4848 queryCommandValue(commandId: string): string;
4850 releaseEvents(): void;
4852 * Writes one or more HTML expressions to a document in the specified window.
4853 * @param content Specifies the text and HTML tags to write.
4855 write(...text: string[]): void;
4857 * Writes one or more HTML expressions, followed by a carriage return, to a document in the specified window.
4858 * @param content The text and HTML tags to write.
4860 writeln(...text: string[]): void;
4861 addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
4862 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
4863 removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
4864 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
4867 declare var Document: {
4868 prototype: Document;
4872 interface DocumentAndElementEventHandlersEventMap {
4873 "copy": ClipboardEvent;
4874 "cut": ClipboardEvent;
4875 "paste": ClipboardEvent;
4878 interface DocumentAndElementEventHandlers {
4879 oncopy: ((this: DocumentAndElementEventHandlers, ev: ClipboardEvent) => any) | null;
4880 oncut: ((this: DocumentAndElementEventHandlers, ev: ClipboardEvent) => any) | null;
4881 onpaste: ((this: DocumentAndElementEventHandlers, ev: ClipboardEvent) => any) | null;
4882 addEventListener<K extends keyof DocumentAndElementEventHandlersEventMap>(type: K, listener: (this: DocumentAndElementEventHandlers, ev: DocumentAndElementEventHandlersEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
4883 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
4884 removeEventListener<K extends keyof DocumentAndElementEventHandlersEventMap>(type: K, listener: (this: DocumentAndElementEventHandlers, ev: DocumentAndElementEventHandlersEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
4885 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
4888 interface DocumentEvent {
4889 createEvent(eventInterface: "AnimationEvent"): AnimationEvent;
4890 createEvent(eventInterface: "AnimationPlaybackEvent"): AnimationPlaybackEvent;
4891 createEvent(eventInterface: "AudioProcessingEvent"): AudioProcessingEvent;
4892 createEvent(eventInterface: "BeforeUnloadEvent"): BeforeUnloadEvent;
4893 createEvent(eventInterface: "ClipboardEvent"): ClipboardEvent;
4894 createEvent(eventInterface: "CloseEvent"): CloseEvent;
4895 createEvent(eventInterface: "CompositionEvent"): CompositionEvent;
4896 createEvent(eventInterface: "CustomEvent"): CustomEvent;
4897 createEvent(eventInterface: "DeviceLightEvent"): DeviceLightEvent;
4898 createEvent(eventInterface: "DeviceMotionEvent"): DeviceMotionEvent;
4899 createEvent(eventInterface: "DeviceOrientationEvent"): DeviceOrientationEvent;
4900 createEvent(eventInterface: "DragEvent"): DragEvent;
4901 createEvent(eventInterface: "ErrorEvent"): ErrorEvent;
4902 createEvent(eventInterface: "Event"): Event;
4903 createEvent(eventInterface: "Events"): Event;
4904 createEvent(eventInterface: "FocusEvent"): FocusEvent;
4905 createEvent(eventInterface: "FocusNavigationEvent"): FocusNavigationEvent;
4906 createEvent(eventInterface: "GamepadEvent"): GamepadEvent;
4907 createEvent(eventInterface: "HashChangeEvent"): HashChangeEvent;
4908 createEvent(eventInterface: "IDBVersionChangeEvent"): IDBVersionChangeEvent;
4909 createEvent(eventInterface: "InputEvent"): InputEvent;
4910 createEvent(eventInterface: "KeyboardEvent"): KeyboardEvent;
4911 createEvent(eventInterface: "ListeningStateChangedEvent"): ListeningStateChangedEvent;
4912 createEvent(eventInterface: "MSGestureEvent"): MSGestureEvent;
4913 createEvent(eventInterface: "MSMediaKeyMessageEvent"): MSMediaKeyMessageEvent;
4914 createEvent(eventInterface: "MSMediaKeyNeededEvent"): MSMediaKeyNeededEvent;
4915 createEvent(eventInterface: "MSPointerEvent"): MSPointerEvent;
4916 createEvent(eventInterface: "MediaEncryptedEvent"): MediaEncryptedEvent;
4917 createEvent(eventInterface: "MediaKeyMessageEvent"): MediaKeyMessageEvent;
4918 createEvent(eventInterface: "MediaQueryListEvent"): MediaQueryListEvent;
4919 createEvent(eventInterface: "MediaStreamErrorEvent"): MediaStreamErrorEvent;
4920 createEvent(eventInterface: "MediaStreamEvent"): MediaStreamEvent;
4921 createEvent(eventInterface: "MediaStreamTrackEvent"): MediaStreamTrackEvent;
4922 createEvent(eventInterface: "MessageEvent"): MessageEvent;
4923 createEvent(eventInterface: "MouseEvent"): MouseEvent;
4924 createEvent(eventInterface: "MouseEvents"): MouseEvent;
4925 createEvent(eventInterface: "MutationEvent"): MutationEvent;
4926 createEvent(eventInterface: "MutationEvents"): MutationEvent;
4927 createEvent(eventInterface: "OfflineAudioCompletionEvent"): OfflineAudioCompletionEvent;
4928 createEvent(eventInterface: "OverflowEvent"): OverflowEvent;
4929 createEvent(eventInterface: "PageTransitionEvent"): PageTransitionEvent;
4930 createEvent(eventInterface: "PaymentRequestUpdateEvent"): PaymentRequestUpdateEvent;
4931 createEvent(eventInterface: "PermissionRequestedEvent"): PermissionRequestedEvent;
4932 createEvent(eventInterface: "PointerEvent"): PointerEvent;
4933 createEvent(eventInterface: "PopStateEvent"): PopStateEvent;
4934 createEvent(eventInterface: "ProgressEvent"): ProgressEvent;
4935 createEvent(eventInterface: "PromiseRejectionEvent"): PromiseRejectionEvent;
4936 createEvent(eventInterface: "RTCDTMFToneChangeEvent"): RTCDTMFToneChangeEvent;
4937 createEvent(eventInterface: "RTCDataChannelEvent"): RTCDataChannelEvent;
4938 createEvent(eventInterface: "RTCDtlsTransportStateChangedEvent"): RTCDtlsTransportStateChangedEvent;
4939 createEvent(eventInterface: "RTCErrorEvent"): RTCErrorEvent;
4940 createEvent(eventInterface: "RTCIceCandidatePairChangedEvent"): RTCIceCandidatePairChangedEvent;
4941 createEvent(eventInterface: "RTCIceGathererEvent"): RTCIceGathererEvent;
4942 createEvent(eventInterface: "RTCIceTransportStateChangedEvent"): RTCIceTransportStateChangedEvent;
4943 createEvent(eventInterface: "RTCPeerConnectionIceErrorEvent"): RTCPeerConnectionIceErrorEvent;
4944 createEvent(eventInterface: "RTCPeerConnectionIceEvent"): RTCPeerConnectionIceEvent;
4945 createEvent(eventInterface: "RTCSsrcConflictEvent"): RTCSsrcConflictEvent;
4946 createEvent(eventInterface: "RTCStatsEvent"): RTCStatsEvent;
4947 createEvent(eventInterface: "RTCTrackEvent"): RTCTrackEvent;
4948 createEvent(eventInterface: "SVGZoomEvent"): SVGZoomEvent;
4949 createEvent(eventInterface: "SVGZoomEvents"): SVGZoomEvent;
4950 createEvent(eventInterface: "SecurityPolicyViolationEvent"): SecurityPolicyViolationEvent;
4951 createEvent(eventInterface: "ServiceWorkerMessageEvent"): ServiceWorkerMessageEvent;
4952 createEvent(eventInterface: "SpeechRecognitionEvent"): SpeechRecognitionEvent;
4953 createEvent(eventInterface: "SpeechSynthesisErrorEvent"): SpeechSynthesisErrorEvent;
4954 createEvent(eventInterface: "SpeechSynthesisEvent"): SpeechSynthesisEvent;
4955 createEvent(eventInterface: "StorageEvent"): StorageEvent;
4956 createEvent(eventInterface: "TextEvent"): TextEvent;
4957 createEvent(eventInterface: "TouchEvent"): TouchEvent;
4958 createEvent(eventInterface: "TrackEvent"): TrackEvent;
4959 createEvent(eventInterface: "TransitionEvent"): TransitionEvent;
4960 createEvent(eventInterface: "UIEvent"): UIEvent;
4961 createEvent(eventInterface: "UIEvents"): UIEvent;
4962 createEvent(eventInterface: "VRDisplayEvent"): VRDisplayEvent;
4963 createEvent(eventInterface: "VRDisplayEvent "): VRDisplayEvent ;
4964 createEvent(eventInterface: "WebGLContextEvent"): WebGLContextEvent;
4965 createEvent(eventInterface: "WheelEvent"): WheelEvent;
4966 createEvent(eventInterface: string): Event;
4969 /** 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. */
4970 interface DocumentFragment extends Node, NonElementParentNode, ParentNode {
4971 readonly ownerDocument: Document;
4972 getElementById(elementId: string): HTMLElement | null;
4975 declare var DocumentFragment: {
4976 prototype: DocumentFragment;
4977 new(): DocumentFragment;
4980 interface DocumentOrShadowRoot {
4981 readonly activeElement: Element | null;
4983 * Returns document's fullscreen element.
4985 readonly fullscreenElement: Element | null;
4986 readonly pointerLockElement: Element | null;
4988 * Retrieves a collection of styleSheet objects representing the style sheets that correspond to each instance of a link or style object in the document.
4990 readonly styleSheets: StyleSheetList;
4991 caretPositionFromPoint(x: number, y: number): CaretPosition | null;
4993 caretRangeFromPoint(x: number, y: number): Range;
4994 elementFromPoint(x: number, y: number): Element | null;
4995 elementsFromPoint(x: number, y: number): Element[];
4996 getSelection(): Selection | null;
4999 interface DocumentTimeline extends AnimationTimeline {
5002 declare var DocumentTimeline: {
5003 prototype: DocumentTimeline;
5004 new(options?: DocumentTimelineOptions): DocumentTimeline;
5007 /** A Node containing a doctype. */
5008 interface DocumentType extends Node, ChildNode {
5009 readonly name: string;
5010 readonly ownerDocument: Document;
5011 readonly publicId: string;
5012 readonly systemId: string;
5015 declare var DocumentType: {
5016 prototype: DocumentType;
5017 new(): DocumentType;
5020 /** 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. */
5021 interface DragEvent extends MouseEvent {
5023 * Returns the DataTransfer object for the event.
5025 readonly dataTransfer: DataTransfer | null;
5028 declare var DragEvent: {
5029 prototype: DragEvent;
5030 new(type: string, eventInitDict?: DragEventInit): DragEvent;
5033 /** Inherits properties from its parent, AudioNode. */
5034 interface DynamicsCompressorNode extends AudioNode {
5035 readonly attack: AudioParam;
5036 readonly knee: AudioParam;
5037 readonly ratio: AudioParam;
5038 readonly reduction: number;
5039 readonly release: AudioParam;
5040 readonly threshold: AudioParam;
5043 declare var DynamicsCompressorNode: {
5044 prototype: DynamicsCompressorNode;
5045 new(context: BaseAudioContext, options?: DynamicsCompressorOptions): DynamicsCompressorNode;
5048 interface EXT_blend_minmax {
5049 readonly MAX_EXT: GLenum;
5050 readonly MIN_EXT: GLenum;
5053 /** 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. */
5054 interface EXT_frag_depth {
5057 interface EXT_sRGB {
5058 readonly FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT: GLenum;
5059 readonly SRGB8_ALPHA8_EXT: GLenum;
5060 readonly SRGB_ALPHA_EXT: GLenum;
5061 readonly SRGB_EXT: GLenum;
5064 interface EXT_shader_texture_lod {
5067 /** The EXT_texture_filter_anisotropic extension is part of the WebGL API and exposes two constants for anisotropic filtering (AF). */
5068 interface EXT_texture_filter_anisotropic {
5069 readonly MAX_TEXTURE_MAX_ANISOTROPY_EXT: GLenum;
5070 readonly TEXTURE_MAX_ANISOTROPY_EXT: GLenum;
5073 interface ElementEventMap {
5074 "fullscreenchange": Event;
5075 "fullscreenerror": Event;
5078 /** 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. */
5079 interface Element extends Node, Animatable, ChildNode, InnerHTML, NonDocumentTypeChildNode, ParentNode, Slottable {
5080 readonly assignedSlot: HTMLSlotElement | null;
5081 readonly attributes: NamedNodeMap;
5083 * Allows for manipulation of element's class content attribute as a set of whitespace-separated tokens through a DOMTokenList object.
5085 readonly classList: DOMTokenList;
5087 * Returns the value of element's class content attribute. Can be set to change it.
5090 readonly clientHeight: number;
5091 readonly clientLeft: number;
5092 readonly clientTop: number;
5093 readonly clientWidth: number;
5095 * Returns the value of element's id content attribute. Can be set to change it.
5099 * Returns the local name.
5101 readonly localName: string;
5103 * Returns the namespace.
5105 readonly namespaceURI: string | null;
5106 onfullscreenchange: ((this: Element, ev: Event) => any) | null;
5107 onfullscreenerror: ((this: Element, ev: Event) => any) | null;
5109 readonly ownerDocument: Document;
5111 * Returns the namespace prefix.
5113 readonly prefix: string | null;
5114 readonly scrollHeight: number;
5117 readonly scrollWidth: number;
5119 * Returns element's shadow root, if any, and if shadow root's mode is "open", and null otherwise.
5121 readonly shadowRoot: ShadowRoot | null;
5123 * Returns the value of element's slot content attribute. Can be set to change it.
5127 * Returns the HTML-uppercased qualified name.
5129 readonly tagName: string;
5131 * Creates a shadow root for element and returns it.
5133 attachShadow(init: ShadowRootInit): ShadowRoot;
5135 * Returns the first (starting at element) inclusive ancestor that matches selectors, and null otherwise.
5137 closest<K extends keyof HTMLElementTagNameMap>(selector: K): HTMLElementTagNameMap[K] | null;
5138 closest<K extends keyof SVGElementTagNameMap>(selector: K): SVGElementTagNameMap[K] | null;
5139 closest<E extends Element = Element>(selector: string): E | null;
5141 * Returns element's first attribute whose qualified name is qualifiedName, and null if there is no such attribute otherwise.
5143 getAttribute(qualifiedName: string): string | null;
5145 * Returns element's attribute whose namespace is namespace and local name is localName, and null if there is no such attribute otherwise.
5147 getAttributeNS(namespace: string | null, localName: string): string | null;
5149 * Returns the qualified names of all element's attributes. Can contain duplicates.
5151 getAttributeNames(): string[];
5152 getAttributeNode(qualifiedName: string): Attr | null;
5153 getAttributeNodeNS(namespace: string | null, localName: string): Attr | null;
5154 getBoundingClientRect(): DOMRect;
5155 getClientRects(): DOMRectList;
5157 * 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.
5159 getElementsByClassName(classNames: string): HTMLCollectionOf<Element>;
5160 getElementsByTagName<K extends keyof HTMLElementTagNameMap>(qualifiedName: K): HTMLCollectionOf<HTMLElementTagNameMap[K]>;
5161 getElementsByTagName<K extends keyof SVGElementTagNameMap>(qualifiedName: K): HTMLCollectionOf<SVGElementTagNameMap[K]>;
5162 getElementsByTagName(qualifiedName: string): HTMLCollectionOf<Element>;
5163 getElementsByTagNameNS(namespaceURI: "http://www.w3.org/1999/xhtml", localName: string): HTMLCollectionOf<HTMLElement>;
5164 getElementsByTagNameNS(namespaceURI: "http://www.w3.org/2000/svg", localName: string): HTMLCollectionOf<SVGElement>;
5165 getElementsByTagNameNS(namespaceURI: string, localName: string): HTMLCollectionOf<Element>;
5167 * Returns true if element has an attribute whose qualified name is qualifiedName, and false otherwise.
5169 hasAttribute(qualifiedName: string): boolean;
5171 * Returns true if element has an attribute whose namespace is namespace and local name is localName.
5173 hasAttributeNS(namespace: string | null, localName: string): boolean;
5175 * Returns true if element has attributes, and false otherwise.
5177 hasAttributes(): boolean;
5178 hasPointerCapture(pointerId: number): boolean;
5179 insertAdjacentElement(position: InsertPosition, insertedElement: Element): Element | null;
5180 insertAdjacentHTML(where: InsertPosition, html: string): void;
5181 insertAdjacentText(where: InsertPosition, text: string): void;
5183 * Returns true if matching selectors against element's root yields element, and false otherwise.
5185 matches(selectors: string): boolean;
5186 msGetRegionContent(): any;
5187 releasePointerCapture(pointerId: number): void;
5189 * Removes element's first attribute whose qualified name is qualifiedName.
5191 removeAttribute(qualifiedName: string): void;
5193 * Removes element's attribute whose namespace is namespace and local name is localName.
5195 removeAttributeNS(namespace: string | null, localName: string): void;
5196 removeAttributeNode(attr: Attr): Attr;
5198 * Displays element fullscreen and resolves promise when done.
5200 * 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.
5202 requestFullscreen(options?: FullscreenOptions): Promise<void>;
5203 requestPointerLock(): void;
5204 scroll(options?: ScrollToOptions): void;
5205 scroll(x: number, y: number): void;
5206 scrollBy(options?: ScrollToOptions): void;
5207 scrollBy(x: number, y: number): void;
5208 scrollIntoView(arg?: boolean | ScrollIntoViewOptions): void;
5209 scrollTo(options?: ScrollToOptions): void;
5210 scrollTo(x: number, y: number): void;
5212 * Sets the value of element's first attribute whose qualified name is qualifiedName to value.
5214 setAttribute(qualifiedName: string, value: string): void;
5216 * Sets the value of element's attribute whose namespace is namespace and local name is localName to value.
5218 setAttributeNS(namespace: string | null, qualifiedName: string, value: string): void;
5219 setAttributeNode(attr: Attr): Attr | null;
5220 setAttributeNodeNS(attr: Attr): Attr | null;
5221 setPointerCapture(pointerId: number): void;
5223 * 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.
5225 * Returns true if qualifiedName is now present, and false otherwise.
5227 toggleAttribute(qualifiedName: string, force?: boolean): boolean;
5228 webkitMatchesSelector(selectors: string): boolean;
5229 addEventListener<K extends keyof ElementEventMap>(type: K, listener: (this: Element, ev: ElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
5230 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
5231 removeEventListener<K extends keyof ElementEventMap>(type: K, listener: (this: Element, ev: ElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
5232 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
5235 declare var Element: {
5240 interface ElementCSSInlineStyle {
5241 readonly style: CSSStyleDeclaration;
5244 interface ElementContentEditable {
5245 contentEditable: string;
5246 enterKeyHint: string;
5248 readonly isContentEditable: boolean;
5251 /** Events providing information related to errors in scripts or in files. */
5252 interface ErrorEvent extends Event {
5253 readonly colno: number;
5254 readonly error: any;
5255 readonly filename: string;
5256 readonly lineno: number;
5257 readonly message: string;
5260 declare var ErrorEvent: {
5261 prototype: ErrorEvent;
5262 new(type: string, eventInitDict?: ErrorEventInit): ErrorEvent;
5265 /** An event which takes place in the DOM. */
5268 * 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.
5270 readonly bubbles: boolean;
5271 cancelBubble: boolean;
5273 * 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.
5275 readonly cancelable: boolean;
5277 * 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.
5279 readonly composed: boolean;
5281 * Returns the object whose event listener's callback is currently being invoked.
5283 readonly currentTarget: EventTarget | null;
5285 * Returns true if preventDefault() was invoked successfully to indicate cancelation, and false otherwise.
5287 readonly defaultPrevented: boolean;
5289 * Returns the event's phase, which is one of NONE, CAPTURING_PHASE, AT_TARGET, and BUBBLING_PHASE.
5291 readonly eventPhase: number;
5293 * Returns true if event was dispatched by the user agent, and false otherwise.
5295 readonly isTrusted: boolean;
5296 returnValue: boolean;
5298 readonly srcElement: EventTarget | null;
5300 * Returns the object to which event is dispatched (its target).
5302 readonly target: EventTarget | null;
5304 * Returns the event's timestamp as the number of milliseconds measured relative to the time origin.
5306 readonly timeStamp: number;
5308 * Returns the type of event, e.g. "click", "hashchange", or "submit".
5310 readonly type: string;
5312 * 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.
5314 composedPath(): EventTarget[];
5315 initEvent(type: string, bubbles?: boolean, cancelable?: boolean): void;
5317 * 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.
5319 preventDefault(): void;
5321 * 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.
5323 stopImmediatePropagation(): void;
5325 * When dispatched in a tree, invoking this method prevents event from reaching any objects other than the current object.
5327 stopPropagation(): void;
5328 readonly AT_TARGET: number;
5329 readonly BUBBLING_PHASE: number;
5330 readonly CAPTURING_PHASE: number;
5331 readonly NONE: number;
5334 declare var Event: {
5336 new(type: string, eventInitDict?: EventInit): Event;
5337 readonly AT_TARGET: number;
5338 readonly BUBBLING_PHASE: number;
5339 readonly CAPTURING_PHASE: number;
5340 readonly NONE: number;
5343 interface EventListenerObject {
5344 handleEvent(evt: Event): void;
5347 interface EventSourceEventMap {
5349 "message": MessageEvent;
5353 interface EventSource extends EventTarget {
5354 onerror: ((this: EventSource, ev: Event) => any) | null;
5355 onmessage: ((this: EventSource, ev: MessageEvent) => any) | null;
5356 onopen: ((this: EventSource, ev: Event) => any) | null;
5358 * Returns the state of this EventSource object's connection. It can have the values described below.
5360 readonly readyState: number;
5362 * Returns the URL providing the event stream.
5364 readonly url: string;
5366 * Returns true if the credentials mode for connection requests to the URL providing the event stream is set to "include", and false otherwise.
5368 readonly withCredentials: boolean;
5370 * Aborts any instances of the fetch algorithm started for this EventSource object, and sets the readyState attribute to CLOSED.
5373 readonly CLOSED: number;
5374 readonly CONNECTING: number;
5375 readonly OPEN: number;
5376 addEventListener<K extends keyof EventSourceEventMap>(type: K, listener: (this: EventSource, ev: EventSourceEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
5377 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
5378 removeEventListener<K extends keyof EventSourceEventMap>(type: K, listener: (this: EventSource, ev: EventSourceEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
5379 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
5382 declare var EventSource: {
5383 prototype: EventSource;
5384 new(url: string, eventSourceInitDict?: EventSourceInit): EventSource;
5385 readonly CLOSED: number;
5386 readonly CONNECTING: number;
5387 readonly OPEN: number;
5390 /** EventTarget is a DOM interface implemented by objects that can receive events and may have listeners for them. */
5391 interface EventTarget {
5393 * 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.
5395 * 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.
5397 * 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.
5399 * 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.
5401 * When set to true, options's once indicates that the callback will only be invoked once after which the event listener will be removed.
5403 * The event listener is appended to target's event listener list and is not appended if it has the same type, callback, and capture.
5405 addEventListener(type: string, listener: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions): void;
5407 * 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.
5409 dispatchEvent(event: Event): boolean;
5411 * Removes the event listener in target's event listener list with the same type, callback, and options.
5413 removeEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
5416 declare var EventTarget: {
5417 prototype: EventTarget;
5421 interface ExtensionScriptApis {
5422 extensionIdToShortId(extensionId: string): number;
5423 fireExtensionApiTelemetry(functionName: string, isSucceeded: boolean, isSupported: boolean, errorString: string): void;
5424 genericFunction(routerAddress: any, parameters?: string, callbackId?: number): void;
5425 genericSynchronousFunction(functionId: number, parameters?: string): string;
5426 genericWebRuntimeCallout(to: any, from: any, payload: string): void;
5427 getExtensionId(): string;
5428 registerGenericFunctionCallbackHandler(callbackHandler: Function): void;
5429 registerGenericPersistentCallbackHandler(callbackHandler: Function): void;
5430 registerWebRuntimeCallbackHandler(handler: Function): any;
5433 declare var ExtensionScriptApis: {
5434 prototype: ExtensionScriptApis;
5435 new(): ExtensionScriptApis;
5438 interface External {
5440 AddSearchProvider(): void;
5442 IsSearchProviderInstalled(): void;
5445 declare var External: {
5446 prototype: External;
5450 /** Provides information about files and allows JavaScript in a web page to access their content. */
5451 interface File extends Blob {
5452 readonly lastModified: number;
5453 readonly name: string;
5458 new(fileBits: BlobPart[], fileName: string, options?: FilePropertyBag): File;
5461 /** 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. */
5462 interface FileList {
5463 readonly length: number;
5464 item(index: number): File | null;
5465 [index: number]: File;
5468 declare var FileList: {
5469 prototype: FileList;
5473 interface FileReaderEventMap {
5474 "abort": ProgressEvent<FileReader>;
5475 "error": ProgressEvent<FileReader>;
5476 "load": ProgressEvent<FileReader>;
5477 "loadend": ProgressEvent<FileReader>;
5478 "loadstart": ProgressEvent<FileReader>;
5479 "progress": ProgressEvent<FileReader>;
5482 /** 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. */
5483 interface FileReader extends EventTarget {
5484 readonly error: DOMException | null;
5485 onabort: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
5486 onerror: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
5487 onload: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
5488 onloadend: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
5489 onloadstart: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
5490 onprogress: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
5491 readonly readyState: number;
5492 readonly result: string | ArrayBuffer | null;
5494 readAsArrayBuffer(blob: Blob): void;
5495 readAsBinaryString(blob: Blob): void;
5496 readAsDataURL(blob: Blob): void;
5497 readAsText(blob: Blob, encoding?: string): void;
5498 readonly DONE: number;
5499 readonly EMPTY: number;
5500 readonly LOADING: number;
5501 addEventListener<K extends keyof FileReaderEventMap>(type: K, listener: (this: FileReader, ev: FileReaderEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
5502 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
5503 removeEventListener<K extends keyof FileReaderEventMap>(type: K, listener: (this: FileReader, ev: FileReaderEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
5504 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
5507 declare var FileReader: {
5508 prototype: FileReader;
5510 readonly DONE: number;
5511 readonly EMPTY: number;
5512 readonly LOADING: number;
5515 /** Focus-related events like focus, blur, focusin, or focusout. */
5516 interface FocusEvent extends UIEvent {
5517 readonly relatedTarget: EventTarget | null;
5520 declare var FocusEvent: {
5521 prototype: FocusEvent;
5522 new(type: string, eventInitDict?: FocusEventInit): FocusEvent;
5525 interface FocusNavigationEvent extends Event {
5526 readonly navigationReason: NavigationReason;
5527 readonly originHeight: number;
5528 readonly originLeft: number;
5529 readonly originTop: number;
5530 readonly originWidth: number;
5531 requestFocus(): void;
5534 declare var FocusNavigationEvent: {
5535 prototype: FocusNavigationEvent;
5536 new(type: string, eventInitDict?: FocusNavigationEventInit): FocusNavigationEvent;
5539 /** 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". */
5540 interface FormData {
5541 append(name: string, value: string | Blob, fileName?: string): void;
5542 delete(name: string): void;
5543 get(name: string): FormDataEntryValue | null;
5544 getAll(name: string): FormDataEntryValue[];
5545 has(name: string): boolean;
5546 set(name: string, value: string | Blob, fileName?: string): void;
5547 forEach(callbackfn: (value: FormDataEntryValue, key: string, parent: FormData) => void, thisArg?: any): void;
5550 declare var FormData: {
5551 prototype: FormData;
5552 new(form?: HTMLFormElement): FormData;
5555 /** 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. */
5556 interface GainNode extends AudioNode {
5557 readonly gain: AudioParam;
5560 declare var GainNode: {
5561 prototype: GainNode;
5562 new(context: BaseAudioContext, options?: GainOptions): GainNode;
5565 /** This Gamepad API interface defines an individual gamepad or other controller, allowing access to information such as button presses, axis positions, and id. */
5567 readonly axes: ReadonlyArray<number>;
5568 readonly buttons: ReadonlyArray<GamepadButton>;
5569 readonly connected: boolean;
5570 readonly hand: GamepadHand;
5571 readonly hapticActuators: ReadonlyArray<GamepadHapticActuator>;
5572 readonly id: string;
5573 readonly index: number;
5574 readonly mapping: GamepadMappingType;
5575 readonly pose: GamepadPose | null;
5576 readonly timestamp: number;
5579 declare var Gamepad: {
5584 /** 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. */
5585 interface GamepadButton {
5586 readonly pressed: boolean;
5587 readonly touched: boolean;
5588 readonly value: number;
5591 declare var GamepadButton: {
5592 prototype: GamepadButton;
5593 new(): GamepadButton;
5596 /** 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. */
5597 interface GamepadEvent extends Event {
5598 readonly gamepad: Gamepad;
5601 declare var GamepadEvent: {
5602 prototype: GamepadEvent;
5603 new(type: string, eventInitDict: GamepadEventInit): GamepadEvent;
5606 /** This Gamepad API interface represents hardware in the controller designed to provide haptic feedback to the user (if available), most commonly vibration hardware. */
5607 interface GamepadHapticActuator {
5608 readonly type: GamepadHapticActuatorType;
5609 pulse(value: number, duration: number): Promise<boolean>;
5612 declare var GamepadHapticActuator: {
5613 prototype: GamepadHapticActuator;
5614 new(): GamepadHapticActuator;
5617 /** This Gamepad API interface represents the pose of a WebVR controller at a given timestamp (which includes orientation, position, velocity, and acceleration information.) */
5618 interface GamepadPose {
5619 readonly angularAcceleration: Float32Array | null;
5620 readonly angularVelocity: Float32Array | null;
5621 readonly hasOrientation: boolean;
5622 readonly hasPosition: boolean;
5623 readonly linearAcceleration: Float32Array | null;
5624 readonly linearVelocity: Float32Array | null;
5625 readonly orientation: Float32Array | null;
5626 readonly position: Float32Array | null;
5629 declare var GamepadPose: {
5630 prototype: GamepadPose;
5634 interface GenericTransformStream {
5636 * Returns a readable stream whose chunks are strings resulting from running encoding's decoder on the chunks written to writable.
5638 readonly readable: ReadableStream;
5640 * Returns a writable stream which accepts [AllowShared] BufferSource chunks and runs them through encoding's decoder before making them available to readable.
5642 * Typically this will be used via the pipeThrough() method on a ReadableStream source.
5645 * var decoder = new TextDecoderStream(encoding);
5647 * .pipeThrough(decoder)
5648 * .pipeTo(textWritable);
5651 * If the error mode is "fatal" and encoding's decoder returns error, both readable and writable will be errored with a TypeError.
5653 readonly writable: WritableStream;
5656 /** 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. */
5657 interface Geolocation {
5658 clearWatch(watchId: number): void;
5659 getCurrentPosition(successCallback: PositionCallback, errorCallback?: PositionErrorCallback, options?: PositionOptions): void;
5660 watchPosition(successCallback: PositionCallback, errorCallback?: PositionErrorCallback, options?: PositionOptions): number;
5663 declare var Geolocation: {
5664 prototype: Geolocation;
5668 interface GeolocationCoordinates {
5669 readonly accuracy: number;
5670 readonly altitude: number | null;
5671 readonly altitudeAccuracy: number | null;
5672 readonly heading: number | null;
5673 readonly latitude: number;
5674 readonly longitude: number;
5675 readonly speed: number | null;
5678 declare var GeolocationCoordinates: {
5679 prototype: GeolocationCoordinates;
5680 new(): GeolocationCoordinates;
5683 interface GeolocationPosition {
5684 readonly coords: GeolocationCoordinates;
5685 readonly timestamp: number;
5688 declare var GeolocationPosition: {
5689 prototype: GeolocationPosition;
5690 new(): GeolocationPosition;
5693 interface GeolocationPositionError {
5694 readonly code: number;
5695 readonly message: string;
5696 readonly PERMISSION_DENIED: number;
5697 readonly POSITION_UNAVAILABLE: number;
5698 readonly TIMEOUT: number;
5701 declare var GeolocationPositionError: {
5702 prototype: GeolocationPositionError;
5703 new(): GeolocationPositionError;
5704 readonly PERMISSION_DENIED: number;
5705 readonly POSITION_UNAVAILABLE: number;
5706 readonly TIMEOUT: number;
5709 interface GlobalEventHandlersEventMap {
5711 "animationcancel": AnimationEvent;
5712 "animationend": AnimationEvent;
5713 "animationiteration": AnimationEvent;
5714 "animationstart": AnimationEvent;
5715 "auxclick": MouseEvent;
5719 "canplaythrough": Event;
5721 "click": MouseEvent;
5723 "contextmenu": MouseEvent;
5725 "dblclick": MouseEvent;
5727 "dragend": DragEvent;
5728 "dragenter": DragEvent;
5730 "dragleave": DragEvent;
5731 "dragover": DragEvent;
5732 "dragstart": DragEvent;
5734 "durationchange": Event;
5737 "error": ErrorEvent;
5738 "focus": FocusEvent;
5739 "focusin": FocusEvent;
5740 "focusout": FocusEvent;
5741 "gotpointercapture": PointerEvent;
5744 "keydown": KeyboardEvent;
5745 "keypress": KeyboardEvent;
5746 "keyup": KeyboardEvent;
5748 "loadeddata": Event;
5749 "loadedmetadata": Event;
5751 "lostpointercapture": PointerEvent;
5752 "mousedown": MouseEvent;
5753 "mouseenter": MouseEvent;
5754 "mouseleave": MouseEvent;
5755 "mousemove": MouseEvent;
5756 "mouseout": MouseEvent;
5757 "mouseover": MouseEvent;
5758 "mouseup": MouseEvent;
5762 "pointercancel": PointerEvent;
5763 "pointerdown": PointerEvent;
5764 "pointerenter": PointerEvent;
5765 "pointerleave": PointerEvent;
5766 "pointermove": PointerEvent;
5767 "pointerout": PointerEvent;
5768 "pointerover": PointerEvent;
5769 "pointerup": PointerEvent;
5770 "progress": ProgressEvent;
5771 "ratechange": Event;
5775 "securitypolicyviolation": SecurityPolicyViolationEvent;
5779 "selectionchange": Event;
5780 "selectstart": Event;
5784 "timeupdate": Event;
5786 "touchcancel": TouchEvent;
5787 "touchend": TouchEvent;
5788 "touchmove": TouchEvent;
5789 "touchstart": TouchEvent;
5790 "transitioncancel": TransitionEvent;
5791 "transitionend": TransitionEvent;
5792 "transitionrun": TransitionEvent;
5793 "transitionstart": TransitionEvent;
5794 "volumechange": Event;
5796 "wheel": WheelEvent;
5799 interface GlobalEventHandlers {
5801 * Fires when the user aborts the download.
5802 * @param ev The event.
5804 onabort: ((this: GlobalEventHandlers, ev: UIEvent) => any) | null;
5805 onanimationcancel: ((this: GlobalEventHandlers, ev: AnimationEvent) => any) | null;
5806 onanimationend: ((this: GlobalEventHandlers, ev: AnimationEvent) => any) | null;
5807 onanimationiteration: ((this: GlobalEventHandlers, ev: AnimationEvent) => any) | null;
5808 onanimationstart: ((this: GlobalEventHandlers, ev: AnimationEvent) => any) | null;
5809 onauxclick: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
5811 * Fires when the object loses the input focus.
5812 * @param ev The focus event.
5814 onblur: ((this: GlobalEventHandlers, ev: FocusEvent) => any) | null;
5815 oncancel: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5817 * Occurs when playback is possible, but would require further buffering.
5818 * @param ev The event.
5820 oncanplay: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5821 oncanplaythrough: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5823 * Fires when the contents of the object or selection have changed.
5824 * @param ev The event.
5826 onchange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5828 * Fires when the user clicks the left mouse button on the object
5829 * @param ev The mouse event.
5831 onclick: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
5832 onclose: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5834 * Fires when the user clicks the right mouse button in the client area, opening the context menu.
5835 * @param ev The mouse event.
5837 oncontextmenu: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
5838 oncuechange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5840 * Fires when the user double-clicks the object.
5841 * @param ev The mouse event.
5843 ondblclick: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
5845 * Fires on the source object continuously during a drag operation.
5846 * @param ev The event.
5848 ondrag: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
5850 * Fires on the source object when the user releases the mouse at the close of a drag operation.
5851 * @param ev The event.
5853 ondragend: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
5855 * Fires on the target element when the user drags the object to a valid drop target.
5856 * @param ev The drag event.
5858 ondragenter: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
5859 ondragexit: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5861 * Fires on the target object when the user moves the mouse out of a valid drop target during a drag operation.
5862 * @param ev The drag event.
5864 ondragleave: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
5866 * Fires on the target element continuously while the user drags the object over a valid drop target.
5867 * @param ev The event.
5869 ondragover: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
5871 * Fires on the source object when the user starts to drag a text selection or selected object.
5872 * @param ev The event.
5874 ondragstart: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
5875 ondrop: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
5877 * Occurs when the duration attribute is updated.
5878 * @param ev The event.
5880 ondurationchange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5882 * Occurs when the media element is reset to its initial state.
5883 * @param ev The event.
5885 onemptied: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5887 * Occurs when the end of playback is reached.
5888 * @param ev The event
5890 onended: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5892 * Fires when an error occurs during object loading.
5893 * @param ev The event.
5895 onerror: OnErrorEventHandler;
5897 * Fires when the object receives focus.
5898 * @param ev The event.
5900 onfocus: ((this: GlobalEventHandlers, ev: FocusEvent) => any) | null;
5901 ongotpointercapture: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
5902 oninput: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5903 oninvalid: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5905 * Fires when the user presses a key.
5906 * @param ev The keyboard event
5908 onkeydown: ((this: GlobalEventHandlers, ev: KeyboardEvent) => any) | null;
5910 * Fires when the user presses an alphanumeric key.
5911 * @param ev The event.
5913 onkeypress: ((this: GlobalEventHandlers, ev: KeyboardEvent) => any) | null;
5915 * Fires when the user releases a key.
5916 * @param ev The keyboard event
5918 onkeyup: ((this: GlobalEventHandlers, ev: KeyboardEvent) => any) | null;
5920 * Fires immediately after the browser loads the object.
5921 * @param ev The event.
5923 onload: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5925 * Occurs when media data is loaded at the current playback position.
5926 * @param ev The event.
5928 onloadeddata: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5930 * Occurs when the duration and dimensions of the media have been determined.
5931 * @param ev The event.
5933 onloadedmetadata: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5935 * Occurs when Internet Explorer begins looking for media data.
5936 * @param ev The event.
5938 onloadstart: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5939 onlostpointercapture: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
5941 * Fires when the user clicks the object with either mouse button.
5942 * @param ev The mouse event.
5944 onmousedown: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
5945 onmouseenter: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
5946 onmouseleave: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
5948 * Fires when the user moves the mouse over the object.
5949 * @param ev The mouse event.
5951 onmousemove: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
5953 * Fires when the user moves the mouse pointer outside the boundaries of the object.
5954 * @param ev The mouse event.
5956 onmouseout: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
5958 * Fires when the user moves the mouse pointer into the object.
5959 * @param ev The mouse event.
5961 onmouseover: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
5963 * Fires when the user releases a mouse button while the mouse is over the object.
5964 * @param ev The mouse event.
5966 onmouseup: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
5968 * Occurs when playback is paused.
5969 * @param ev The event.
5971 onpause: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5973 * Occurs when the play method is requested.
5974 * @param ev The event.
5976 onplay: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5978 * Occurs when the audio or video has started playing.
5979 * @param ev The event.
5981 onplaying: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5982 onpointercancel: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
5983 onpointerdown: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
5984 onpointerenter: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
5985 onpointerleave: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
5986 onpointermove: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
5987 onpointerout: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
5988 onpointerover: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
5989 onpointerup: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
5991 * Occurs to indicate progress while downloading media data.
5992 * @param ev The event.
5994 onprogress: ((this: GlobalEventHandlers, ev: ProgressEvent) => any) | null;
5996 * Occurs when the playback rate is increased or decreased.
5997 * @param ev The event.
5999 onratechange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6001 * Fires when the user resets a form.
6002 * @param ev The event.
6004 onreset: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6005 onresize: ((this: GlobalEventHandlers, ev: UIEvent) => any) | null;
6007 * Fires when the user repositions the scroll box in the scroll bar on the object.
6008 * @param ev The event.
6010 onscroll: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6011 onsecuritypolicyviolation: ((this: GlobalEventHandlers, ev: SecurityPolicyViolationEvent) => any) | null;
6013 * Occurs when the seek operation ends.
6014 * @param ev The event.
6016 onseeked: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6018 * Occurs when the current playback position is moved.
6019 * @param ev The event.
6021 onseeking: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6023 * Fires when the current selection changes.
6024 * @param ev The event.
6026 onselect: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6027 onselectionchange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6028 onselectstart: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6030 * Occurs when the download has stopped.
6031 * @param ev The event.
6033 onstalled: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6034 onsubmit: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6036 * Occurs if the load operation has been intentionally halted.
6037 * @param ev The event.
6039 onsuspend: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6041 * Occurs to indicate the current playback position.
6042 * @param ev The event.
6044 ontimeupdate: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6045 ontoggle: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6046 ontouchcancel?: ((this: GlobalEventHandlers, ev: TouchEvent) => any) | null;
6047 ontouchend?: ((this: GlobalEventHandlers, ev: TouchEvent) => any) | null;
6048 ontouchmove?: ((this: GlobalEventHandlers, ev: TouchEvent) => any) | null;
6049 ontouchstart?: ((this: GlobalEventHandlers, ev: TouchEvent) => any) | null;
6050 ontransitioncancel: ((this: GlobalEventHandlers, ev: TransitionEvent) => any) | null;
6051 ontransitionend: ((this: GlobalEventHandlers, ev: TransitionEvent) => any) | null;
6052 ontransitionrun: ((this: GlobalEventHandlers, ev: TransitionEvent) => any) | null;
6053 ontransitionstart: ((this: GlobalEventHandlers, ev: TransitionEvent) => any) | null;
6055 * Occurs when the volume is changed, or playback is muted or unmuted.
6056 * @param ev The event.
6058 onvolumechange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6060 * Occurs when playback stops because the next frame of a video resource is not available.
6061 * @param ev The event.
6063 onwaiting: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6064 onwheel: ((this: GlobalEventHandlers, ev: WheelEvent) => any) | null;
6065 addEventListener<K extends keyof GlobalEventHandlersEventMap>(type: K, listener: (this: GlobalEventHandlers, ev: GlobalEventHandlersEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6066 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6067 removeEventListener<K extends keyof GlobalEventHandlersEventMap>(type: K, listener: (this: GlobalEventHandlers, ev: GlobalEventHandlersEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6068 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6071 interface HTMLAllCollection {
6073 * Returns the number of elements in the collection.
6075 readonly length: number;
6077 * Returns the item with index index from the collection (determined by tree order).
6079 item(nameOrIndex?: string): HTMLCollection | Element | null;
6081 * Returns the item with ID or name name from the collection.
6083 * If there are multiple matching items, then an HTMLCollection object containing all those elements is returned.
6085 * 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.
6087 namedItem(name: string): HTMLCollection | Element | null;
6088 [index: number]: Element;
6091 declare var HTMLAllCollection: {
6092 prototype: HTMLAllCollection;
6093 new(): HTMLAllCollection;
6096 /** 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. */
6097 interface HTMLAnchorElement extends HTMLElement, HTMLHyperlinkElementUtils {
6099 * Sets or retrieves the character set used to encode the object.
6104 * Sets or retrieves the coordinates of the object.
6110 * Sets or retrieves the language code of the object.
6114 * Sets or retrieves the shape of the object.
6119 referrerPolicy: string;
6121 * Sets or retrieves the relationship between the object and the destination of the link.
6124 readonly relList: DOMTokenList;
6126 * Sets or retrieves the relationship between the object and the destination of the link.
6131 * Sets or retrieves the shape of the object.
6136 * Sets or retrieves the window or frame at which to target content.
6140 * Retrieves or sets the text of the object as a string.
6144 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLAnchorElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6145 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6146 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLAnchorElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6147 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6150 declare var HTMLAnchorElement: {
6151 prototype: HTMLAnchorElement;
6152 new(): HTMLAnchorElement;
6155 interface HTMLAppletElement extends HTMLElement {
6159 * Sets or retrieves a text alternative to the graphic.
6164 * Sets or retrieves a character string that can be used to implement your own archive functionality for the object.
6171 * Sets or retrieves the URL of the component.
6175 readonly form: HTMLFormElement | null;
6177 * Sets or retrieves the height of the object.
6184 * Sets or retrieves the shape of the object.
6194 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLAppletElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6195 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6196 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLAppletElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6197 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6200 declare var HTMLAppletElement: {
6201 prototype: HTMLAppletElement;
6202 new(): HTMLAppletElement;
6205 /** 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. */
6206 interface HTMLAreaElement extends HTMLElement, HTMLHyperlinkElementUtils {
6208 * Sets or retrieves a text alternative to the graphic.
6212 * Sets or retrieves the coordinates of the object.
6217 * Sets or gets whether clicks in this region cause action.
6222 referrerPolicy: string;
6224 readonly relList: DOMTokenList;
6226 * Sets or retrieves the shape of the object.
6230 * Sets or retrieves the window or frame at which to target content.
6233 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLAreaElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6234 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6235 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLAreaElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6236 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6239 declare var HTMLAreaElement: {
6240 prototype: HTMLAreaElement;
6241 new(): HTMLAreaElement;
6244 /** Provides access to the properties of <audio> elements, as well as methods to manipulate them. It derives from the HTMLMediaElement interface. */
6245 interface HTMLAudioElement extends HTMLMediaElement {
6246 addEventListener<K extends keyof HTMLMediaElementEventMap>(type: K, listener: (this: HTMLAudioElement, ev: HTMLMediaElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6247 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6248 removeEventListener<K extends keyof HTMLMediaElementEventMap>(type: K, listener: (this: HTMLAudioElement, ev: HTMLMediaElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6249 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6252 declare var HTMLAudioElement: {
6253 prototype: HTMLAudioElement;
6254 new(): HTMLAudioElement;
6257 /** A HTML line break element (<br>). It inherits from HTMLElement. */
6258 interface HTMLBRElement extends HTMLElement {
6260 * Sets or retrieves the side on which floating objects are not to be positioned when any IHTMLBlockElement is inserted into the document.
6264 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLBRElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6265 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6266 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLBRElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6267 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6270 declare var HTMLBRElement: {
6271 prototype: HTMLBRElement;
6272 new(): HTMLBRElement;
6275 /** Contains the base URIÂ for a document. This object inherits all of the properties and methods as described in the HTMLElement interface. */
6276 interface HTMLBaseElement extends HTMLElement {
6278 * Gets or sets the baseline URL on which relative links are based.
6282 * Sets or retrieves the window or frame at which to target content.
6285 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLBaseElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6286 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6287 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLBaseElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6288 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6291 declare var HTMLBaseElement: {
6292 prototype: HTMLBaseElement;
6293 new(): HTMLBaseElement;
6296 /** Provides special properties (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating <basefont> elements. */
6297 interface HTMLBaseFontElement extends HTMLElement, DOML2DeprecatedColorProperty {
6299 * Sets or retrieves the current typeface family.
6304 * Sets or retrieves the font size of the object.
6308 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLBaseFontElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6309 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6310 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLBaseFontElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6311 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6314 declare var HTMLBaseFontElement: {
6315 prototype: HTMLBaseFontElement;
6316 new(): HTMLBaseFontElement;
6319 interface HTMLBodyElementEventMap extends HTMLElementEventMap, WindowEventHandlersEventMap {
6320 "orientationchange": Event;
6323 /** Provides special properties (beyond those inherited from the regular HTMLElement interface) for manipulating <body> elements. */
6324 interface HTMLBodyElement extends HTMLElement, WindowEventHandlers {
6334 onorientationchange: ((this: HTMLBodyElement, ev: Event) => any) | null;
6339 addEventListener<K extends keyof HTMLBodyElementEventMap>(type: K, listener: (this: HTMLBodyElement, ev: HTMLBodyElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6340 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6341 removeEventListener<K extends keyof HTMLBodyElementEventMap>(type: K, listener: (this: HTMLBodyElement, ev: HTMLBodyElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6342 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6345 declare var HTMLBodyElement: {
6346 prototype: HTMLBodyElement;
6347 new(): HTMLBodyElement;
6350 /** Provides properties and methods (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating <button> elements. */
6351 interface HTMLButtonElement extends HTMLElement {
6354 * Retrieves a reference to the form that the object is embedded in.
6356 readonly form: HTMLFormElement | null;
6358 * Overrides the action attribute (where the data on a form is sent) on the parent form element.
6362 * Used to override the encoding (formEnctype attribute) specified on the form element.
6364 formEnctype: string;
6366 * Overrides the submit method attribute previously specified on a form element.
6370 * 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.
6372 formNoValidate: boolean;
6374 * Overrides the target attribute on a form element.
6377 readonly labels: NodeListOf<HTMLLabelElement>;
6379 * Sets or retrieves the name of the object.
6383 * Gets the classification and default behavior of the button.
6387 * 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.
6389 readonly validationMessage: string;
6391 * Returns a ValidityState object that represents the validity states of an element.
6393 readonly validity: ValidityState;
6395 * Sets or retrieves the default or selected value of the control.
6399 * Returns whether an element will successfully validate based on forms validation rules and constraints.
6401 readonly willValidate: boolean;
6403 * Returns whether a form will validate when it is submitted, without having to submit it.
6405 checkValidity(): boolean;
6406 reportValidity(): boolean;
6408 * Sets a custom error message that is displayed when a form is submitted.
6409 * @param error Sets a custom error message that is displayed when a form is submitted.
6411 setCustomValidity(error: string): void;
6412 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLButtonElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6413 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6414 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLButtonElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6415 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6418 declare var HTMLButtonElement: {
6419 prototype: HTMLButtonElement;
6420 new(): HTMLButtonElement;
6423 /** 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. */
6424 interface HTMLCanvasElement extends HTMLElement {
6426 * Gets or sets the height of a canvas element on a document.
6430 * Gets or sets the width of a canvas element on a document.
6434 * 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.
6435 * @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");
6437 getContext(contextId: "2d", options?: CanvasRenderingContext2DSettings): CanvasRenderingContext2D | null;
6438 getContext(contextId: "bitmaprenderer", options?: ImageBitmapRenderingContextSettings): ImageBitmapRenderingContext | null;
6439 getContext(contextId: "webgl", options?: WebGLContextAttributes): WebGLRenderingContext | null;
6440 getContext(contextId: "webgl2", options?: WebGLContextAttributes): WebGL2RenderingContext | null;
6441 getContext(contextId: string, options?: any): RenderingContext | null;
6442 toBlob(callback: BlobCallback, type?: string, quality?: any): void;
6444 * Returns the content of the current canvas as an image that you can use as a source for another canvas or an HTML element.
6445 * @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.
6447 toDataURL(type?: string, quality?: any): string;
6448 transferControlToOffscreen(): OffscreenCanvas;
6449 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLCanvasElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6450 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6451 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLCanvasElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6452 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6455 declare var HTMLCanvasElement: {
6456 prototype: HTMLCanvasElement;
6457 new(): HTMLCanvasElement;
6460 /** A generic collection (array-like object similar to arguments) of elements (in document order) and offers methods and properties for selecting from the list. */
6461 interface HTMLCollectionBase {
6463 * Sets or retrieves the number of objects in a collection.
6465 readonly length: number;
6467 * Retrieves an object from various collections.
6469 item(index: number): Element | null;
6470 [index: number]: Element;
6473 interface HTMLCollection extends HTMLCollectionBase {
6475 * Retrieves a select object or an object from an options collection.
6477 namedItem(name: string): Element | null;
6480 declare var HTMLCollection: {
6481 prototype: HTMLCollection;
6482 new(): HTMLCollection;
6485 interface HTMLCollectionOf<T extends Element> extends HTMLCollectionBase {
6486 item(index: number): T | null;
6487 namedItem(name: string): T | null;
6491 /** Provides special properties (beyond those of the regular HTMLElement interface it also has available to it by inheritance) for manipulating definition list (<dl>) elements. */
6492 interface HTMLDListElement extends HTMLElement {
6495 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDListElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6496 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6497 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDListElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6498 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6501 declare var HTMLDListElement: {
6502 prototype: HTMLDListElement;
6503 new(): HTMLDListElement;
6506 /** Provides special properties (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating <data> elements. */
6507 interface HTMLDataElement extends HTMLElement {
6509 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDataElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6510 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6511 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDataElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6512 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6515 declare var HTMLDataElement: {
6516 prototype: HTMLDataElement;
6517 new(): HTMLDataElement;
6520 /** Provides special properties (beyond the HTMLElement object interface it also has available to it by inheritance) to manipulate <datalist> elements and their content. */
6521 interface HTMLDataListElement extends HTMLElement {
6522 readonly options: HTMLCollectionOf<HTMLOptionElement>;
6523 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDataListElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6524 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6525 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDataListElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6526 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6529 declare var HTMLDataListElement: {
6530 prototype: HTMLDataListElement;
6531 new(): HTMLDataListElement;
6534 interface HTMLDetailsElement extends HTMLElement {
6536 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDetailsElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6537 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6538 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDetailsElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6539 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6542 declare var HTMLDetailsElement: {
6543 prototype: HTMLDetailsElement;
6544 new(): HTMLDetailsElement;
6547 interface HTMLDialogElement extends HTMLElement {
6549 returnValue: string;
6550 close(returnValue?: string): void;
6553 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDialogElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6554 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6555 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDialogElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6556 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6559 declare var HTMLDialogElement: {
6560 prototype: HTMLDialogElement;
6561 new(): HTMLDialogElement;
6564 interface HTMLDirectoryElement extends HTMLElement {
6567 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDirectoryElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6568 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6569 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDirectoryElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6570 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6573 declare var HTMLDirectoryElement: {
6574 prototype: HTMLDirectoryElement;
6575 new(): HTMLDirectoryElement;
6578 /** Provides special properties (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating <div> elements. */
6579 interface HTMLDivElement extends HTMLElement {
6581 * Sets or retrieves how the object is aligned with adjacent text.
6585 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDivElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6586 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6587 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDivElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6588 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6591 declare var HTMLDivElement: {
6592 prototype: HTMLDivElement;
6593 new(): HTMLDivElement;
6596 /** The HTMLDocument property of Window objects is an alias that browsers expose for the Document interface object. */
6597 interface HTMLDocument extends Document {
6598 addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: HTMLDocument, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6599 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6600 removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: HTMLDocument, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6601 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6604 declare var HTMLDocument: {
6605 prototype: HTMLDocument;
6606 new(): HTMLDocument;
6609 interface HTMLElementEventMap extends ElementEventMap, GlobalEventHandlersEventMap, DocumentAndElementEventHandlersEventMap {
6612 /** Any HTML element. Some elements directly implement this interface, while others implement it via an interface that inherits it. */
6613 interface HTMLElement extends Element, DocumentAndElementEventHandlers, ElementCSSInlineStyle, ElementCSSInlineStyle, ElementContentEditable, GlobalEventHandlers, HTMLOrSVGElement {
6615 readonly accessKeyLabel: string;
6616 autocapitalize: string;
6622 readonly offsetHeight: number;
6623 readonly offsetLeft: number;
6624 readonly offsetParent: Element | null;
6625 readonly offsetTop: number;
6626 readonly offsetWidth: number;
6627 spellcheck: boolean;
6631 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6632 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6633 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6634 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6637 declare var HTMLElement: {
6638 prototype: HTMLElement;
6642 /** Provides special properties (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating <embed> elements. */
6643 interface HTMLEmbedElement extends HTMLElement {
6647 * Sets or retrieves the height of the object.
6651 * Sets or retrieves the name of the object.
6656 * Sets or retrieves a URL to be loaded by the object.
6661 * Sets or retrieves the width of the object.
6664 getSVGDocument(): Document | null;
6665 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLEmbedElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6666 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6667 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLEmbedElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6668 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6671 declare var HTMLEmbedElement: {
6672 prototype: HTMLEmbedElement;
6673 new(): HTMLEmbedElement;
6676 /** 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. */
6677 interface HTMLFieldSetElement extends HTMLElement {
6679 readonly elements: HTMLCollection;
6681 * Retrieves a reference to the form that the object is embedded in.
6683 readonly form: HTMLFormElement | null;
6685 readonly type: string;
6687 * 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.
6689 readonly validationMessage: string;
6691 * Returns a ValidityState object that represents the validity states of an element.
6693 readonly validity: ValidityState;
6695 * Returns whether an element will successfully validate based on forms validation rules and constraints.
6697 readonly willValidate: boolean;
6699 * Returns whether a form will validate when it is submitted, without having to submit it.
6701 checkValidity(): boolean;
6702 reportValidity(): boolean;
6704 * Sets a custom error message that is displayed when a form is submitted.
6705 * @param error Sets a custom error message that is displayed when a form is submitted.
6707 setCustomValidity(error: string): void;
6708 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLFieldSetElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6709 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6710 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLFieldSetElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6711 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6714 declare var HTMLFieldSetElement: {
6715 prototype: HTMLFieldSetElement;
6716 new(): HTMLFieldSetElement;
6719 /** 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. */
6720 interface HTMLFontElement extends HTMLElement {
6724 * Sets or retrieves the current typeface family.
6730 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLFontElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6731 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6732 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLFontElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6733 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6736 declare var HTMLFontElement: {
6737 prototype: HTMLFontElement;
6738 new(): HTMLFontElement;
6741 /** A collection of HTML form control elements. */
6742 interface HTMLFormControlsCollection extends HTMLCollectionBase {
6744 * Returns the item with ID or name name from the collection.
6746 * If there are multiple matching items, then a RadioNodeList object containing all those elements is returned.
6748 namedItem(name: string): RadioNodeList | Element | null;
6751 declare var HTMLFormControlsCollection: {
6752 prototype: HTMLFormControlsCollection;
6753 new(): HTMLFormControlsCollection;
6756 /** 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. */
6757 interface HTMLFormElement extends HTMLElement {
6759 * Sets or retrieves a list of character encodings for input data that must be accepted by the server processing the form.
6761 acceptCharset: string;
6763 * Sets or retrieves the URL to which the form content is sent for processing.
6767 * Specifies whether autocomplete is applied to an editable text field.
6769 autocomplete: string;
6771 * Retrieves a collection, in source order, of all controls in a given form.
6773 readonly elements: HTMLFormControlsCollection;
6775 * Sets or retrieves the MIME encoding for the form.
6779 * Sets or retrieves the encoding type for the form.
6783 * Sets or retrieves the number of objects in a collection.
6785 readonly length: number;
6787 * Sets or retrieves how to send the form data to the server.
6791 * Sets or retrieves the name of the object.
6795 * Designates a form that is not validated when submitted.
6797 noValidate: boolean;
6799 * Sets or retrieves the window or frame at which to target content.
6803 * Returns whether a form will validate when it is submitted, without having to submit it.
6805 checkValidity(): boolean;
6806 reportValidity(): boolean;
6808 * Fires when the user resets a form.
6812 * Fires when a FORM is about to be submitted.
6815 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLFormElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6816 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6817 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLFormElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6818 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6819 [index: number]: Element;
6820 [name: string]: any;
6823 declare var HTMLFormElement: {
6824 prototype: HTMLFormElement;
6825 new(): HTMLFormElement;
6828 interface HTMLFrameElement extends HTMLElement {
6830 * Retrieves the document object of the page or frame.
6833 readonly contentDocument: Document | null;
6835 * Retrieves the object of the specified.
6838 readonly contentWindow: WindowProxy | null;
6840 * Sets or retrieves whether to display a border for the frame.
6843 frameBorder: string;
6845 * Sets or retrieves a URI to a long description of the object.
6850 * Sets or retrieves the top and bottom margin heights before displaying the text in a frame.
6853 marginHeight: string;
6855 * Sets or retrieves the left and right margin widths before displaying the text in a frame.
6858 marginWidth: string;
6860 * Sets or retrieves the frame name.
6865 * Sets or retrieves whether the user can resize the frame.
6870 * Sets or retrieves whether the frame can be scrolled.
6875 * Sets or retrieves a URL to be loaded by the object.
6879 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLFrameElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6880 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6881 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLFrameElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6882 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6885 declare var HTMLFrameElement: {
6886 prototype: HTMLFrameElement;
6887 new(): HTMLFrameElement;
6890 interface HTMLFrameSetElementEventMap extends HTMLElementEventMap, WindowEventHandlersEventMap {
6893 /** Provides special properties (beyond those of the regular HTMLElement interface they also inherit) for manipulating <frameset> elements. */
6894 interface HTMLFrameSetElement extends HTMLElement, WindowEventHandlers {
6896 * Sets or retrieves the frame widths of the object.
6901 * Sets or retrieves the frame heights of the object.
6905 addEventListener<K extends keyof HTMLFrameSetElementEventMap>(type: K, listener: (this: HTMLFrameSetElement, ev: HTMLFrameSetElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6906 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6907 removeEventListener<K extends keyof HTMLFrameSetElementEventMap>(type: K, listener: (this: HTMLFrameSetElement, ev: HTMLFrameSetElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6908 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6911 declare var HTMLFrameSetElement: {
6912 prototype: HTMLFrameSetElement;
6913 new(): HTMLFrameSetElement;
6916 /** Provides special properties (beyond those of the HTMLElement interface it also has available to it by inheritance) for manipulating <hr> elements. */
6917 interface HTMLHRElement extends HTMLElement {
6919 * Sets or retrieves how the object is aligned with adjacent text.
6926 * Sets or retrieves whether the horizontal rule is drawn with 3-D shading.
6933 * Sets or retrieves the width of the object.
6937 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLHRElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6938 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6939 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLHRElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6940 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6943 declare var HTMLHRElement: {
6944 prototype: HTMLHRElement;
6945 new(): HTMLHRElement;
6948 /** Contains the descriptive information, or metadata, for a document. This object inherits all of the properties and methods described in the HTMLElement interface. */
6949 interface HTMLHeadElement extends HTMLElement {
6950 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLHeadElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6951 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6952 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLHeadElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6953 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6956 declare var HTMLHeadElement: {
6957 prototype: HTMLHeadElement;
6958 new(): HTMLHeadElement;
6961 /** The different heading elements. It inherits methods and properties from the HTMLElement interface. */
6962 interface HTMLHeadingElement extends HTMLElement {
6964 * Sets or retrieves a value that indicates the table alignment.
6968 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLHeadingElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6969 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6970 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLHeadingElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6971 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6974 declare var HTMLHeadingElement: {
6975 prototype: HTMLHeadingElement;
6976 new(): HTMLHeadingElement;
6979 /** Serves as the root node for a given HTML document. This object inherits the properties and methods described in the HTMLElement interface. */
6980 interface HTMLHtmlElement extends HTMLElement {
6982 * Sets or retrieves the DTD version that governs the current document.
6986 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLHtmlElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6987 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6988 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLHtmlElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6989 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6992 declare var HTMLHtmlElement: {
6993 prototype: HTMLHtmlElement;
6994 new(): HTMLHtmlElement;
6997 interface HTMLHyperlinkElementUtils {
7003 readonly origin: string;
7012 /** 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. */
7013 interface HTMLIFrameElement extends HTMLElement {
7015 * Sets or retrieves how the object is aligned with adjacent text.
7020 allowFullscreen: boolean;
7021 allowPaymentRequest: boolean;
7023 * Retrieves the document object of the page or frame.
7025 readonly contentDocument: Document | null;
7027 * Retrieves the object of the specified.
7029 readonly contentWindow: WindowProxy | null;
7031 * Sets or retrieves whether to display a border for the frame.
7034 frameBorder: string;
7036 * Sets or retrieves the height of the object.
7040 * Sets or retrieves a URI to a long description of the object.
7045 * Sets or retrieves the top and bottom margin heights before displaying the text in a frame.
7048 marginHeight: string;
7050 * Sets or retrieves the left and right margin widths before displaying the text in a frame.
7053 marginWidth: string;
7055 * Sets or retrieves the frame name.
7058 referrerPolicy: ReferrerPolicy;
7059 readonly sandbox: DOMTokenList;
7061 * Sets or retrieves whether the frame can be scrolled.
7066 * Sets or retrieves a URL to be loaded by the object.
7070 * Sets or retrives the content of the page that is to contain.
7074 * Sets or retrieves the width of the object.
7077 getSVGDocument(): Document | null;
7078 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLIFrameElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7079 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7080 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLIFrameElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7081 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7084 declare var HTMLIFrameElement: {
7085 prototype: HTMLIFrameElement;
7086 new(): HTMLIFrameElement;
7089 /** Provides special properties and methods for manipulating <img> elements. */
7090 interface HTMLImageElement extends HTMLElement {
7092 * Sets or retrieves how the object is aligned with adjacent text.
7097 * Sets or retrieves a text alternative to the graphic.
7101 * Specifies the properties of a border drawn around an object.
7106 * Retrieves whether the object is fully loaded.
7108 readonly complete: boolean;
7109 crossOrigin: string | null;
7110 readonly currentSrc: string;
7111 decoding: "async" | "sync" | "auto";
7113 * Sets or retrieves the height of the object.
7117 * Sets or retrieves the width of the border to draw around the object.
7122 * Sets or retrieves whether the image is a server-side image map.
7127 * Sets or retrieves a Uniform Resource Identifier (URI) to a long description of the object.
7134 * Sets or retrieves the name of the object.
7139 * The original height of the image resource before sizing.
7141 readonly naturalHeight: number;
7143 * The original width of the image resource before sizing.
7145 readonly naturalWidth: number;
7146 referrerPolicy: string;
7149 * The address or URL of the a media resource that is to be considered.
7154 * Sets or retrieves the URL, often with a bookmark extension (#name), to use as a client-side image map.
7158 * Sets or retrieves the vertical margin for the object.
7163 * Sets or retrieves the width of the object.
7168 decode(): Promise<void>;
7169 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLImageElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7170 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7171 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLImageElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7172 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7175 declare var HTMLImageElement: {
7176 prototype: HTMLImageElement;
7177 new(): HTMLImageElement;
7180 /** Provides special properties and methods for manipulating the options, layout, and presentation of <input> elements. */
7181 interface HTMLInputElement extends HTMLElement {
7183 * Sets or retrieves a comma-separated list of content types.
7187 * Sets or retrieves how the object is aligned with adjacent text.
7192 * Sets or retrieves a text alternative to the graphic.
7196 * Specifies whether autocomplete is applied to an editable text field.
7198 autocomplete: string;
7200 * Sets or retrieves the state of the check box or radio button.
7204 * Sets or retrieves the state of the check box or radio button.
7206 defaultChecked: boolean;
7208 * Sets or retrieves the initial contents of the object.
7210 defaultValue: string;
7214 * Returns a FileList object on a file type input object.
7216 files: FileList | null;
7218 * Retrieves a reference to the form that the object is embedded in.
7220 readonly form: HTMLFormElement | null;
7222 * Overrides the action attribute (where the data on a form is sent) on the parent form element.
7226 * Used to override the encoding (formEnctype attribute) specified on the form element.
7228 formEnctype: string;
7230 * Overrides the submit method attribute previously specified on a form element.
7234 * 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.
7236 formNoValidate: boolean;
7238 * Overrides the target attribute on a form element.
7242 * Sets or retrieves the height of the object.
7245 indeterminate: boolean;
7246 readonly labels: NodeListOf<HTMLLabelElement> | null;
7248 * Specifies the ID of a pre-defined datalist of options for an input element.
7250 readonly list: HTMLElement | null;
7252 * 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.
7256 * Sets or retrieves the maximum number of characters that the user can enter in a text control.
7260 * 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.
7265 * Sets or retrieves the Boolean value indicating whether multiple items can be selected from a list.
7269 * Sets or retrieves the name of the object.
7273 * Gets or sets a string containing a regular expression that the user's input must match.
7277 * 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.
7279 placeholder: string;
7282 * When present, marks an element that can't be submitted without a value.
7285 selectionDirection: "forward" | "backward" | "none" | null;
7287 * Gets or sets the end position or offset of a text selection.
7289 selectionEnd: number | null;
7291 * Gets or sets the starting position or offset of a text selection.
7293 selectionStart: number | null;
7296 * The address or URL of the a media resource that is to be considered.
7300 * 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.
7304 * Returns the content type of the object.
7308 * Sets or retrieves the URL, often with a bookmark extension (#name), to use as a client-side image map.
7313 * 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.
7315 readonly validationMessage: string;
7317 * Returns a ValidityState object that represents the validity states of an element.
7319 readonly validity: ValidityState;
7321 * Returns the value of the data at the cursor's current position.
7325 * 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.
7327 valueAsDate: Date | null;
7329 * Returns the input field value as a number.
7331 valueAsNumber: number;
7333 * Sets or retrieves the width of the object.
7337 * Returns whether an element will successfully validate based on forms validation rules and constraints.
7339 readonly willValidate: boolean;
7341 * Returns whether a form will validate when it is submitted, without having to submit it.
7343 checkValidity(): boolean;
7344 reportValidity(): boolean;
7346 * Makes the selection equal to the current object.
7350 * Sets a custom error message that is displayed when a form is submitted.
7351 * @param error Sets a custom error message that is displayed when a form is submitted.
7353 setCustomValidity(error: string): void;
7354 setRangeText(replacement: string): void;
7355 setRangeText(replacement: string, start: number, end: number, selectionMode?: SelectionMode): void;
7357 * Sets the start and end positions of a selection in a text field.
7358 * @param start The offset into the text field for the start of the selection.
7359 * @param end The offset into the text field for the end of the selection.
7360 * @param direction The direction in which the selection is performed.
7362 setSelectionRange(start: number, end: number, direction?: "forward" | "backward" | "none"): void;
7364 * 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.
7365 * @param n Value to decrement the value by.
7367 stepDown(n?: number): void;
7369 * 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.
7370 * @param n Value to increment the value by.
7372 stepUp(n?: number): void;
7373 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLInputElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7374 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7375 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLInputElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7376 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7379 declare var HTMLInputElement: {
7380 prototype: HTMLInputElement;
7381 new(): HTMLInputElement;
7384 /** Exposes specific properties and methods (beyond those defined by regular HTMLElement interface it also has available to it by inheritance) for manipulating list elements. */
7385 interface HTMLLIElement extends HTMLElement {
7389 * Sets or retrieves the value of a list item.
7392 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLLIElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7393 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7394 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLLIElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7395 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7398 declare var HTMLLIElement: {
7399 prototype: HTMLLIElement;
7400 new(): HTMLLIElement;
7403 /** Gives access to properties specific to <label> elements. It inherits methods and properties from the base HTMLElement interface. */
7404 interface HTMLLabelElement extends HTMLElement {
7405 readonly control: HTMLElement | null;
7407 * Retrieves a reference to the form that the object is embedded in.
7409 readonly form: HTMLFormElement | null;
7411 * Sets or retrieves the object to which the given label object is assigned.
7414 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLLabelElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7415 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7416 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLLabelElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7417 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7420 declare var HTMLLabelElement: {
7421 prototype: HTMLLabelElement;
7422 new(): HTMLLabelElement;
7425 /** The HTMLLegendElement is an interface allowing to access properties of the <legend> elements. It inherits properties and methods from the HTMLElement interface. */
7426 interface HTMLLegendElement extends HTMLElement {
7430 * Retrieves a reference to the form that the object is embedded in.
7432 readonly form: HTMLFormElement | null;
7433 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLLegendElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7434 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7435 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLLegendElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7436 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7439 declare var HTMLLegendElement: {
7440 prototype: HTMLLegendElement;
7441 new(): HTMLLegendElement;
7444 /** 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. */
7445 interface HTMLLinkElement extends HTMLElement, LinkStyle {
7448 * Sets or retrieves the character set used to encode the object.
7452 crossOrigin: string | null;
7455 * Sets or retrieves a destination URL or an anchor point.
7459 * Sets or retrieves the language code of the object.
7463 imageSrcset: string;
7466 * Sets or retrieves the media type.
7469 referrerPolicy: string;
7471 * Sets or retrieves the relationship between the object and the destination of the link.
7474 readonly relList: DOMTokenList;
7476 * Sets or retrieves the relationship between the object and the destination of the link.
7480 readonly sizes: DOMTokenList;
7482 * Sets or retrieves the window or frame at which to target content.
7487 * Sets or retrieves the MIME type of the object.
7490 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLLinkElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7491 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7492 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLLinkElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7493 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7496 declare var HTMLLinkElement: {
7497 prototype: HTMLLinkElement;
7498 new(): HTMLLinkElement;
7501 /** 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. */
7502 interface HTMLMapElement extends HTMLElement {
7504 * Retrieves a collection of the area objects defined for the given map object.
7506 readonly areas: HTMLCollection;
7508 * Sets or retrieves the name of the object.
7511 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLMapElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7512 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7513 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLMapElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7514 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7517 declare var HTMLMapElement: {
7518 prototype: HTMLMapElement;
7519 new(): HTMLMapElement;
7522 interface HTMLMarqueeElementEventMap extends HTMLElementEventMap {
7528 /** Provides methods to manipulate <marquee> elements. */
7529 interface HTMLMarqueeElement extends HTMLElement {
7543 onbounce: ((this: HTMLMarqueeElement, ev: Event) => any) | null;
7545 onfinish: ((this: HTMLMarqueeElement, ev: Event) => any) | null;
7547 onstart: ((this: HTMLMarqueeElement, ev: Event) => any) | null;
7549 scrollAmount: number;
7551 scrollDelay: number;
7562 addEventListener<K extends keyof HTMLMarqueeElementEventMap>(type: K, listener: (this: HTMLMarqueeElement, ev: HTMLMarqueeElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7563 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7564 removeEventListener<K extends keyof HTMLMarqueeElementEventMap>(type: K, listener: (this: HTMLMarqueeElement, ev: HTMLMarqueeElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7565 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7568 declare var HTMLMarqueeElement: {
7569 prototype: HTMLMarqueeElement;
7570 new(): HTMLMarqueeElement;
7573 interface HTMLMediaElementEventMap extends HTMLElementEventMap {
7574 "encrypted": MediaEncryptedEvent;
7575 "waitingforkey": Event;
7578 /** Adds to HTMLElement the properties and methods needed to support basic media-related capabilities that are common to audio and video. */
7579 interface HTMLMediaElement extends HTMLElement {
7581 * Gets or sets a value that indicates whether to start playing the media automatically.
7585 * Gets a collection of buffered time ranges.
7587 readonly buffered: TimeRanges;
7589 * 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).
7592 crossOrigin: string | null;
7594 * Gets the address or URL of the current media resource that is selected by IHTMLMediaElement.
7596 readonly currentSrc: string;
7598 * Gets or sets the current playback position, in seconds.
7600 currentTime: number;
7601 defaultMuted: boolean;
7603 * Gets or sets the default playback rate when the user is not using fast forward or reverse for a video or audio resource.
7605 defaultPlaybackRate: number;
7607 * 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.
7609 readonly duration: number;
7611 * Gets information about whether the playback has ended or not.
7613 readonly ended: boolean;
7615 * Returns an object representing the current error state of the audio or video element.
7617 readonly error: MediaError | null;
7619 * Gets or sets a flag to specify whether playback should restart after it completes.
7622 readonly mediaKeys: MediaKeys | null;
7624 * Gets or sets a flag that indicates whether the audio (either audio or the audio track on video media) is muted.
7628 * Gets the current network activity for the element.
7630 readonly networkState: number;
7631 onencrypted: ((this: HTMLMediaElement, ev: MediaEncryptedEvent) => any) | null;
7632 onwaitingforkey: ((this: HTMLMediaElement, ev: Event) => any) | null;
7634 * Gets a flag that specifies whether playback is paused.
7636 readonly paused: boolean;
7638 * 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.
7640 playbackRate: number;
7642 * Gets TimeRanges for the current media resource that has been played.
7644 readonly played: TimeRanges;
7646 * Gets or sets the current playback position, in seconds.
7649 readonly readyState: number;
7651 * Returns a TimeRanges object that represents the ranges of the current media resource that can be seeked.
7653 readonly seekable: TimeRanges;
7655 * Gets a flag that indicates whether the client is currently moving to a new playback position in the media resource.
7657 readonly seeking: boolean;
7659 * The address or URL of the a media resource that is to be considered.
7662 srcObject: MediaProvider | null;
7663 readonly textTracks: TextTrackList;
7665 * Gets or sets the volume level for audio portions of the media element.
7668 addTextTrack(kind: TextTrackKind, label?: string, language?: string): TextTrack;
7670 * Returns a string that specifies whether the client can play a given media resource type.
7672 canPlayType(type: string): CanPlayTypeResult;
7673 fastSeek(time: number): void;
7675 * Resets the audio or video object and loads a new media resource.
7679 * 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.
7683 * Loads and starts playback of a media resource.
7685 play(): Promise<void>;
7686 setMediaKeys(mediaKeys: MediaKeys | null): Promise<void>;
7687 readonly HAVE_CURRENT_DATA: number;
7688 readonly HAVE_ENOUGH_DATA: number;
7689 readonly HAVE_FUTURE_DATA: number;
7690 readonly HAVE_METADATA: number;
7691 readonly HAVE_NOTHING: number;
7692 readonly NETWORK_EMPTY: number;
7693 readonly NETWORK_IDLE: number;
7694 readonly NETWORK_LOADING: number;
7695 readonly NETWORK_NO_SOURCE: number;
7696 addEventListener<K extends keyof HTMLMediaElementEventMap>(type: K, listener: (this: HTMLMediaElement, ev: HTMLMediaElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7697 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7698 removeEventListener<K extends keyof HTMLMediaElementEventMap>(type: K, listener: (this: HTMLMediaElement, ev: HTMLMediaElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7699 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7702 declare var HTMLMediaElement: {
7703 prototype: HTMLMediaElement;
7704 new(): HTMLMediaElement;
7705 readonly HAVE_CURRENT_DATA: number;
7706 readonly HAVE_ENOUGH_DATA: number;
7707 readonly HAVE_FUTURE_DATA: number;
7708 readonly HAVE_METADATA: number;
7709 readonly HAVE_NOTHING: number;
7710 readonly NETWORK_EMPTY: number;
7711 readonly NETWORK_IDLE: number;
7712 readonly NETWORK_LOADING: number;
7713 readonly NETWORK_NO_SOURCE: number;
7716 interface HTMLMenuElement extends HTMLElement {
7719 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLMenuElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7720 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7721 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLMenuElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7722 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7725 declare var HTMLMenuElement: {
7726 prototype: HTMLMenuElement;
7727 new(): HTMLMenuElement;
7730 /** Contains descriptive metadata about a document. It inherits all of the properties and methods described in the HTMLElement interface. */
7731 interface HTMLMetaElement extends HTMLElement {
7733 * Gets or sets meta-information to associate with httpEquiv or name.
7737 * Gets or sets information used to bind the value of a content attribute of a meta element to an HTTP response header.
7741 * Sets or retrieves the value specified in the content attribute of the meta object.
7745 * Sets or retrieves a scheme to be used in interpreting the value of a property specified for the object.
7749 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLMetaElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7750 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7751 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLMetaElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7752 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7755 declare var HTMLMetaElement: {
7756 prototype: HTMLMetaElement;
7757 new(): HTMLMetaElement;
7760 /** 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. */
7761 interface HTMLMeterElement extends HTMLElement {
7763 readonly labels: NodeListOf<HTMLLabelElement>;
7769 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLMeterElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7770 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7771 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLMeterElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7772 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7775 declare var HTMLMeterElement: {
7776 prototype: HTMLMeterElement;
7777 new(): HTMLMeterElement;
7780 /** 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>. */
7781 interface HTMLModElement extends HTMLElement {
7783 * Sets or retrieves reference information about the object.
7787 * Sets or retrieves the date and time of a modification to the object.
7790 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLModElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7791 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7792 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLModElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7793 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7796 declare var HTMLModElement: {
7797 prototype: HTMLModElement;
7798 new(): HTMLModElement;
7801 /** Provides special properties (beyond those defined on the regular HTMLElement interface it also has available to it by inheritance) for manipulating ordered list elements. */
7802 interface HTMLOListElement extends HTMLElement {
7807 * The starting number.
7811 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLOListElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7812 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7813 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLOListElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7814 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7817 declare var HTMLOListElement: {
7818 prototype: HTMLOListElement;
7819 new(): HTMLOListElement;
7822 /** 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. */
7823 interface HTMLObjectElement extends HTMLElement {
7827 * Sets or retrieves a character string that can be used to implement your own archive functionality for the object.
7834 * Sets or retrieves the URL of the file containing the compiled Java class.
7839 * Sets or retrieves the URL of the component.
7844 * Sets or retrieves the Internet media type for the code associated with the object.
7849 * Retrieves the document object of the page or frame.
7851 readonly contentDocument: Document | null;
7852 readonly contentWindow: WindowProxy | null;
7854 * Sets or retrieves the URL that references the data of the object.
7860 * Retrieves a reference to the form that the object is embedded in.
7862 readonly form: HTMLFormElement | null;
7864 * Sets or retrieves the height of the object.
7870 * Sets or retrieves the name of the object.
7874 * Sets or retrieves a message to be displayed while an object is loading.
7879 * Sets or retrieves the MIME type of the object.
7883 * Sets or retrieves the URL, often with a bookmark extension (#name), to use as a client-side image map.
7887 * 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.
7889 readonly validationMessage: string;
7891 * Returns a ValidityState object that represents the validity states of an element.
7893 readonly validity: ValidityState;
7897 * Sets or retrieves the width of the object.
7901 * Returns whether an element will successfully validate based on forms validation rules and constraints.
7903 readonly willValidate: boolean;
7905 * Returns whether a form will validate when it is submitted, without having to submit it.
7907 checkValidity(): boolean;
7908 getSVGDocument(): Document | null;
7909 reportValidity(): boolean;
7911 * Sets a custom error message that is displayed when a form is submitted.
7912 * @param error Sets a custom error message that is displayed when a form is submitted.
7914 setCustomValidity(error: string): void;
7915 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLObjectElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7916 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7917 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLObjectElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7918 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7921 declare var HTMLObjectElement: {
7922 prototype: HTMLObjectElement;
7923 new(): HTMLObjectElement;
7926 /** 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. */
7927 interface HTMLOptGroupElement extends HTMLElement {
7930 * Retrieves a reference to the form that the object is embedded in.
7932 readonly form: HTMLFormElement | null;
7934 * Sets or retrieves a value that you can use to implement your own label functionality for the object.
7937 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLOptGroupElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7938 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7939 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLOptGroupElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7940 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7943 declare var HTMLOptGroupElement: {
7944 prototype: HTMLOptGroupElement;
7945 new(): HTMLOptGroupElement;
7948 /** <option> elements and inherits all classes and methods of the HTMLElement interface. */
7949 interface HTMLOptionElement extends HTMLElement {
7951 * Sets or retrieves the status of an option.
7953 defaultSelected: boolean;
7956 * Retrieves a reference to the form that the object is embedded in.
7958 readonly form: HTMLFormElement | null;
7960 * Sets or retrieves the ordinal position of an option in a list box.
7962 readonly index: number;
7964 * Sets or retrieves a value that you can use to implement your own label functionality for the object.
7968 * Sets or retrieves whether the option in the list box is the default item.
7972 * Sets or retrieves the text string specified by the option tag.
7976 * Sets or retrieves the value which is returned to the server when the form control is submitted.
7979 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLOptionElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7980 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7981 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLOptionElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7982 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7985 declare var HTMLOptionElement: {
7986 prototype: HTMLOptionElement;
7987 new(): HTMLOptionElement;
7990 /** 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. */
7991 interface HTMLOptionsCollection extends HTMLCollectionOf<HTMLOptionElement> {
7993 * Returns the number of elements in the collection.
7995 * When set to a smaller number, truncates the number of option elements in the corresponding container.
7997 * When set to a greater number, adds new blank option elements to that container.
8001 * Returns the index of the first selected item, if any, or −1 if there is no selected item.
8003 * Can be set, to change the selection.
8005 selectedIndex: number;
8007 * Inserts element before the node given by before.
8009 * 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.
8011 * If before is omitted, null, or a number out of range, then element will be added at the end of the list.
8013 * This method will throw a "HierarchyRequestError" DOMException if element is an ancestor of the element into which it is to be inserted.
8015 add(element: HTMLOptionElement | HTMLOptGroupElement, before?: HTMLElement | number | null): void;
8017 * Removes the item with index index from the collection.
8019 remove(index: number): void;
8022 declare var HTMLOptionsCollection: {
8023 prototype: HTMLOptionsCollection;
8024 new(): HTMLOptionsCollection;
8027 interface HTMLOrSVGElement {
8029 readonly dataset: DOMStringMap;
8033 focus(options?: FocusOptions): void;
8036 /** Provides properties and methods (beyond those inherited from HTMLElement) for manipulating the layout and presentation of <output> elements. */
8037 interface HTMLOutputElement extends HTMLElement {
8038 defaultValue: string;
8039 readonly form: HTMLFormElement | null;
8040 readonly htmlFor: DOMTokenList;
8041 readonly labels: NodeListOf<HTMLLabelElement>;
8043 readonly type: string;
8044 readonly validationMessage: string;
8045 readonly validity: ValidityState;
8047 readonly willValidate: boolean;
8048 checkValidity(): boolean;
8049 reportValidity(): boolean;
8050 setCustomValidity(error: string): void;
8051 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLOutputElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8052 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8053 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLOutputElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8054 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8057 declare var HTMLOutputElement: {
8058 prototype: HTMLOutputElement;
8059 new(): HTMLOutputElement;
8062 /** Provides special properties (beyond those of the regular HTMLElement object interface it inherits) for manipulating <p> elements. */
8063 interface HTMLParagraphElement extends HTMLElement {
8065 * Sets or retrieves how the object is aligned with adjacent text.
8069 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLParagraphElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8070 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8071 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLParagraphElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8072 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8075 declare var HTMLParagraphElement: {
8076 prototype: HTMLParagraphElement;
8077 new(): HTMLParagraphElement;
8080 /** 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. */
8081 interface HTMLParamElement extends HTMLElement {
8083 * Sets or retrieves the name of an input parameter for an element.
8087 * Sets or retrieves the content type of the resource designated by the value attribute.
8092 * Sets or retrieves the value of an input parameter for an element.
8096 * Sets or retrieves the data type of the value attribute.
8100 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLParamElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8101 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8102 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLParamElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8103 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8106 declare var HTMLParamElement: {
8107 prototype: HTMLParamElement;
8108 new(): HTMLParamElement;
8111 /** A <picture> HTML element. It doesn't implement specific properties or methods. */
8112 interface HTMLPictureElement extends HTMLElement {
8113 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLPictureElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8114 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8115 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLPictureElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8116 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8119 declare var HTMLPictureElement: {
8120 prototype: HTMLPictureElement;
8121 new(): HTMLPictureElement;
8124 /** 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>). */
8125 interface HTMLPreElement extends HTMLElement {
8127 * Sets or gets a value that you can use to implement your own width functionality for the object.
8131 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLPreElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8132 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8133 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLPreElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8134 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8137 declare var HTMLPreElement: {
8138 prototype: HTMLPreElement;
8139 new(): HTMLPreElement;
8142 /** 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. */
8143 interface HTMLProgressElement extends HTMLElement {
8144 readonly labels: NodeListOf<HTMLLabelElement>;
8146 * Defines the maximum, or "done" value for a progress element.
8150 * 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).
8152 readonly position: number;
8154 * Sets or gets the current value of a progress element. The value must be a non-negative number between 0 and the max value.
8157 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLProgressElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8158 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8159 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLProgressElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8160 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8163 declare var HTMLProgressElement: {
8164 prototype: HTMLProgressElement;
8165 new(): HTMLProgressElement;
8168 /** 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. */
8169 interface HTMLQuoteElement extends HTMLElement {
8171 * Sets or retrieves reference information about the object.
8174 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLQuoteElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8175 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8176 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLQuoteElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8177 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8180 declare var HTMLQuoteElement: {
8181 prototype: HTMLQuoteElement;
8182 new(): HTMLQuoteElement;
8185 /** 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). */
8186 interface HTMLScriptElement extends HTMLElement {
8189 * Sets or retrieves the character set used to encode the object.
8193 crossOrigin: string | null;
8195 * Sets or retrieves the status of the script.
8199 * Sets or retrieves the event for which the script is written.
8204 * Sets or retrieves the object that is bound to the event script.
8210 referrerPolicy: string;
8212 * Retrieves the URL to an external file that contains the source code or data.
8216 * Retrieves or sets the text of the object as a string.
8220 * Sets or retrieves the MIME type for the associated scripting engine.
8223 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLScriptElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8224 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8225 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLScriptElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8226 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8229 declare var HTMLScriptElement: {
8230 prototype: HTMLScriptElement;
8231 new(): HTMLScriptElement;
8234 /** A <select> HTML Element. These elements also share all of the properties and methods of other HTML elements via the HTMLElement interface. */
8235 interface HTMLSelectElement extends HTMLElement {
8236 autocomplete: string;
8239 * Retrieves a reference to the form that the object is embedded in.
8241 readonly form: HTMLFormElement | null;
8242 readonly labels: NodeListOf<HTMLLabelElement>;
8244 * Sets or retrieves the number of objects in a collection.
8248 * Sets or retrieves the Boolean value indicating whether multiple items can be selected from a list.
8252 * Sets or retrieves the name of the object.
8255 readonly options: HTMLOptionsCollection;
8257 * When present, marks an element that can't be submitted without a value.
8261 * Sets or retrieves the index of the selected option in a select object.
8263 selectedIndex: number;
8264 readonly selectedOptions: HTMLCollectionOf<HTMLOptionElement>;
8266 * Sets or retrieves the number of rows in the list box.
8270 * Retrieves the type of select control based on the value of the MULTIPLE attribute.
8272 readonly type: string;
8274 * 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.
8276 readonly validationMessage: string;
8278 * Returns a ValidityState object that represents the validity states of an element.
8280 readonly validity: ValidityState;
8282 * Sets or retrieves the value which is returned to the server when the form control is submitted.
8286 * Returns whether an element will successfully validate based on forms validation rules and constraints.
8288 readonly willValidate: boolean;
8290 * Adds an element to the areas, controlRange, or options collection.
8291 * @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.
8292 * @param before Variant of type Object that specifies an element to insert before, or null to append the object to the collection.
8294 add(element: HTMLOptionElement | HTMLOptGroupElement, before?: HTMLElement | number | null): void;
8296 * Returns whether a form will validate when it is submitted, without having to submit it.
8298 checkValidity(): boolean;
8300 * Retrieves a select object or an object from an options collection.
8301 * @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.
8302 * @param index Variant of type Number that specifies the zero-based index of the object to retrieve when a collection is returned.
8304 item(index: number): Element | null;
8306 * Retrieves a select object or an object from an options collection.
8307 * @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.
8309 namedItem(name: string): HTMLOptionElement | null;
8311 * Removes an element from the collection.
8312 * @param index Number that specifies the zero-based index of the element to remove from the collection.
8315 remove(index: number): void;
8316 reportValidity(): boolean;
8318 * Sets a custom error message that is displayed when a form is submitted.
8319 * @param error Sets a custom error message that is displayed when a form is submitted.
8321 setCustomValidity(error: string): void;
8322 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLSelectElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8323 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8324 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLSelectElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8325 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8326 [name: number]: HTMLOptionElement | HTMLOptGroupElement;
8329 declare var HTMLSelectElement: {
8330 prototype: HTMLSelectElement;
8331 new(): HTMLSelectElement;
8334 interface HTMLSlotElement extends HTMLElement {
8336 assignedElements(options?: AssignedNodesOptions): Element[];
8337 assignedNodes(options?: AssignedNodesOptions): Node[];
8338 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLSlotElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8339 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8340 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLSlotElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8341 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8344 declare var HTMLSlotElement: {
8345 prototype: HTMLSlotElement;
8346 new(): HTMLSlotElement;
8349 /** Provides special properties (beyond the regular HTMLElement object interface it also has available to it by inheritance) for manipulating <source> elements. */
8350 interface HTMLSourceElement extends HTMLElement {
8352 * Gets or sets the intended media type of the media source.
8357 * The address or URL of the a media resource that is to be considered.
8362 * Gets or sets the MIME type of a media resource.
8365 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLSourceElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8366 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8367 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLSourceElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8368 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8371 declare var HTMLSourceElement: {
8372 prototype: HTMLSourceElement;
8373 new(): HTMLSourceElement;
8376 /** A <span> element and derives from the HTMLElement interface, but without implementing any additional properties or methods. */
8377 interface HTMLSpanElement extends HTMLElement {
8378 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLSpanElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8379 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8380 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLSpanElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8381 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8384 declare var HTMLSpanElement: {
8385 prototype: HTMLSpanElement;
8386 new(): HTMLSpanElement;
8389 /** A <style> element. It inherits properties and methods from its parent, HTMLElement, and from LinkStyle. */
8390 interface HTMLStyleElement extends HTMLElement, LinkStyle {
8392 * Sets or retrieves the media type.
8396 * Retrieves the CSS language in which the style sheet is written.
8400 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLStyleElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8401 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8402 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLStyleElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8403 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8406 declare var HTMLStyleElement: {
8407 prototype: HTMLStyleElement;
8408 new(): HTMLStyleElement;
8411 /** Special properties (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating table caption elements. */
8412 interface HTMLTableCaptionElement extends HTMLElement {
8414 * Sets or retrieves the alignment of the caption or legend.
8418 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableCaptionElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8419 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8420 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableCaptionElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8421 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8424 declare var HTMLTableCaptionElement: {
8425 prototype: HTMLTableCaptionElement;
8426 new(): HTMLTableCaptionElement;
8429 /** 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. */
8430 interface HTMLTableCellElement extends HTMLElement {
8432 * Sets or retrieves abbreviated text for the object.
8436 * Sets or retrieves how the object is aligned with adjacent text.
8441 * Sets or retrieves a comma-delimited list of conceptual categories associated with the object.
8448 * Retrieves the position of the object in the cells collection of a row.
8450 readonly cellIndex: number;
8456 * Sets or retrieves the number columns in the table that the object should span.
8460 * Sets or retrieves a list of header cells that provide information for the object.
8464 * Sets or retrieves the height of the object.
8469 * Sets or retrieves whether the browser automatically performs wordwrap.
8474 * Sets or retrieves how many rows in a table the cell should span.
8478 * Sets or retrieves the group of cells in a table to which the object's information applies.
8484 * Sets or retrieves the width of the object.
8488 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableCellElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8489 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8490 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableCellElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8491 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8494 declare var HTMLTableCellElement: {
8495 prototype: HTMLTableCellElement;
8496 new(): HTMLTableCellElement;
8499 /** Provides special properties (beyond the HTMLElement interface it also has available to it inheritance) for manipulating single or grouped table column elements. */
8500 interface HTMLTableColElement extends HTMLElement {
8502 * Sets or retrieves the alignment of the object relative to the display or table.
8511 * Sets or retrieves the number of columns in the group.
8517 * Sets or retrieves the width of the object.
8521 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableColElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8522 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8523 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableColElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8524 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8527 declare var HTMLTableColElement: {
8528 prototype: HTMLTableColElement;
8529 new(): HTMLTableColElement;
8532 interface HTMLTableDataCellElement extends HTMLTableCellElement {
8533 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableDataCellElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8534 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8535 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableDataCellElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8536 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8539 declare var HTMLTableDataCellElement: {
8540 prototype: HTMLTableDataCellElement;
8541 new(): HTMLTableDataCellElement;
8544 /** 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. */
8545 interface HTMLTableElement extends HTMLElement {
8547 * Sets or retrieves a value that indicates the table alignment.
8554 * Sets or retrieves the width of the border to draw around the object.
8559 * Retrieves the caption object of a table.
8561 caption: HTMLTableCaptionElement | null;
8563 * Sets or retrieves the amount of space between the border of the cell and the content of the cell.
8566 cellPadding: string;
8568 * Sets or retrieves the amount of space between cells in a table.
8571 cellSpacing: string;
8573 * Sets or retrieves the way the border frame around the table is displayed.
8578 * Sets or retrieves the number of horizontal rows contained in the object.
8580 readonly rows: HTMLCollectionOf<HTMLTableRowElement>;
8582 * Sets or retrieves which dividing lines (inner borders) are displayed.
8587 * Sets or retrieves a description and/or structure of the object.
8592 * Retrieves a collection of all tBody objects in the table. Objects in this collection are in source order.
8594 readonly tBodies: HTMLCollectionOf<HTMLTableSectionElement>;
8596 * Retrieves the tFoot object of the table.
8598 tFoot: HTMLTableSectionElement | null;
8600 * Retrieves the tHead object of the table.
8602 tHead: HTMLTableSectionElement | null;
8604 * Sets or retrieves the width of the object.
8609 * Creates an empty caption element in the table.
8611 createCaption(): HTMLTableCaptionElement;
8613 * Creates an empty tBody element in the table.
8615 createTBody(): HTMLTableSectionElement;
8617 * Creates an empty tFoot element in the table.
8619 createTFoot(): HTMLTableSectionElement;
8621 * Returns the tHead element object if successful, or null otherwise.
8623 createTHead(): HTMLTableSectionElement;
8625 * Deletes the caption element and its contents from the table.
8627 deleteCaption(): void;
8629 * Removes the specified row (tr) from the element and from the rows collection.
8630 * @param index Number that specifies the zero-based position in the rows collection of the row to remove.
8632 deleteRow(index: number): void;
8634 * Deletes the tFoot element and its contents from the table.
8636 deleteTFoot(): void;
8638 * Deletes the tHead element and its contents from the table.
8640 deleteTHead(): void;
8642 * Creates a new row (tr) in the table, and adds the row to the rows collection.
8643 * @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.
8645 insertRow(index?: number): HTMLTableRowElement;
8646 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8647 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8648 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8649 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8652 declare var HTMLTableElement: {
8653 prototype: HTMLTableElement;
8654 new(): HTMLTableElement;
8657 interface HTMLTableHeaderCellElement extends HTMLTableCellElement {
8659 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableHeaderCellElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8660 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8661 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableHeaderCellElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8662 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8665 declare var HTMLTableHeaderCellElement: {
8666 prototype: HTMLTableHeaderCellElement;
8667 new(): HTMLTableHeaderCellElement;
8670 /** 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. */
8671 interface HTMLTableRowElement extends HTMLElement {
8673 * Sets or retrieves how the object is aligned with adjacent text.
8680 * Retrieves a collection of all cells in the table row.
8682 readonly cells: HTMLCollectionOf<HTMLTableDataCellElement | HTMLTableHeaderCellElement>;
8688 * Retrieves the position of the object in the rows collection for the table.
8690 readonly rowIndex: number;
8692 * Retrieves the position of the object in the collection.
8694 readonly sectionRowIndex: number;
8698 * Removes the specified cell from the table row, as well as from the cells collection.
8699 * @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.
8701 deleteCell(index: number): void;
8703 * Creates a new cell in the table row, and adds the cell to the cells collection.
8704 * @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.
8706 insertCell(index?: number): HTMLTableDataCellElement;
8707 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableRowElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8708 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8709 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableRowElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8710 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8713 declare var HTMLTableRowElement: {
8714 prototype: HTMLTableRowElement;
8715 new(): HTMLTableRowElement;
8718 /** 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. */
8719 interface HTMLTableSectionElement extends HTMLElement {
8721 * Sets or retrieves a value that indicates the table alignment.
8730 * Sets or retrieves the number of horizontal rows contained in the object.
8732 readonly rows: HTMLCollectionOf<HTMLTableRowElement>;
8736 * Removes the specified row (tr) from the element and from the rows collection.
8737 * @param index Number that specifies the zero-based position in the rows collection of the row to remove.
8739 deleteRow(index: number): void;
8741 * Creates a new row (tr) in the table, and adds the row to the rows collection.
8742 * @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.
8744 insertRow(index?: number): HTMLTableRowElement;
8745 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableSectionElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8746 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8747 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableSectionElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8748 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8751 declare var HTMLTableSectionElement: {
8752 prototype: HTMLTableSectionElement;
8753 new(): HTMLTableSectionElement;
8756 /** Enables access to the contents of an HTML <template> element. */
8757 interface HTMLTemplateElement extends HTMLElement {
8758 readonly content: DocumentFragment;
8759 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTemplateElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8760 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8761 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTemplateElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8762 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8765 declare var HTMLTemplateElement: {
8766 prototype: HTMLTemplateElement;
8767 new(): HTMLTemplateElement;
8770 /** Provides special properties and methods for manipulating the layout and presentation of <textarea> elements. */
8771 interface HTMLTextAreaElement extends HTMLElement {
8772 autocomplete: string;
8774 * Sets or retrieves the width of the object.
8778 * Sets or retrieves the initial contents of the object.
8780 defaultValue: string;
8784 * Retrieves a reference to the form that the object is embedded in.
8786 readonly form: HTMLFormElement | null;
8787 readonly labels: NodeListOf<HTMLLabelElement>;
8789 * Sets or retrieves the maximum number of characters that the user can enter in a text control.
8794 * Sets or retrieves the name of the object.
8798 * 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.
8800 placeholder: string;
8802 * Sets or retrieves the value indicated whether the content of the object is read-only.
8806 * When present, marks an element that can't be submitted without a value.
8810 * Sets or retrieves the number of horizontal rows contained in the object.
8813 selectionDirection: "forward" | "backward" | "none";
8815 * Gets or sets the end position or offset of a text selection.
8817 selectionEnd: number;
8819 * Gets or sets the starting position or offset of a text selection.
8821 selectionStart: number;
8822 readonly textLength: number;
8824 * Retrieves the type of control.
8826 readonly type: string;
8828 * 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.
8830 readonly validationMessage: string;
8832 * Returns a ValidityState object that represents the validity states of an element.
8834 readonly validity: ValidityState;
8836 * Retrieves or sets the text in the entry field of the textArea element.
8840 * Returns whether an element will successfully validate based on forms validation rules and constraints.
8842 readonly willValidate: boolean;
8844 * Sets or retrieves how to handle wordwrapping in the object.
8848 * Returns whether a form will validate when it is submitted, without having to submit it.
8850 checkValidity(): boolean;
8851 reportValidity(): boolean;
8853 * Highlights the input area of a form element.
8857 * Sets a custom error message that is displayed when a form is submitted.
8858 * @param error Sets a custom error message that is displayed when a form is submitted.
8860 setCustomValidity(error: string): void;
8861 setRangeText(replacement: string): void;
8862 setRangeText(replacement: string, start: number, end: number, selectionMode?: SelectionMode): void;
8864 * Sets the start and end positions of a selection in a text field.
8865 * @param start The offset into the text field for the start of the selection.
8866 * @param end The offset into the text field for the end of the selection.
8867 * @param direction The direction in which the selection is performed.
8869 setSelectionRange(start: number, end: number, direction?: "forward" | "backward" | "none"): void;
8870 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTextAreaElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8871 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8872 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTextAreaElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8873 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8876 declare var HTMLTextAreaElement: {
8877 prototype: HTMLTextAreaElement;
8878 new(): HTMLTextAreaElement;
8881 /** Provides special properties (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating <time> elements. */
8882 interface HTMLTimeElement extends HTMLElement {
8884 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTimeElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8885 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8886 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTimeElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8887 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8890 declare var HTMLTimeElement: {
8891 prototype: HTMLTimeElement;
8892 new(): HTMLTimeElement;
8895 /** Contains the title for a document. This element inherits all of the properties and methods of the HTMLElement interface. */
8896 interface HTMLTitleElement extends HTMLElement {
8898 * Retrieves or sets the text of the object as a string.
8901 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTitleElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8902 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8903 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTitleElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8904 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8907 declare var HTMLTitleElement: {
8908 prototype: HTMLTitleElement;
8909 new(): HTMLTitleElement;
8912 /** The HTMLTrackElement */
8913 interface HTMLTrackElement extends HTMLElement {
8917 readonly readyState: number;
8920 readonly track: TextTrack;
8921 readonly ERROR: number;
8922 readonly LOADED: number;
8923 readonly LOADING: number;
8924 readonly NONE: number;
8925 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTrackElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8926 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8927 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTrackElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8928 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8931 declare var HTMLTrackElement: {
8932 prototype: HTMLTrackElement;
8933 new(): HTMLTrackElement;
8934 readonly ERROR: number;
8935 readonly LOADED: number;
8936 readonly LOADING: number;
8937 readonly NONE: number;
8940 /** Provides special properties (beyond those defined on the regular HTMLElement interface it also has available to it by inheritance) for manipulating unordered list elements. */
8941 interface HTMLUListElement extends HTMLElement {
8946 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLUListElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8947 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8948 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLUListElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8949 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8952 declare var HTMLUListElement: {
8953 prototype: HTMLUListElement;
8954 new(): HTMLUListElement;
8957 /** An invalid HTML element and derives from the HTMLElement interface, but without implementing any additional properties or methods. */
8958 interface HTMLUnknownElement extends HTMLElement {
8959 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLUnknownElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8960 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8961 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLUnknownElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8962 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8965 declare var HTMLUnknownElement: {
8966 prototype: HTMLUnknownElement;
8967 new(): HTMLUnknownElement;
8970 /** Provides special properties and methods for manipulating video objects. It also inherits properties and methods of HTMLMediaElement and HTMLElement. */
8971 interface HTMLVideoElement extends HTMLMediaElement {
8973 * Gets or sets the height of the video element.
8977 * Gets or sets the playsinline of the video element. for example, On iPhone, video elements will now be allowed to play inline, and will not automatically enter fullscreen mode when playback begins.
8979 playsInline: boolean;
8981 * 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.
8985 * Gets the intrinsic height of a video in CSS pixels, or zero if the dimensions are not known.
8987 readonly videoHeight: number;
8989 * Gets the intrinsic width of a video in CSS pixels, or zero if the dimensions are not known.
8991 readonly videoWidth: number;
8993 * Gets or sets the width of the video element.
8996 getVideoPlaybackQuality(): VideoPlaybackQuality;
8997 addEventListener<K extends keyof HTMLMediaElementEventMap>(type: K, listener: (this: HTMLVideoElement, ev: HTMLMediaElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8998 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8999 removeEventListener<K extends keyof HTMLMediaElementEventMap>(type: K, listener: (this: HTMLVideoElement, ev: HTMLMediaElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9000 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9003 declare var HTMLVideoElement: {
9004 prototype: HTMLVideoElement;
9005 new(): HTMLVideoElement;
9008 /** Events that fire when the fragment identifier of the URL has changed. */
9009 interface HashChangeEvent extends Event {
9011 * Returns the URL of the session history entry that is now current.
9013 readonly newURL: string;
9015 * Returns the URL of the session history entry that was previously current.
9017 readonly oldURL: string;
9020 declare var HashChangeEvent: {
9021 prototype: HashChangeEvent;
9022 new(type: string, eventInitDict?: HashChangeEventInit): HashChangeEvent;
9025 /** 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. */
9027 append(name: string, value: string): void;
9028 delete(name: string): void;
9029 get(name: string): string | null;
9030 has(name: string): boolean;
9031 set(name: string, value: string): void;
9032 forEach(callbackfn: (value: string, key: string, parent: Headers) => void, thisArg?: any): void;
9035 declare var Headers: {
9037 new(init?: HeadersInit): Headers;
9040 /** Allows manipulation of the browser session history, that is the pages visited in the tab or frame that the current page is loaded in. */
9042 readonly length: number;
9043 scrollRestoration: ScrollRestoration;
9044 readonly state: any;
9047 go(delta?: number): void;
9048 pushState(data: any, title: string, url?: string | null): void;
9049 replaceState(data: any, title: string, url?: string | null): void;
9052 declare var History: {
9057 interface IDBArrayKey extends Array<IDBValidKey> {
9060 /** This IndexedDB API interface represents a cursor for traversing or iterating over multiple records in a database. */
9061 interface IDBCursor {
9063 * Returns the direction ("next", "nextunique", "prev" or "prevunique") of the cursor.
9065 readonly direction: IDBCursorDirection;
9067 * Returns the key of the cursor. Throws a "InvalidStateError" DOMException if the cursor is advancing or is finished.
9069 readonly key: IDBValidKey;
9071 * Returns the effective key of the cursor. Throws a "InvalidStateError" DOMException if the cursor is advancing or is finished.
9073 readonly primaryKey: IDBValidKey;
9075 * Returns the IDBObjectStore or IDBIndex the cursor was opened from.
9077 readonly source: IDBObjectStore | IDBIndex;
9079 * Advances the cursor through the next count records in range.
9081 advance(count: number): void;
9083 * Advances the cursor to the next record in range.
9085 continue(key?: IDBValidKey): void;
9087 * 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.
9089 continuePrimaryKey(key: IDBValidKey, primaryKey: IDBValidKey): void;
9091 * Delete the record pointed at by the cursor with a new value.
9093 * If successful, request's result will be undefined.
9095 delete(): IDBRequest<undefined>;
9097 * Updated the record pointed at by the cursor with a new value.
9099 * Throws a "DataError" DOMException if the effective object store uses in-line keys and the key would have changed.
9101 * If successful, request's result will be the record's key.
9103 update(value: any): IDBRequest<IDBValidKey>;
9106 declare var IDBCursor: {
9107 prototype: IDBCursor;
9111 /** 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. */
9112 interface IDBCursorWithValue extends IDBCursor {
9114 * Returns the cursor's current value.
9116 readonly value: any;
9119 declare var IDBCursorWithValue: {
9120 prototype: IDBCursorWithValue;
9121 new(): IDBCursorWithValue;
9124 interface IDBDatabaseEventMap {
9128 "versionchange": IDBVersionChangeEvent;
9131 /** 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. */
9132 interface IDBDatabase extends EventTarget {
9134 * Returns the name of the database.
9136 readonly name: string;
9138 * Returns a list of the names of object stores in the database.
9140 readonly objectStoreNames: DOMStringList;
9141 onabort: ((this: IDBDatabase, ev: Event) => any) | null;
9142 onclose: ((this: IDBDatabase, ev: Event) => any) | null;
9143 onerror: ((this: IDBDatabase, ev: Event) => any) | null;
9144 onversionchange: ((this: IDBDatabase, ev: IDBVersionChangeEvent) => any) | null;
9146 * Returns the version of the database.
9148 readonly version: number;
9150 * Closes the connection once all running transactions have finished.
9154 * Creates a new object store with the given name and options and returns a new IDBObjectStore.
9156 * Throws a "InvalidStateError" DOMException if not called within an upgrade transaction.
9158 createObjectStore(name: string, options?: IDBObjectStoreParameters): IDBObjectStore;
9160 * Deletes the object store with the given name.
9162 * Throws a "InvalidStateError" DOMException if not called within an upgrade transaction.
9164 deleteObjectStore(name: string): void;
9166 * 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.
9168 transaction(storeNames: string | string[], mode?: IDBTransactionMode): IDBTransaction;
9169 addEventListener<K extends keyof IDBDatabaseEventMap>(type: K, listener: (this: IDBDatabase, ev: IDBDatabaseEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9170 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9171 removeEventListener<K extends keyof IDBDatabaseEventMap>(type: K, listener: (this: IDBDatabase, ev: IDBDatabaseEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9172 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9175 declare var IDBDatabase: {
9176 prototype: IDBDatabase;
9180 /** 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.) */
9181 interface IDBFactory {
9183 * Compares two values as keys. Returns -1 if key1 precedes key2, 1 if key2 precedes key1, and 0 if the keys are equal.
9185 * Throws a "DataError" DOMException if either input is not a valid key.
9187 cmp(first: any, second: any): number;
9189 * 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.
9191 deleteDatabase(name: string): IDBOpenDBRequest;
9193 * 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.
9195 open(name: string, version?: number): IDBOpenDBRequest;
9198 declare var IDBFactory: {
9199 prototype: IDBFactory;
9203 /** 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. */
9204 interface IDBIndex {
9205 readonly keyPath: string | string[];
9206 readonly multiEntry: boolean;
9208 * Returns the name of the index.
9212 * Returns the IDBObjectStore the index belongs to.
9214 readonly objectStore: IDBObjectStore;
9215 readonly unique: boolean;
9217 * Retrieves the number of records matching the given key or key range in query.
9219 * If successful, request's result will be the count.
9221 count(key?: IDBValidKey | IDBKeyRange): IDBRequest<number>;
9223 * Retrieves the value of the first record matching the given key or key range in query.
9225 * If successful, request's result will be the value, or undefined if there was no matching record.
9227 get(key: IDBValidKey | IDBKeyRange): IDBRequest<any | undefined>;
9229 * Retrieves the values of the records matching the given key or key range in query (up to count if given).
9231 * If successful, request's result will be an Array of the values.
9233 getAll(query?: IDBValidKey | IDBKeyRange | null, count?: number): IDBRequest<any[]>;
9235 * Retrieves the keys of records matching the given key or key range in query (up to count if given).
9237 * If successful, request's result will be an Array of the keys.
9239 getAllKeys(query?: IDBValidKey | IDBKeyRange | null, count?: number): IDBRequest<IDBValidKey[]>;
9241 * Retrieves the key of the first record matching the given key or key range in query.
9243 * If successful, request's result will be the key, or undefined if there was no matching record.
9245 getKey(key: IDBValidKey | IDBKeyRange): IDBRequest<IDBValidKey | undefined>;
9247 * Opens a cursor over the records matching query, ordered by direction. If query is null, all records in index are matched.
9249 * If successful, request's result will be an IDBCursorWithValue, or null if there were no matching records.
9251 openCursor(query?: IDBValidKey | IDBKeyRange | null, direction?: IDBCursorDirection): IDBRequest<IDBCursorWithValue | null>;
9253 * 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.
9255 * If successful, request's result will be an IDBCursor, or null if there were no matching records.
9257 openKeyCursor(query?: IDBValidKey | IDBKeyRange | null, direction?: IDBCursorDirection): IDBRequest<IDBCursor | null>;
9260 declare var IDBIndex: {
9261 prototype: IDBIndex;
9265 /** 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: */
9266 interface IDBKeyRange {
9268 * Returns lower bound, or undefined if none.
9270 readonly lower: any;
9272 * Returns true if the lower open flag is set, and false otherwise.
9274 readonly lowerOpen: boolean;
9276 * Returns upper bound, or undefined if none.
9278 readonly upper: any;
9280 * Returns true if the upper open flag is set, and false otherwise.
9282 readonly upperOpen: boolean;
9284 * Returns true if key is included in the range, and false otherwise.
9286 includes(key: any): boolean;
9289 declare var IDBKeyRange: {
9290 prototype: IDBKeyRange;
9293 * 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.
9295 bound(lower: any, upper: any, lowerOpen?: boolean, upperOpen?: boolean): IDBKeyRange;
9297 * Returns a new IDBKeyRange starting at key with no upper bound. If open is true, key is not included in the range.
9299 lowerBound(lower: any, open?: boolean): IDBKeyRange;
9301 * Returns a new IDBKeyRange spanning only key.
9303 only(value: any): IDBKeyRange;
9305 * Returns a new IDBKeyRange with no lower bound and ending at key. If open is true, key is not included in the range.
9307 upperBound(upper: any, open?: boolean): IDBKeyRange;
9310 /** 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.) */
9311 interface IDBObjectStore {
9313 * Returns true if the store has a key generator, and false otherwise.
9315 readonly autoIncrement: boolean;
9317 * Returns a list of the names of indexes in the store.
9319 readonly indexNames: DOMStringList;
9321 * Returns the key path of the store, or null if none.
9323 readonly keyPath: string | string[];
9325 * Returns the name of the store.
9329 * Returns the associated transaction.
9331 readonly transaction: IDBTransaction;
9333 * Adds or updates a record in store with the given value and key.
9335 * If the store uses in-line keys and key is specified a "DataError" DOMException will be thrown.
9337 * 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.
9339 * If successful, request's result will be the record's key.
9341 add(value: any, key?: IDBValidKey): IDBRequest<IDBValidKey>;
9343 * Deletes all records in store.
9345 * If successful, request's result will be undefined.
9347 clear(): IDBRequest<undefined>;
9349 * Retrieves the number of records matching the given key or key range in query.
9351 * If successful, request's result will be the count.
9353 count(key?: IDBValidKey | IDBKeyRange): IDBRequest<number>;
9355 * 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.
9357 * Throws an "InvalidStateError" DOMException if not called within an upgrade transaction.
9359 createIndex(name: string, keyPath: string | string[], options?: IDBIndexParameters): IDBIndex;
9361 * Deletes records in store with the given key or in the given key range in query.
9363 * If successful, request's result will be undefined.
9365 delete(key: IDBValidKey | IDBKeyRange): IDBRequest<undefined>;
9367 * Deletes the index in store with the given name.
9369 * Throws an "InvalidStateError" DOMException if not called within an upgrade transaction.
9371 deleteIndex(name: string): void;
9373 * Retrieves the value of the first record matching the given key or key range in query.
9375 * If successful, request's result will be the value, or undefined if there was no matching record.
9377 get(query: IDBValidKey | IDBKeyRange): IDBRequest<any | undefined>;
9379 * Retrieves the values of the records matching the given key or key range in query (up to count if given).
9381 * If successful, request's result will be an Array of the values.
9383 getAll(query?: IDBValidKey | IDBKeyRange | null, count?: number): IDBRequest<any[]>;
9385 * Retrieves the keys of records matching the given key or key range in query (up to count if given).
9387 * If successful, request's result will be an Array of the keys.
9389 getAllKeys(query?: IDBValidKey | IDBKeyRange | null, count?: number): IDBRequest<IDBValidKey[]>;
9391 * Retrieves the key of the first record matching the given key or key range in query.
9393 * If successful, request's result will be the key, or undefined if there was no matching record.
9395 getKey(query: IDBValidKey | IDBKeyRange): IDBRequest<IDBValidKey | undefined>;
9396 index(name: string): IDBIndex;
9398 * Opens a cursor over the records matching query, ordered by direction. If query is null, all records in store are matched.
9400 * If successful, request's result will be an IDBCursorWithValue pointing at the first matching record, or null if there were no matching records.
9402 openCursor(query?: IDBValidKey | IDBKeyRange | null, direction?: IDBCursorDirection): IDBRequest<IDBCursorWithValue | null>;
9404 * 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.
9406 * If successful, request's result will be an IDBCursor pointing at the first matching record, or null if there were no matching records.
9408 openKeyCursor(query?: IDBValidKey | IDBKeyRange | null, direction?: IDBCursorDirection): IDBRequest<IDBCursor | null>;
9410 * Adds or updates a record in store with the given value and key.
9412 * If the store uses in-line keys and key is specified a "DataError" DOMException will be thrown.
9414 * 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.
9416 * If successful, request's result will be the record's key.
9418 put(value: any, key?: IDBValidKey): IDBRequest<IDBValidKey>;
9421 declare var IDBObjectStore: {
9422 prototype: IDBObjectStore;
9423 new(): IDBObjectStore;
9426 interface IDBOpenDBRequestEventMap extends IDBRequestEventMap {
9428 "upgradeneeded": IDBVersionChangeEvent;
9431 /** Also inherits methods from its parents IDBRequest and EventTarget. */
9432 interface IDBOpenDBRequest extends IDBRequest<IDBDatabase> {
9433 onblocked: ((this: IDBOpenDBRequest, ev: Event) => any) | null;
9434 onupgradeneeded: ((this: IDBOpenDBRequest, ev: IDBVersionChangeEvent) => any) | null;
9435 addEventListener<K extends keyof IDBOpenDBRequestEventMap>(type: K, listener: (this: IDBOpenDBRequest, ev: IDBOpenDBRequestEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9436 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9437 removeEventListener<K extends keyof IDBOpenDBRequestEventMap>(type: K, listener: (this: IDBOpenDBRequest, ev: IDBOpenDBRequestEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9438 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9441 declare var IDBOpenDBRequest: {
9442 prototype: IDBOpenDBRequest;
9443 new(): IDBOpenDBRequest;
9446 interface IDBRequestEventMap {
9451 /** 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. */
9452 interface IDBRequest<T = any> extends EventTarget {
9454 * 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.
9456 readonly error: DOMException | null;
9457 onerror: ((this: IDBRequest<T>, ev: Event) => any) | null;
9458 onsuccess: ((this: IDBRequest<T>, ev: Event) => any) | null;
9460 * Returns "pending" until a request is complete, then returns "done".
9462 readonly readyState: IDBRequestReadyState;
9464 * When a request is completed, returns the result, or undefined if the request failed. Throws a "InvalidStateError" DOMException if the request is still pending.
9468 * Returns the IDBObjectStore, IDBIndex, or IDBCursor the request was made against, or null if is was an open request.
9470 readonly source: IDBObjectStore | IDBIndex | IDBCursor;
9472 * 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.
9474 readonly transaction: IDBTransaction | null;
9475 addEventListener<K extends keyof IDBRequestEventMap>(type: K, listener: (this: IDBRequest<T>, ev: IDBRequestEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9476 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9477 removeEventListener<K extends keyof IDBRequestEventMap>(type: K, listener: (this: IDBRequest<T>, ev: IDBRequestEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9478 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9481 declare var IDBRequest: {
9482 prototype: IDBRequest;
9486 interface IDBTransactionEventMap {
9492 interface IDBTransaction extends EventTarget {
9494 * Returns the transaction's connection.
9496 readonly db: IDBDatabase;
9498 * If the transaction was aborted, returns the error (a DOMException) providing the reason.
9500 readonly error: DOMException;
9502 * Returns the mode the transaction was created with ("readonly" or "readwrite"), or "versionchange" for an upgrade transaction.
9504 readonly mode: IDBTransactionMode;
9506 * 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.
9508 readonly objectStoreNames: DOMStringList;
9509 onabort: ((this: IDBTransaction, ev: Event) => any) | null;
9510 oncomplete: ((this: IDBTransaction, ev: Event) => any) | null;
9511 onerror: ((this: IDBTransaction, ev: Event) => any) | null;
9513 * Aborts the transaction. All pending requests will fail with a "AbortError" DOMException and all changes made to the database will be reverted.
9517 * Returns an IDBObjectStore in the transaction's scope.
9519 objectStore(name: string): IDBObjectStore;
9520 addEventListener<K extends keyof IDBTransactionEventMap>(type: K, listener: (this: IDBTransaction, ev: IDBTransactionEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9521 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9522 removeEventListener<K extends keyof IDBTransactionEventMap>(type: K, listener: (this: IDBTransaction, ev: IDBTransactionEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9523 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9526 declare var IDBTransaction: {
9527 prototype: IDBTransaction;
9528 new(): IDBTransaction;
9531 /** This IndexedDB API interface indicates that the version of the database has changed, as the result of an IDBOpenDBRequest.onupgradeneeded event handler function. */
9532 interface IDBVersionChangeEvent extends Event {
9533 readonly newVersion: number | null;
9534 readonly oldVersion: number;
9537 declare var IDBVersionChangeEvent: {
9538 prototype: IDBVersionChangeEvent;
9539 new(type: string, eventInitDict?: IDBVersionChangeEventInit): IDBVersionChangeEvent;
9542 /** 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. */
9543 interface IIRFilterNode extends AudioNode {
9544 getFrequencyResponse(frequencyHz: Float32Array, magResponse: Float32Array, phaseResponse: Float32Array): void;
9547 declare var IIRFilterNode: {
9548 prototype: IIRFilterNode;
9549 new(context: BaseAudioContext, options: IIRFilterOptions): IIRFilterNode;
9552 interface ImageBitmap {
9554 * Returns the intrinsic height of the image, in CSS pixels.
9556 readonly height: number;
9558 * Returns the intrinsic width of the image, in CSS pixels.
9560 readonly width: number;
9562 * Releases imageBitmap's underlying bitmap data.
9567 declare var ImageBitmap: {
9568 prototype: ImageBitmap;
9572 interface ImageBitmapRenderingContext {
9574 * Returns the canvas element that the context is bound to.
9576 readonly canvas: HTMLCanvasElement | OffscreenCanvas;
9578 * Transfers the underlying bitmap data from imageBitmap to context, and the bitmap becomes the contents of the canvas element to which context is bound.
9580 transferFromImageBitmap(bitmap: ImageBitmap | null): void;
9583 declare var ImageBitmapRenderingContext: {
9584 prototype: ImageBitmapRenderingContext;
9585 new(): ImageBitmapRenderingContext;
9588 /** 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(). */
9589 interface ImageData {
9591 * Returns the one-dimensional array containing the data in RGBA order, as integers in the range 0 to 255.
9593 readonly data: Uint8ClampedArray;
9595 * Returns the actual dimensions of the data in the ImageData object, in pixels.
9597 readonly height: number;
9599 * Returns the actual dimensions of the data in the ImageData object, in pixels.
9601 readonly width: number;
9604 declare var ImageData: {
9605 prototype: ImageData;
9606 new(sw: number, sh: number): ImageData;
9607 new(data: Uint8ClampedArray, sw: number, sh?: number): ImageData;
9610 interface InnerHTML {
9614 interface InputDeviceInfo extends MediaDeviceInfo {
9615 getCapabilities(): MediaTrackCapabilities;
9618 declare var InputDeviceInfo: {
9619 prototype: InputDeviceInfo;
9620 new(): InputDeviceInfo;
9623 interface InputEvent extends UIEvent {
9624 readonly data: string | null;
9625 readonly inputType: string;
9626 readonly isComposing: boolean;
9629 declare var InputEvent: {
9630 prototype: InputEvent;
9631 new(type: string, eventInitDict?: InputEventInit): InputEvent;
9634 /** 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. */
9635 interface IntersectionObserver {
9636 readonly root: Element | null;
9637 readonly rootMargin: string;
9638 readonly thresholds: ReadonlyArray<number>;
9640 observe(target: Element): void;
9641 takeRecords(): IntersectionObserverEntry[];
9642 unobserve(target: Element): void;
9645 declare var IntersectionObserver: {
9646 prototype: IntersectionObserver;
9647 new(callback: IntersectionObserverCallback, options?: IntersectionObserverInit): IntersectionObserver;
9650 /** This Intersection Observer API interface describes the intersection between the target element and its root container at a specific moment of transition. */
9651 interface IntersectionObserverEntry {
9652 readonly boundingClientRect: DOMRectReadOnly;
9653 readonly intersectionRatio: number;
9654 readonly intersectionRect: DOMRectReadOnly;
9655 readonly isIntersecting: boolean;
9656 readonly rootBounds: DOMRectReadOnly | null;
9657 readonly target: Element;
9658 readonly time: number;
9661 declare var IntersectionObserverEntry: {
9662 prototype: IntersectionObserverEntry;
9663 new(intersectionObserverEntryInit: IntersectionObserverEntryInit): IntersectionObserverEntry;
9666 /** 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. */
9667 interface KeyboardEvent extends UIEvent {
9668 readonly altKey: boolean;
9672 readonly charCode: number;
9673 readonly code: string;
9674 readonly ctrlKey: boolean;
9675 readonly isComposing: boolean;
9676 readonly key: string;
9678 readonly keyCode: number;
9679 readonly location: number;
9680 readonly metaKey: boolean;
9681 readonly repeat: boolean;
9682 readonly shiftKey: boolean;
9683 getModifierState(keyArg: string): boolean;
9684 readonly DOM_KEY_LOCATION_LEFT: number;
9685 readonly DOM_KEY_LOCATION_NUMPAD: number;
9686 readonly DOM_KEY_LOCATION_RIGHT: number;
9687 readonly DOM_KEY_LOCATION_STANDARD: number;
9690 declare var KeyboardEvent: {
9691 prototype: KeyboardEvent;
9692 new(type: string, eventInitDict?: KeyboardEventInit): KeyboardEvent;
9693 readonly DOM_KEY_LOCATION_LEFT: number;
9694 readonly DOM_KEY_LOCATION_NUMPAD: number;
9695 readonly DOM_KEY_LOCATION_RIGHT: number;
9696 readonly DOM_KEY_LOCATION_STANDARD: number;
9699 interface KeyframeEffect extends AnimationEffect {
9700 composite: CompositeOperation;
9701 iterationComposite: IterationCompositeOperation;
9702 target: Element | null;
9703 getKeyframes(): ComputedKeyframe[];
9704 setKeyframes(keyframes: Keyframe[] | PropertyIndexedKeyframes | null): void;
9707 declare var KeyframeEffect: {
9708 prototype: KeyframeEffect;
9709 new(target: Element | null, keyframes: Keyframe[] | PropertyIndexedKeyframes | null, options?: number | KeyframeEffectOptions): KeyframeEffect;
9710 new(source: KeyframeEffect): KeyframeEffect;
9713 interface LinkStyle {
9714 readonly sheet: CSSStyleSheet | null;
9717 interface ListeningStateChangedEvent extends Event {
9718 readonly label: string;
9719 readonly state: ListeningState;
9722 declare var ListeningStateChangedEvent: {
9723 prototype: ListeningStateChangedEvent;
9724 new(): ListeningStateChangedEvent;
9727 /** 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. */
9728 interface Location {
9730 * Returns a DOMStringList object listing the origins of the ancestor browsing contexts, from the parent browsing context to the top-level browsing context.
9732 readonly ancestorOrigins: DOMStringList;
9734 * Returns the Location object's URL's fragment (includes leading "#" if non-empty).
9736 * Can be set, to navigate to the same URL with a changed fragment (ignores leading "#").
9740 * Returns the Location object's URL's host and port (if different from the default port for the scheme).
9742 * Can be set, to navigate to the same URL with a changed host and port.
9746 * Returns the Location object's URL's host.
9748 * Can be set, to navigate to the same URL with a changed host.
9752 * Returns the Location object's URL.
9754 * Can be set, to navigate to the given URL.
9759 * Returns the Location object's URL's origin.
9761 readonly origin: string;
9763 * Returns the Location object's URL's path.
9765 * Can be set, to navigate to the same URL with a changed path.
9769 * Returns the Location object's URL's port.
9771 * Can be set, to navigate to the same URL with a changed port.
9775 * Returns the Location object's URL's scheme.
9777 * Can be set, to navigate to the same URL with a changed scheme.
9781 * Returns the Location object's URL's query (includes leading "?" if non-empty).
9783 * Can be set, to navigate to the same URL with a changed query (ignores leading "?").
9787 * Navigates to the given URL.
9789 assign(url: string): void;
9791 * Reloads the current page.
9795 reload(forcedReload: boolean): void;
9797 * Removes the current page from the session history and navigates to the given URL.
9799 replace(url: string): void;
9802 declare var Location: {
9803 prototype: Location;
9807 interface MSAssertion {
9808 readonly id: string;
9809 readonly type: MSCredentialType;
9812 declare var MSAssertion: {
9813 prototype: MSAssertion;
9817 interface MSBlobBuilder {
9818 append(data: any, endings?: string): void;
9819 getBlob(contentType?: string): Blob;
9822 declare var MSBlobBuilder: {
9823 prototype: MSBlobBuilder;
9824 new(): MSBlobBuilder;
9827 interface MSFIDOCredentialAssertion extends MSAssertion {
9828 readonly algorithm: string | Algorithm;
9829 readonly attestation: any;
9830 readonly publicKey: string;
9831 readonly transportHints: MSTransportType[];
9834 declare var MSFIDOCredentialAssertion: {
9835 prototype: MSFIDOCredentialAssertion;
9836 new(): MSFIDOCredentialAssertion;
9839 interface MSFIDOSignature {
9840 readonly authnrData: string;
9841 readonly clientData: string;
9842 readonly signature: string;
9845 declare var MSFIDOSignature: {
9846 prototype: MSFIDOSignature;
9847 new(): MSFIDOSignature;
9850 interface MSFIDOSignatureAssertion extends MSAssertion {
9851 readonly signature: MSFIDOSignature;
9854 declare var MSFIDOSignatureAssertion: {
9855 prototype: MSFIDOSignatureAssertion;
9856 new(): MSFIDOSignatureAssertion;
9859 interface MSFileSaver {
9860 msSaveBlob(blob: any, defaultName?: string): boolean;
9861 msSaveOrOpenBlob(blob: any, defaultName?: string): boolean;
9864 interface MSGesture {
9866 addPointer(pointerId: number): void;
9870 declare var MSGesture: {
9871 prototype: MSGesture;
9875 /** 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. */
9876 interface MSGestureEvent extends UIEvent {
9877 readonly clientX: number;
9878 readonly clientY: number;
9879 readonly expansion: number;
9880 readonly gestureObject: any;
9881 readonly hwTimestamp: number;
9882 readonly offsetX: number;
9883 readonly offsetY: number;
9884 readonly rotation: number;
9885 readonly scale: number;
9886 readonly screenX: number;
9887 readonly screenY: number;
9888 readonly translationX: number;
9889 readonly translationY: number;
9890 readonly velocityAngular: number;
9891 readonly velocityExpansion: number;
9892 readonly velocityX: number;
9893 readonly velocityY: number;
9894 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;
9895 readonly MSGESTURE_FLAG_BEGIN: number;
9896 readonly MSGESTURE_FLAG_CANCEL: number;
9897 readonly MSGESTURE_FLAG_END: number;
9898 readonly MSGESTURE_FLAG_INERTIA: number;
9899 readonly MSGESTURE_FLAG_NONE: number;
9902 declare var MSGestureEvent: {
9903 prototype: MSGestureEvent;
9904 new(): MSGestureEvent;
9905 readonly MSGESTURE_FLAG_BEGIN: number;
9906 readonly MSGESTURE_FLAG_CANCEL: number;
9907 readonly MSGESTURE_FLAG_END: number;
9908 readonly MSGESTURE_FLAG_INERTIA: number;
9909 readonly MSGESTURE_FLAG_NONE: number;
9912 /** The msGraphicsTrust() constructor returns an object that provides properties for info on protected video playback. */
9913 interface MSGraphicsTrust {
9914 readonly constrictionActive: boolean;
9915 readonly status: string;
9918 declare var MSGraphicsTrust: {
9919 prototype: MSGraphicsTrust;
9920 new(): MSGraphicsTrust;
9923 interface MSInputMethodContextEventMap {
9924 "MSCandidateWindowHide": Event;
9925 "MSCandidateWindowShow": Event;
9926 "MSCandidateWindowUpdate": Event;
9929 interface MSInputMethodContext extends EventTarget {
9930 readonly compositionEndOffset: number;
9931 readonly compositionStartOffset: number;
9932 oncandidatewindowhide: ((this: MSInputMethodContext, ev: Event) => any) | null;
9933 oncandidatewindowshow: ((this: MSInputMethodContext, ev: Event) => any) | null;
9934 oncandidatewindowupdate: ((this: MSInputMethodContext, ev: Event) => any) | null;
9935 readonly target: HTMLElement;
9936 getCandidateWindowClientRect(): ClientRect;
9937 getCompositionAlternatives(): string[];
9938 hasComposition(): boolean;
9939 isCandidateWindowVisible(): boolean;
9940 addEventListener<K extends keyof MSInputMethodContextEventMap>(type: K, listener: (this: MSInputMethodContext, ev: MSInputMethodContextEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9941 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9942 removeEventListener<K extends keyof MSInputMethodContextEventMap>(type: K, listener: (this: MSInputMethodContext, ev: MSInputMethodContextEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9943 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9946 declare var MSInputMethodContext: {
9947 prototype: MSInputMethodContext;
9948 new(): MSInputMethodContext;
9951 interface MSMediaKeyError {
9952 readonly code: number;
9953 readonly systemCode: number;
9954 readonly MS_MEDIA_KEYERR_CLIENT: number;
9955 readonly MS_MEDIA_KEYERR_DOMAIN: number;
9956 readonly MS_MEDIA_KEYERR_HARDWARECHANGE: number;
9957 readonly MS_MEDIA_KEYERR_OUTPUT: number;
9958 readonly MS_MEDIA_KEYERR_SERVICE: number;
9959 readonly MS_MEDIA_KEYERR_UNKNOWN: number;
9962 declare var MSMediaKeyError: {
9963 prototype: MSMediaKeyError;
9964 new(): MSMediaKeyError;
9965 readonly MS_MEDIA_KEYERR_CLIENT: number;
9966 readonly MS_MEDIA_KEYERR_DOMAIN: number;
9967 readonly MS_MEDIA_KEYERR_HARDWARECHANGE: number;
9968 readonly MS_MEDIA_KEYERR_OUTPUT: number;
9969 readonly MS_MEDIA_KEYERR_SERVICE: number;
9970 readonly MS_MEDIA_KEYERR_UNKNOWN: number;
9973 interface MSMediaKeyMessageEvent extends Event {
9974 readonly destinationURL: string | null;
9975 readonly message: Uint8Array;
9978 declare var MSMediaKeyMessageEvent: {
9979 prototype: MSMediaKeyMessageEvent;
9980 new(): MSMediaKeyMessageEvent;
9983 interface MSMediaKeyNeededEvent extends Event {
9984 readonly initData: Uint8Array | null;
9987 declare var MSMediaKeyNeededEvent: {
9988 prototype: MSMediaKeyNeededEvent;
9989 new(): MSMediaKeyNeededEvent;
9992 interface MSMediaKeySession extends EventTarget {
9993 readonly error: MSMediaKeyError | null;
9994 readonly keySystem: string;
9995 readonly sessionId: string;
9997 update(key: Uint8Array): void;
10000 declare var MSMediaKeySession: {
10001 prototype: MSMediaKeySession;
10002 new(): MSMediaKeySession;
10005 interface MSMediaKeys {
10006 readonly keySystem: string;
10007 createSession(type: string, initData: Uint8Array, cdmData?: Uint8Array | null): MSMediaKeySession;
10010 declare var MSMediaKeys: {
10011 prototype: MSMediaKeys;
10012 new(keySystem: string): MSMediaKeys;
10013 isTypeSupported(keySystem: string, type?: string | null): boolean;
10014 isTypeSupportedWithFeatures(keySystem: string, type?: string | null): string;
10017 interface MSNavigatorDoNotTrack {
10018 confirmSiteSpecificTrackingException(args: ConfirmSiteSpecificExceptionsInformation): boolean;
10019 confirmWebWideTrackingException(args: ExceptionInformation): boolean;
10020 removeSiteSpecificTrackingException(args: ExceptionInformation): void;
10021 removeWebWideTrackingException(args: ExceptionInformation): void;
10022 storeSiteSpecificTrackingException(args: StoreSiteSpecificExceptionsInformation): void;
10023 storeWebWideTrackingException(args: StoreExceptionsInformation): void;
10026 interface MSPointerEvent extends MouseEvent {
10027 readonly currentPoint: any;
10028 readonly height: number;
10029 readonly hwTimestamp: number;
10030 readonly intermediatePoints: any;
10031 readonly isPrimary: boolean;
10032 readonly pointerId: number;
10033 readonly pointerType: any;
10034 readonly pressure: number;
10035 readonly rotation: number;
10036 readonly tiltX: number;
10037 readonly tiltY: number;
10038 readonly width: number;
10039 getCurrentPoint(element: Element): void;
10040 getIntermediatePoints(element: Element): void;
10041 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;
10044 declare var MSPointerEvent: {
10045 prototype: MSPointerEvent;
10046 new(typeArg: string, eventInitDict?: PointerEventInit): MSPointerEvent;
10049 interface MSStream {
10050 readonly type: string;
10052 msDetachStream(): any;
10055 declare var MSStream: {
10056 prototype: MSStream;
10060 /** The MediaDevicesInfo interface contains information that describes a single media input or output device. */
10061 interface MediaDeviceInfo {
10062 readonly deviceId: string;
10063 readonly groupId: string;
10064 readonly kind: MediaDeviceKind;
10065 readonly label: string;
10069 declare var MediaDeviceInfo: {
10070 prototype: MediaDeviceInfo;
10071 new(): MediaDeviceInfo;
10074 interface MediaDevicesEventMap {
10075 "devicechange": Event;
10078 /** 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. */
10079 interface MediaDevices extends EventTarget {
10080 ondevicechange: ((this: MediaDevices, ev: Event) => any) | null;
10081 enumerateDevices(): Promise<MediaDeviceInfo[]>;
10082 getSupportedConstraints(): MediaTrackSupportedConstraints;
10083 getUserMedia(constraints?: MediaStreamConstraints): Promise<MediaStream>;
10084 addEventListener<K extends keyof MediaDevicesEventMap>(type: K, listener: (this: MediaDevices, ev: MediaDevicesEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10085 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10086 removeEventListener<K extends keyof MediaDevicesEventMap>(type: K, listener: (this: MediaDevices, ev: MediaDevicesEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10087 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10090 declare var MediaDevices: {
10091 prototype: MediaDevices;
10092 new(): MediaDevices;
10095 /** 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. */
10096 interface MediaElementAudioSourceNode extends AudioNode {
10097 readonly mediaElement: HTMLMediaElement;
10100 declare var MediaElementAudioSourceNode: {
10101 prototype: MediaElementAudioSourceNode;
10102 new(context: AudioContext, options: MediaElementAudioSourceOptions): MediaElementAudioSourceNode;
10105 interface MediaEncryptedEvent extends Event {
10106 readonly initData: ArrayBuffer | null;
10107 readonly initDataType: string;
10110 declare var MediaEncryptedEvent: {
10111 prototype: MediaEncryptedEvent;
10112 new(type: string, eventInitDict?: MediaEncryptedEventInit): MediaEncryptedEvent;
10115 /** An error which occurred while handling media in an HTML media element based on HTMLMediaElement, such as <audio> or <video>. */
10116 interface MediaError {
10117 readonly code: number;
10118 readonly message: string;
10119 readonly MEDIA_ERR_ABORTED: number;
10120 readonly MEDIA_ERR_DECODE: number;
10121 readonly MEDIA_ERR_NETWORK: number;
10122 readonly MEDIA_ERR_SRC_NOT_SUPPORTED: number;
10125 declare var MediaError: {
10126 prototype: MediaError;
10128 readonly MEDIA_ERR_ABORTED: number;
10129 readonly MEDIA_ERR_DECODE: number;
10130 readonly MEDIA_ERR_NETWORK: number;
10131 readonly MEDIA_ERR_SRC_NOT_SUPPORTED: number;
10134 /** This EncryptedMediaExtensions API interface contains the content and related data when the content decryption module generates a message for the session. */
10135 interface MediaKeyMessageEvent extends Event {
10136 readonly message: ArrayBuffer;
10137 readonly messageType: MediaKeyMessageType;
10140 declare var MediaKeyMessageEvent: {
10141 prototype: MediaKeyMessageEvent;
10142 new(type: string, eventInitDict: MediaKeyMessageEventInit): MediaKeyMessageEvent;
10145 interface MediaKeySessionEventMap {
10146 "keystatuseschange": Event;
10147 "message": MediaKeyMessageEvent;
10150 /** This EncryptedMediaExtensions API interface represents a context for message exchange with a content decryption module (CDM). */
10151 interface MediaKeySession extends EventTarget {
10152 readonly closed: Promise<void>;
10153 readonly expiration: number;
10154 readonly keyStatuses: MediaKeyStatusMap;
10155 onkeystatuseschange: ((this: MediaKeySession, ev: Event) => any) | null;
10156 onmessage: ((this: MediaKeySession, ev: MediaKeyMessageEvent) => any) | null;
10157 readonly sessionId: string;
10158 close(): Promise<void>;
10159 generateRequest(initDataType: string, initData: BufferSource): Promise<void>;
10160 load(sessionId: string): Promise<boolean>;
10161 remove(): Promise<void>;
10162 update(response: BufferSource): Promise<void>;
10163 addEventListener<K extends keyof MediaKeySessionEventMap>(type: K, listener: (this: MediaKeySession, ev: MediaKeySessionEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10164 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10165 removeEventListener<K extends keyof MediaKeySessionEventMap>(type: K, listener: (this: MediaKeySession, ev: MediaKeySessionEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10166 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10169 declare var MediaKeySession: {
10170 prototype: MediaKeySession;
10171 new(): MediaKeySession;
10174 /** This EncryptedMediaExtensions API interface is a read-only map of media key statuses by key IDs. */
10175 interface MediaKeyStatusMap {
10176 readonly size: number;
10177 get(keyId: BufferSource): MediaKeyStatus | undefined;
10178 has(keyId: BufferSource): boolean;
10179 forEach(callbackfn: (value: MediaKeyStatus, key: BufferSource, parent: MediaKeyStatusMap) => void, thisArg?: any): void;
10182 declare var MediaKeyStatusMap: {
10183 prototype: MediaKeyStatusMap;
10184 new(): MediaKeyStatusMap;
10187 /** 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. */
10188 interface MediaKeySystemAccess {
10189 readonly keySystem: string;
10190 createMediaKeys(): Promise<MediaKeys>;
10191 getConfiguration(): MediaKeySystemConfiguration;
10194 declare var MediaKeySystemAccess: {
10195 prototype: MediaKeySystemAccess;
10196 new(): MediaKeySystemAccess;
10199 /** This EncryptedMediaExtensions API interface the represents a set of keys that an associated HTMLMediaElement can use for decryption of media data during playback. */
10200 interface MediaKeys {
10201 createSession(sessionType?: MediaKeySessionType): MediaKeySession;
10202 setServerCertificate(serverCertificate: BufferSource): Promise<boolean>;
10205 declare var MediaKeys: {
10206 prototype: MediaKeys;
10210 interface MediaList {
10211 readonly length: number;
10213 toString(): string;
10214 appendMedium(medium: string): void;
10215 deleteMedium(medium: string): void;
10216 item(index: number): string | null;
10217 [index: number]: string;
10220 declare var MediaList: {
10221 prototype: MediaList;
10225 interface MediaQueryListEventMap {
10226 "change": MediaQueryListEvent;
10229 /** 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). */
10230 interface MediaQueryList extends EventTarget {
10231 readonly matches: boolean;
10232 readonly media: string;
10233 onchange: ((this: MediaQueryList, ev: MediaQueryListEvent) => any) | null;
10235 addListener(listener: ((this: MediaQueryList, ev: MediaQueryListEvent) => any) | null): void;
10237 removeListener(listener: ((this: MediaQueryList, ev: MediaQueryListEvent) => any) | null): void;
10238 addEventListener<K extends keyof MediaQueryListEventMap>(type: K, listener: (this: MediaQueryList, ev: MediaQueryListEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10239 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10240 removeEventListener<K extends keyof MediaQueryListEventMap>(type: K, listener: (this: MediaQueryList, ev: MediaQueryListEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10241 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10244 declare var MediaQueryList: {
10245 prototype: MediaQueryList;
10246 new(): MediaQueryList;
10249 interface MediaQueryListEvent extends Event {
10250 readonly matches: boolean;
10251 readonly media: string;
10254 declare var MediaQueryListEvent: {
10255 prototype: MediaQueryListEvent;
10256 new(type: string, eventInitDict?: MediaQueryListEventInit): MediaQueryListEvent;
10259 interface MediaSourceEventMap {
10260 "sourceclose": Event;
10261 "sourceended": Event;
10262 "sourceopen": Event;
10265 /** 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. */
10266 interface MediaSource extends EventTarget {
10267 readonly activeSourceBuffers: SourceBufferList;
10269 onsourceclose: ((this: MediaSource, ev: Event) => any) | null;
10270 onsourceended: ((this: MediaSource, ev: Event) => any) | null;
10271 onsourceopen: ((this: MediaSource, ev: Event) => any) | null;
10272 readonly readyState: ReadyState;
10273 readonly sourceBuffers: SourceBufferList;
10274 addSourceBuffer(type: string): SourceBuffer;
10275 clearLiveSeekableRange(): void;
10276 endOfStream(error?: EndOfStreamError): void;
10277 removeSourceBuffer(sourceBuffer: SourceBuffer): void;
10278 setLiveSeekableRange(start: number, end: number): void;
10279 addEventListener<K extends keyof MediaSourceEventMap>(type: K, listener: (this: MediaSource, ev: MediaSourceEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10280 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10281 removeEventListener<K extends keyof MediaSourceEventMap>(type: K, listener: (this: MediaSource, ev: MediaSourceEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10282 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10285 declare var MediaSource: {
10286 prototype: MediaSource;
10287 new(): MediaSource;
10288 isTypeSupported(type: string): boolean;
10291 interface MediaStreamEventMap {
10292 "addtrack": MediaStreamTrackEvent;
10293 "removetrack": MediaStreamTrackEvent;
10296 /** 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. */
10297 interface MediaStream extends EventTarget {
10298 readonly active: boolean;
10299 readonly id: string;
10300 onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
10301 onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
10302 addTrack(track: MediaStreamTrack): void;
10303 clone(): MediaStream;
10304 getAudioTracks(): MediaStreamTrack[];
10305 getTrackById(trackId: string): MediaStreamTrack | null;
10306 getTracks(): MediaStreamTrack[];
10307 getVideoTracks(): MediaStreamTrack[];
10308 removeTrack(track: MediaStreamTrack): void;
10309 addEventListener<K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10310 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10311 removeEventListener<K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10312 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10315 declare var MediaStream: {
10316 prototype: MediaStream;
10317 new(): MediaStream;
10318 new(stream: MediaStream): MediaStream;
10319 new(tracks: MediaStreamTrack[]): MediaStream;
10322 interface MediaStreamAudioDestinationNode extends AudioNode {
10323 readonly stream: MediaStream;
10326 declare var MediaStreamAudioDestinationNode: {
10327 prototype: MediaStreamAudioDestinationNode;
10328 new(context: AudioContext, options?: AudioNodeOptions): MediaStreamAudioDestinationNode;
10331 /** 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. */
10332 interface MediaStreamAudioSourceNode extends AudioNode {
10333 readonly mediaStream: MediaStream;
10336 declare var MediaStreamAudioSourceNode: {
10337 prototype: MediaStreamAudioSourceNode;
10338 new(context: AudioContext, options: MediaStreamAudioSourceOptions): MediaStreamAudioSourceNode;
10341 interface MediaStreamError {
10342 readonly constraintName: string | null;
10343 readonly message: string | null;
10344 readonly name: string;
10347 declare var MediaStreamError: {
10348 prototype: MediaStreamError;
10349 new(): MediaStreamError;
10352 interface MediaStreamErrorEvent extends Event {
10353 readonly error: MediaStreamError | null;
10356 declare var MediaStreamErrorEvent: {
10357 prototype: MediaStreamErrorEvent;
10358 new(typeArg: string, eventInitDict?: MediaStreamErrorEventInit): MediaStreamErrorEvent;
10361 /** Events that occurs in relation to a MediaStream. Two events of this type can be thrown: addstream and removestream. */
10362 interface MediaStreamEvent extends Event {
10363 readonly stream: MediaStream | null;
10366 declare var MediaStreamEvent: {
10367 prototype: MediaStreamEvent;
10368 new(type: string, eventInitDict: MediaStreamEventInit): MediaStreamEvent;
10371 interface MediaStreamTrackEventMap {
10373 "isolationchange": Event;
10378 /** A single media track within a stream; typically, these are audio or video tracks, but other track types may exist as well. */
10379 interface MediaStreamTrack extends EventTarget {
10381 readonly id: string;
10382 readonly isolated: boolean;
10383 readonly kind: string;
10384 readonly label: string;
10385 readonly muted: boolean;
10386 onended: ((this: MediaStreamTrack, ev: Event) => any) | null;
10387 onisolationchange: ((this: MediaStreamTrack, ev: Event) => any) | null;
10388 onmute: ((this: MediaStreamTrack, ev: Event) => any) | null;
10389 onunmute: ((this: MediaStreamTrack, ev: Event) => any) | null;
10390 readonly readyState: MediaStreamTrackState;
10391 applyConstraints(constraints?: MediaTrackConstraints): Promise<void>;
10392 clone(): MediaStreamTrack;
10393 getCapabilities(): MediaTrackCapabilities;
10394 getConstraints(): MediaTrackConstraints;
10395 getSettings(): MediaTrackSettings;
10397 addEventListener<K extends keyof MediaStreamTrackEventMap>(type: K, listener: (this: MediaStreamTrack, ev: MediaStreamTrackEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10398 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10399 removeEventListener<K extends keyof MediaStreamTrackEventMap>(type: K, listener: (this: MediaStreamTrack, ev: MediaStreamTrackEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10400 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10403 declare var MediaStreamTrack: {
10404 prototype: MediaStreamTrack;
10405 new(): MediaStreamTrack;
10408 interface MediaStreamTrackAudioSourceNode extends AudioNode {
10411 declare var MediaStreamTrackAudioSourceNode: {
10412 prototype: MediaStreamTrackAudioSourceNode;
10413 new(context: AudioContext, options: MediaStreamTrackAudioSourceOptions): MediaStreamTrackAudioSourceNode;
10416 /** 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. */
10417 interface MediaStreamTrackEvent extends Event {
10418 readonly track: MediaStreamTrack;
10421 declare var MediaStreamTrackEvent: {
10422 prototype: MediaStreamTrackEvent;
10423 new(type: string, eventInitDict: MediaStreamTrackEventInit): MediaStreamTrackEvent;
10426 /** This Channel Messaging API interface allows us to create a new message channel and send data through it via its two MessagePort properties. */
10427 interface MessageChannel {
10429 * Returns the first MessagePort object.
10431 readonly port1: MessagePort;
10433 * Returns the second MessagePort object.
10435 readonly port2: MessagePort;
10438 declare var MessageChannel: {
10439 prototype: MessageChannel;
10440 new(): MessageChannel;
10443 /** A message received by a target object. */
10444 interface MessageEvent<T = any> extends Event {
10446 * Returns the data of the message.
10450 * Returns the last event ID string, for server-sent events.
10452 readonly lastEventId: string;
10454 * Returns the origin of the message, for server-sent events and cross-document messaging.
10456 readonly origin: string;
10458 * Returns the MessagePort array sent with the message, for cross-document messaging and channel messaging.
10460 readonly ports: ReadonlyArray<MessagePort>;
10462 * Returns the WindowProxy of the source window, for cross-document messaging, and the MessagePort being attached, in the connect event fired at SharedWorkerGlobalScope objects.
10464 readonly source: MessageEventSource | null;
10467 declare var MessageEvent: {
10468 prototype: MessageEvent;
10469 new<T>(type: string, eventInitDict?: MessageEventInit<T>): MessageEvent<T>;
10472 interface MessagePortEventMap {
10473 "message": MessageEvent;
10474 "messageerror": MessageEvent;
10477 /** 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. */
10478 interface MessagePort extends EventTarget {
10479 onmessage: ((this: MessagePort, ev: MessageEvent) => any) | null;
10480 onmessageerror: ((this: MessagePort, ev: MessageEvent) => any) | null;
10482 * Disconnects the port, so that it is no longer active.
10486 * 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.
10488 * Throws a "DataCloneError" DOMException if transfer contains duplicate objects or port, or if message could not be cloned.
10490 postMessage(message: any, transfer: Transferable[]): void;
10491 postMessage(message: any, options?: PostMessageOptions): void;
10493 * Begins dispatching messages received on the port.
10496 addEventListener<K extends keyof MessagePortEventMap>(type: K, listener: (this: MessagePort, ev: MessagePortEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10497 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10498 removeEventListener<K extends keyof MessagePortEventMap>(type: K, listener: (this: MessagePort, ev: MessagePortEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10499 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10502 declare var MessagePort: {
10503 prototype: MessagePort;
10504 new(): MessagePort;
10507 /** Provides contains information about a MIME type associated with a particular plugin. NavigatorPlugins.mimeTypes returns an array of this object. */
10508 interface MimeType {
10510 * Returns the MIME type's description.
10512 readonly description: string;
10514 * Returns the Plugin object that implements this MIME type.
10516 readonly enabledPlugin: Plugin;
10518 * Returns the MIME type's typical file extensions, in a comma-separated list.
10520 readonly suffixes: string;
10522 * Returns the MIME type.
10524 readonly type: string;
10527 declare var MimeType: {
10528 prototype: MimeType;
10532 /** Returns an array of MimeType instances, each of which contains information about a supported browser plugins. This object is returned by NavigatorPlugins.mimeTypes. */
10533 interface MimeTypeArray {
10534 readonly length: number;
10535 item(index: number): MimeType | null;
10536 namedItem(name: string): MimeType | null;
10537 [index: number]: MimeType;
10540 declare var MimeTypeArray: {
10541 prototype: MimeTypeArray;
10542 new(): MimeTypeArray;
10545 /** 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. */
10546 interface MouseEvent extends UIEvent {
10547 readonly altKey: boolean;
10548 readonly button: number;
10549 readonly buttons: number;
10550 readonly clientX: number;
10551 readonly clientY: number;
10552 readonly ctrlKey: boolean;
10553 readonly metaKey: boolean;
10554 readonly movementX: number;
10555 readonly movementY: number;
10556 readonly offsetX: number;
10557 readonly offsetY: number;
10558 readonly pageX: number;
10559 readonly pageY: number;
10560 readonly relatedTarget: EventTarget | null;
10561 readonly screenX: number;
10562 readonly screenY: number;
10563 readonly shiftKey: boolean;
10564 readonly x: number;
10565 readonly y: number;
10566 getModifierState(keyArg: string): boolean;
10567 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;
10570 declare var MouseEvent: {
10571 prototype: MouseEvent;
10572 new(type: string, eventInitDict?: MouseEventInit): MouseEvent;
10575 /** Provides event properties that are specific to modifications to the Document Object Model (DOM) hierarchy and nodes. */
10576 interface MutationEvent extends Event {
10577 readonly attrChange: number;
10578 readonly attrName: string;
10579 readonly newValue: string;
10580 readonly prevValue: string;
10581 readonly relatedNode: Node;
10582 initMutationEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, relatedNodeArg: Node, prevValueArg: string, newValueArg: string, attrNameArg: string, attrChangeArg: number): void;
10583 readonly ADDITION: number;
10584 readonly MODIFICATION: number;
10585 readonly REMOVAL: number;
10588 declare var MutationEvent: {
10589 prototype: MutationEvent;
10590 new(): MutationEvent;
10591 readonly ADDITION: number;
10592 readonly MODIFICATION: number;
10593 readonly REMOVAL: number;
10596 /** 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. */
10597 interface MutationObserver {
10599 * Stops observer from observing any mutations. Until the observe() method is used again, observer's callback will not be invoked.
10601 disconnect(): void;
10603 * Instructs the user agent to observe a given target (a node) and report any mutations based on the criteria given by options (an object).
10605 * The options argument allows for setting mutation observation options via object members.
10607 observe(target: Node, options?: MutationObserverInit): void;
10609 * Empties the record queue and returns what was in there.
10611 takeRecords(): MutationRecord[];
10614 declare var MutationObserver: {
10615 prototype: MutationObserver;
10616 new(callback: MutationCallback): MutationObserver;
10619 /** A MutationRecord represents an individual DOM mutation. It is the object that is passed to MutationObserver's callback. */
10620 interface MutationRecord {
10622 * Return the nodes added and removed respectively.
10624 readonly addedNodes: NodeList;
10626 * Returns the local name of the changed attribute, and null otherwise.
10628 readonly attributeName: string | null;
10630 * Returns the namespace of the changed attribute, and null otherwise.
10632 readonly attributeNamespace: string | null;
10634 * Return the previous and next sibling respectively of the added or removed nodes, and null otherwise.
10636 readonly nextSibling: Node | null;
10638 * 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.
10640 readonly oldValue: string | null;
10642 * Return the previous and next sibling respectively of the added or removed nodes, and null otherwise.
10644 readonly previousSibling: Node | null;
10646 * Return the nodes added and removed respectively.
10648 readonly removedNodes: NodeList;
10650 * 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.
10652 readonly target: Node;
10654 * 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.
10656 readonly type: MutationRecordType;
10659 declare var MutationRecord: {
10660 prototype: MutationRecord;
10661 new(): MutationRecord;
10664 /** 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. */
10665 interface NamedNodeMap {
10666 readonly length: number;
10667 getNamedItem(qualifiedName: string): Attr | null;
10668 getNamedItemNS(namespace: string | null, localName: string): Attr | null;
10669 item(index: number): Attr | null;
10670 removeNamedItem(qualifiedName: string): Attr;
10671 removeNamedItemNS(namespace: string | null, localName: string): Attr;
10672 setNamedItem(attr: Attr): Attr | null;
10673 setNamedItemNS(attr: Attr): Attr | null;
10674 [index: number]: Attr;
10677 declare var NamedNodeMap: {
10678 prototype: NamedNodeMap;
10679 new(): NamedNodeMap;
10682 interface NavigationPreloadManager {
10683 disable(): Promise<void>;
10684 enable(): Promise<void>;
10685 getState(): Promise<NavigationPreloadState>;
10686 setHeaderValue(value: string): Promise<void>;
10689 declare var NavigationPreloadManager: {
10690 prototype: NavigationPreloadManager;
10691 new(): NavigationPreloadManager;
10694 /** The state and the identity of the user agent. It allows scripts to query it and to register themselves to carry on some activities. */
10695 interface Navigator extends MSFileSaver, MSNavigatorDoNotTrack, NavigatorAutomationInformation, NavigatorBeacon, NavigatorConcurrentHardware, NavigatorContentUtils, NavigatorCookies, NavigatorID, NavigatorLanguage, NavigatorOnLine, NavigatorPlugins, NavigatorStorage {
10696 readonly activeVRDisplays: ReadonlyArray<VRDisplay>;
10697 readonly clipboard: Clipboard;
10698 readonly credentials: CredentialsContainer;
10699 readonly doNotTrack: string | null;
10700 readonly geolocation: Geolocation;
10701 readonly maxTouchPoints: number;
10702 readonly mediaDevices: MediaDevices;
10703 readonly msManipulationViewsEnabled: boolean;
10704 readonly msMaxTouchPoints: number;
10705 readonly msPointerEnabled: boolean;
10706 readonly permissions: Permissions;
10707 readonly pointerEnabled: boolean;
10708 readonly serviceWorker: ServiceWorkerContainer;
10709 getGamepads(): (Gamepad | null)[];
10710 getUserMedia(constraints: MediaStreamConstraints, successCallback: NavigatorUserMediaSuccessCallback, errorCallback: NavigatorUserMediaErrorCallback): void;
10711 getVRDisplays(): Promise<VRDisplay[]>;
10712 msLaunchUri(uri: string, successCallback?: MSLaunchUriCallback, noHandlerCallback?: MSLaunchUriCallback): void;
10713 requestMediaKeySystemAccess(keySystem: string, supportedConfigurations: MediaKeySystemConfiguration[]): Promise<MediaKeySystemAccess>;
10714 sendBeacon(url: string, data?: BodyInit | null): boolean;
10715 share(data?: ShareData): Promise<void>;
10716 vibrate(pattern: number | number[]): boolean;
10719 declare var Navigator: {
10720 prototype: Navigator;
10724 interface NavigatorAutomationInformation {
10725 readonly webdriver: boolean;
10728 interface NavigatorBeacon {
10729 sendBeacon(url: string, data?: Blob | Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer | FormData | string | null): boolean;
10732 interface NavigatorConcurrentHardware {
10733 readonly hardwareConcurrency: number;
10736 interface NavigatorContentUtils {
10737 registerProtocolHandler(scheme: string, url: string, title: string): void;
10738 unregisterProtocolHandler(scheme: string, url: string): void;
10741 interface NavigatorCookies {
10742 readonly cookieEnabled: boolean;
10745 interface NavigatorID {
10746 readonly appCodeName: string;
10747 readonly appName: string;
10748 readonly appVersion: string;
10749 readonly platform: string;
10750 readonly product: string;
10751 readonly productSub: string;
10752 readonly userAgent: string;
10753 readonly vendor: string;
10754 readonly vendorSub: string;
10757 interface NavigatorLanguage {
10758 readonly language: string;
10759 readonly languages: ReadonlyArray<string>;
10762 interface NavigatorOnLine {
10763 readonly onLine: boolean;
10766 interface NavigatorPlugins {
10767 readonly mimeTypes: MimeTypeArray;
10768 readonly plugins: PluginArray;
10769 javaEnabled(): boolean;
10772 interface NavigatorStorage {
10773 readonly storage: StorageManager;
10776 /** 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. */
10777 interface Node extends EventTarget {
10779 * Returns node's node document's document base URL.
10781 readonly baseURI: string;
10783 * Returns the children.
10785 readonly childNodes: NodeListOf<ChildNode>;
10787 * Returns the first child.
10789 readonly firstChild: ChildNode | null;
10791 * Returns true if node is connected and false otherwise.
10793 readonly isConnected: boolean;
10795 * Returns the last child.
10797 readonly lastChild: ChildNode | null;
10799 readonly namespaceURI: string | null;
10801 * Returns the next sibling.
10803 readonly nextSibling: ChildNode | null;
10805 * Returns a string appropriate for the type of node.
10807 readonly nodeName: string;
10809 * Returns the type of node.
10811 readonly nodeType: number;
10812 nodeValue: string | null;
10814 * Returns the node document. Returns null for documents.
10816 readonly ownerDocument: Document | null;
10818 * Returns the parent element.
10820 readonly parentElement: HTMLElement | null;
10822 * Returns the parent.
10824 readonly parentNode: Node & ParentNode | null;
10826 * Returns the previous sibling.
10828 readonly previousSibling: ChildNode | null;
10829 textContent: string | null;
10830 appendChild<T extends Node>(newChild: T): T;
10832 * Returns a copy of node. If deep is true, the copy also includes the node's descendants.
10834 cloneNode(deep?: boolean): Node;
10836 * Returns a bitmask indicating the position of other relative to node.
10838 compareDocumentPosition(other: Node): number;
10840 * Returns true if other is an inclusive descendant of node, and false otherwise.
10842 contains(other: Node | null): boolean;
10844 * Returns node's root.
10846 getRootNode(options?: GetRootNodeOptions): Node;
10848 * Returns whether node has children.
10850 hasChildNodes(): boolean;
10851 insertBefore<T extends Node>(newChild: T, refChild: Node | null): T;
10852 isDefaultNamespace(namespace: string | null): boolean;
10854 * Returns whether node and otherNode have the same properties.
10856 isEqualNode(otherNode: Node | null): boolean;
10857 isSameNode(otherNode: Node | null): boolean;
10858 lookupNamespaceURI(prefix: string | null): string | null;
10859 lookupPrefix(namespace: string | null): string | null;
10861 * Removes empty exclusive Text nodes and concatenates the data of remaining contiguous exclusive Text nodes into the first of their nodes.
10864 removeChild<T extends Node>(oldChild: T): T;
10865 replaceChild<T extends Node>(newChild: Node, oldChild: T): T;
10866 readonly ATTRIBUTE_NODE: number;
10868 * node is a CDATASection node.
10870 readonly CDATA_SECTION_NODE: number;
10872 * node is a Comment node.
10874 readonly COMMENT_NODE: number;
10876 * node is a DocumentFragment node.
10878 readonly DOCUMENT_FRAGMENT_NODE: number;
10880 * node is a document.
10882 readonly DOCUMENT_NODE: number;
10884 * Set when other is a descendant of node.
10886 readonly DOCUMENT_POSITION_CONTAINED_BY: number;
10888 * Set when other is an ancestor of node.
10890 readonly DOCUMENT_POSITION_CONTAINS: number;
10892 * Set when node and other are not in the same tree.
10894 readonly DOCUMENT_POSITION_DISCONNECTED: number;
10896 * Set when other is following node.
10898 readonly DOCUMENT_POSITION_FOLLOWING: number;
10899 readonly DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC: number;
10901 * Set when other is preceding node.
10903 readonly DOCUMENT_POSITION_PRECEDING: number;
10905 * node is a doctype.
10907 readonly DOCUMENT_TYPE_NODE: number;
10909 * node is an element.
10911 readonly ELEMENT_NODE: number;
10912 readonly ENTITY_NODE: number;
10913 readonly ENTITY_REFERENCE_NODE: number;
10914 readonly NOTATION_NODE: number;
10916 * node is a ProcessingInstruction node.
10918 readonly PROCESSING_INSTRUCTION_NODE: number;
10920 * node is a Text node.
10922 readonly TEXT_NODE: number;
10925 declare var Node: {
10928 readonly ATTRIBUTE_NODE: number;
10930 * node is a CDATASection node.
10932 readonly CDATA_SECTION_NODE: number;
10934 * node is a Comment node.
10936 readonly COMMENT_NODE: number;
10938 * node is a DocumentFragment node.
10940 readonly DOCUMENT_FRAGMENT_NODE: number;
10942 * node is a document.
10944 readonly DOCUMENT_NODE: number;
10946 * Set when other is a descendant of node.
10948 readonly DOCUMENT_POSITION_CONTAINED_BY: number;
10950 * Set when other is an ancestor of node.
10952 readonly DOCUMENT_POSITION_CONTAINS: number;
10954 * Set when node and other are not in the same tree.
10956 readonly DOCUMENT_POSITION_DISCONNECTED: number;
10958 * Set when other is following node.
10960 readonly DOCUMENT_POSITION_FOLLOWING: number;
10961 readonly DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC: number;
10963 * Set when other is preceding node.
10965 readonly DOCUMENT_POSITION_PRECEDING: number;
10967 * node is a doctype.
10969 readonly DOCUMENT_TYPE_NODE: number;
10971 * node is an element.
10973 readonly ELEMENT_NODE: number;
10974 readonly ENTITY_NODE: number;
10975 readonly ENTITY_REFERENCE_NODE: number;
10976 readonly NOTATION_NODE: number;
10978 * node is a ProcessingInstruction node.
10980 readonly PROCESSING_INSTRUCTION_NODE: number;
10982 * node is a Text node.
10984 readonly TEXT_NODE: number;
10987 /** 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. */
10988 interface NodeFilter {
10989 acceptNode(node: Node): number;
10992 declare var NodeFilter: {
10993 readonly FILTER_ACCEPT: number;
10994 readonly FILTER_REJECT: number;
10995 readonly FILTER_SKIP: number;
10996 readonly SHOW_ALL: number;
10997 readonly SHOW_ATTRIBUTE: number;
10998 readonly SHOW_CDATA_SECTION: number;
10999 readonly SHOW_COMMENT: number;
11000 readonly SHOW_DOCUMENT: number;
11001 readonly SHOW_DOCUMENT_FRAGMENT: number;
11002 readonly SHOW_DOCUMENT_TYPE: number;
11003 readonly SHOW_ELEMENT: number;
11004 readonly SHOW_ENTITY: number;
11005 readonly SHOW_ENTITY_REFERENCE: number;
11006 readonly SHOW_NOTATION: number;
11007 readonly SHOW_PROCESSING_INSTRUCTION: number;
11008 readonly SHOW_TEXT: number;
11011 /** 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. */
11012 interface NodeIterator {
11013 readonly filter: NodeFilter | null;
11014 readonly pointerBeforeReferenceNode: boolean;
11015 readonly referenceNode: Node;
11016 readonly root: Node;
11017 readonly whatToShow: number;
11019 nextNode(): Node | null;
11020 previousNode(): Node | null;
11023 declare var NodeIterator: {
11024 prototype: NodeIterator;
11025 new(): NodeIterator;
11028 /** NodeList objects are collections of nodes, usually returned by properties such as Node.childNodes and methods such as document.querySelectorAll(). */
11029 interface NodeList {
11031 * Returns the number of nodes in the collection.
11033 readonly length: number;
11035 * Returns the node with index index from the collection. The nodes are sorted in tree order.
11037 item(index: number): Node | null;
11039 * Performs the specified action for each node in an list.
11040 * @param callbackfn A function that accepts up to three arguments. forEach calls the callbackfn function one time for each element in the list.
11041 * @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.
11043 forEach(callbackfn: (value: Node, key: number, parent: NodeList) => void, thisArg?: any): void;
11044 [index: number]: Node;
11047 declare var NodeList: {
11048 prototype: NodeList;
11052 interface NodeListOf<TNode extends Node> extends NodeList {
11054 item(index: number): TNode;
11056 * Performs the specified action for each node in an list.
11057 * @param callbackfn A function that accepts up to three arguments. forEach calls the callbackfn function one time for each element in the list.
11058 * @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.
11060 forEach(callbackfn: (value: TNode, key: number, parent: NodeListOf<TNode>) => void, thisArg?: any): void;
11061 [index: number]: TNode;
11064 interface NonDocumentTypeChildNode {
11066 * Returns the first following sibling that is an element, and null otherwise.
11068 readonly nextElementSibling: Element | null;
11070 * Returns the first preceding sibling that is an element, and null otherwise.
11072 readonly previousElementSibling: Element | null;
11075 interface NonElementParentNode {
11077 * Returns the first element within node's descendants whose ID is elementId.
11079 getElementById(elementId: string): Element | null;
11082 interface NotificationEventMap {
11089 /** This Notifications API interface is used to configure and display desktop notifications to the user. */
11090 interface Notification extends EventTarget {
11091 readonly actions: ReadonlyArray<NotificationAction>;
11092 readonly badge: string;
11093 readonly body: string;
11094 readonly data: any;
11095 readonly dir: NotificationDirection;
11096 readonly icon: string;
11097 readonly image: string;
11098 readonly lang: string;
11099 onclick: ((this: Notification, ev: Event) => any) | null;
11100 onclose: ((this: Notification, ev: Event) => any) | null;
11101 onerror: ((this: Notification, ev: Event) => any) | null;
11102 onshow: ((this: Notification, ev: Event) => any) | null;
11103 readonly renotify: boolean;
11104 readonly requireInteraction: boolean;
11105 readonly silent: boolean;
11106 readonly tag: string;
11107 readonly timestamp: number;
11108 readonly title: string;
11109 readonly vibrate: ReadonlyArray<number>;
11111 addEventListener<K extends keyof NotificationEventMap>(type: K, listener: (this: Notification, ev: NotificationEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11112 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11113 removeEventListener<K extends keyof NotificationEventMap>(type: K, listener: (this: Notification, ev: NotificationEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11114 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11117 declare var Notification: {
11118 prototype: Notification;
11119 new(title: string, options?: NotificationOptions): Notification;
11120 readonly maxActions: number;
11121 readonly permission: NotificationPermission;
11122 requestPermission(deprecatedCallback?: NotificationPermissionCallback): Promise<NotificationPermission>;
11125 /** The OES_element_index_uint extension is part of the WebGL API and adds support for gl.UNSIGNED_INT types to WebGLRenderingContext.drawElements(). */
11126 interface OES_element_index_uint {
11129 /** The OES_standard_derivatives extension is part of the WebGL API and adds the GLSL derivative functions dFdx, dFdy, and fwidth. */
11130 interface OES_standard_derivatives {
11131 readonly FRAGMENT_SHADER_DERIVATIVE_HINT_OES: GLenum;
11134 /** The OES_texture_float extension is part of the WebGL API and exposes floating-point pixel types for textures. */
11135 interface OES_texture_float {
11138 /** The OES_texture_float_linear extension is part of the WebGL API and allows linear filtering with floating-point pixel types for textures. */
11139 interface OES_texture_float_linear {
11142 /** 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. */
11143 interface OES_texture_half_float {
11144 readonly HALF_FLOAT_OES: GLenum;
11147 /** 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. */
11148 interface OES_texture_half_float_linear {
11151 interface OES_vertex_array_object {
11152 bindVertexArrayOES(arrayObject: WebGLVertexArrayObjectOES | null): void;
11153 createVertexArrayOES(): WebGLVertexArrayObjectOES | null;
11154 deleteVertexArrayOES(arrayObject: WebGLVertexArrayObjectOES | null): void;
11155 isVertexArrayOES(arrayObject: WebGLVertexArrayObjectOES | null): GLboolean;
11156 readonly VERTEX_ARRAY_BINDING_OES: GLenum;
11159 /** The Web Audio API OfflineAudioCompletionEvent interface represents events that occur when the processing of an OfflineAudioContext is terminated. The complete event implements this interface. */
11160 interface OfflineAudioCompletionEvent extends Event {
11161 readonly renderedBuffer: AudioBuffer;
11164 declare var OfflineAudioCompletionEvent: {
11165 prototype: OfflineAudioCompletionEvent;
11166 new(type: string, eventInitDict: OfflineAudioCompletionEventInit): OfflineAudioCompletionEvent;
11169 interface OfflineAudioContextEventMap extends BaseAudioContextEventMap {
11170 "complete": OfflineAudioCompletionEvent;
11173 /** 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. */
11174 interface OfflineAudioContext extends BaseAudioContext {
11175 readonly length: number;
11176 oncomplete: ((this: OfflineAudioContext, ev: OfflineAudioCompletionEvent) => any) | null;
11177 resume(): Promise<void>;
11178 startRendering(): Promise<AudioBuffer>;
11179 suspend(suspendTime: number): Promise<void>;
11180 addEventListener<K extends keyof OfflineAudioContextEventMap>(type: K, listener: (this: OfflineAudioContext, ev: OfflineAudioContextEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11181 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11182 removeEventListener<K extends keyof OfflineAudioContextEventMap>(type: K, listener: (this: OfflineAudioContext, ev: OfflineAudioContextEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11183 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11186 declare var OfflineAudioContext: {
11187 prototype: OfflineAudioContext;
11188 new(contextOptions: OfflineAudioContextOptions): OfflineAudioContext;
11189 new(numberOfChannels: number, length: number, sampleRate: number): OfflineAudioContext;
11192 interface OffscreenCanvas extends EventTarget {
11194 * These attributes return the dimensions of the OffscreenCanvas object's bitmap.
11196 * They can be set, to replace the bitmap with a new, transparent black bitmap of the specified dimensions (effectively resizing it).
11200 * These attributes return the dimensions of the OffscreenCanvas object's bitmap.
11202 * They can be set, to replace the bitmap with a new, transparent black bitmap of the specified dimensions (effectively resizing it).
11206 * Returns a promise that will fulfill with a new Blob object representing a file containing the image in the OffscreenCanvas object.
11208 * 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.
11210 convertToBlob(options?: ImageEncodeOptions): Promise<Blob>;
11212 * 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.
11214 * 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]
11216 * 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).
11218 getContext(contextId: "2d", options?: CanvasRenderingContext2DSettings): OffscreenCanvasRenderingContext2D | null;
11219 getContext(contextId: "bitmaprenderer", options?: ImageBitmapRenderingContextSettings): ImageBitmapRenderingContext | null;
11220 getContext(contextId: "webgl", options?: WebGLContextAttributes): WebGLRenderingContext | null;
11221 getContext(contextId: "webgl2", options?: WebGLContextAttributes): WebGL2RenderingContext | null;
11222 getContext(contextId: OffscreenRenderingContextId, options?: any): OffscreenRenderingContext | null;
11224 * 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.
11226 transferToImageBitmap(): ImageBitmap;
11229 declare var OffscreenCanvas: {
11230 prototype: OffscreenCanvas;
11231 new(width: number, height: number): OffscreenCanvas;
11234 interface OffscreenCanvasRenderingContext2D extends CanvasCompositing, CanvasDrawImage, CanvasDrawPath, CanvasFillStrokeStyles, CanvasFilters, CanvasImageData, CanvasImageSmoothing, CanvasPath, CanvasPathDrawingStyles, CanvasRect, CanvasShadowStyles, CanvasState, CanvasText, CanvasTextDrawingStyles, CanvasTransform {
11235 readonly canvas: OffscreenCanvas;
11239 declare var OffscreenCanvasRenderingContext2D: {
11240 prototype: OffscreenCanvasRenderingContext2D;
11241 new(): OffscreenCanvasRenderingContext2D;
11244 /** 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. */
11245 interface OscillatorNode extends AudioScheduledSourceNode {
11246 readonly detune: AudioParam;
11247 readonly frequency: AudioParam;
11248 type: OscillatorType;
11249 setPeriodicWave(periodicWave: PeriodicWave): void;
11250 addEventListener<K extends keyof AudioScheduledSourceNodeEventMap>(type: K, listener: (this: OscillatorNode, ev: AudioScheduledSourceNodeEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11251 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11252 removeEventListener<K extends keyof AudioScheduledSourceNodeEventMap>(type: K, listener: (this: OscillatorNode, ev: AudioScheduledSourceNodeEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11253 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11256 declare var OscillatorNode: {
11257 prototype: OscillatorNode;
11258 new(context: BaseAudioContext, options?: OscillatorOptions): OscillatorNode;
11261 interface OverconstrainedError extends Error {
11262 constraint: string;
11265 declare var OverconstrainedError: {
11266 prototype: OverconstrainedError;
11267 new(): OverconstrainedError;
11270 interface OverflowEvent extends UIEvent {
11271 readonly horizontalOverflow: boolean;
11272 readonly orient: number;
11273 readonly verticalOverflow: boolean;
11274 readonly BOTH: number;
11275 readonly HORIZONTAL: number;
11276 readonly VERTICAL: number;
11279 declare var OverflowEvent: {
11280 prototype: OverflowEvent;
11281 new(): OverflowEvent;
11282 readonly BOTH: number;
11283 readonly HORIZONTAL: number;
11284 readonly VERTICAL: number;
11287 /** The PageTransitionEvent is fired when a document is being loaded or unloaded. */
11288 interface PageTransitionEvent extends Event {
11290 * For the pageshow event, returns false if the page is newly being loaded (and the load event will fire). Otherwise, returns true.
11292 * 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.
11294 * Things that can cause the page to be unsalvageable include:
11296 * Listening for beforeunload events
11297 * Listening for unload events
11298 * Having iframes that are not salvageable
11299 * Active WebSocket objects
11300 * Aborting a Document
11302 readonly persisted: boolean;
11305 declare var PageTransitionEvent: {
11306 prototype: PageTransitionEvent;
11307 new(type: string, eventInitDict?: PageTransitionEventInit): PageTransitionEvent;
11310 /** 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! */
11311 interface PannerNode extends AudioNode {
11312 coneInnerAngle: number;
11313 coneOuterAngle: number;
11314 coneOuterGain: number;
11315 distanceModel: DistanceModelType;
11316 maxDistance: number;
11317 readonly orientationX: AudioParam;
11318 readonly orientationY: AudioParam;
11319 readonly orientationZ: AudioParam;
11320 panningModel: PanningModelType;
11321 readonly positionX: AudioParam;
11322 readonly positionY: AudioParam;
11323 readonly positionZ: AudioParam;
11324 refDistance: number;
11325 rolloffFactor: number;
11327 setOrientation(x: number, y: number, z: number): void;
11329 setPosition(x: number, y: number, z: number): void;
11332 declare var PannerNode: {
11333 prototype: PannerNode;
11334 new(context: BaseAudioContext, options?: PannerOptions): PannerNode;
11337 interface ParentNode {
11338 readonly childElementCount: number;
11340 * Returns the child elements.
11342 readonly children: HTMLCollection;
11344 * Returns the first child that is an element, and null otherwise.
11346 readonly firstElementChild: Element | null;
11348 * Returns the last child that is an element, and null otherwise.
11350 readonly lastElementChild: Element | null;
11352 * Inserts nodes after the last child of node, while replacing strings in nodes with equivalent Text nodes.
11354 * Throws a "HierarchyRequestError" DOMException if the constraints of the node tree are violated.
11356 append(...nodes: (Node | string)[]): void;
11358 * Inserts nodes before the first child of node, while replacing strings in nodes with equivalent Text nodes.
11360 * Throws a "HierarchyRequestError" DOMException if the constraints of the node tree are violated.
11362 prepend(...nodes: (Node | string)[]): void;
11364 * Returns the first element that is a descendant of node that matches selectors.
11366 querySelector<K extends keyof HTMLElementTagNameMap>(selectors: K): HTMLElementTagNameMap[K] | null;
11367 querySelector<K extends keyof SVGElementTagNameMap>(selectors: K): SVGElementTagNameMap[K] | null;
11368 querySelector<E extends Element = Element>(selectors: string): E | null;
11370 * Returns all element descendants of node that match selectors.
11372 querySelectorAll<K extends keyof HTMLElementTagNameMap>(selectors: K): NodeListOf<HTMLElementTagNameMap[K]>;
11373 querySelectorAll<K extends keyof SVGElementTagNameMap>(selectors: K): NodeListOf<SVGElementTagNameMap[K]>;
11374 querySelectorAll<E extends Element = Element>(selectors: string): NodeListOf<E>;
11377 /** 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. */
11378 interface Path2D extends CanvasPath {
11380 * Adds to the path the path given by the argument.
11382 addPath(path: Path2D, transform?: DOMMatrix2DInit): void;
11385 declare var Path2D: {
11387 new(path?: Path2D | string): Path2D;
11390 /** This Payment Request API interface is used to store shipping or payment address information. */
11391 interface PaymentAddress {
11392 readonly addressLine: string[];
11393 readonly city: string;
11394 readonly country: string;
11395 readonly dependentLocality: string;
11396 readonly languageCode: string;
11397 readonly organization: string;
11398 readonly phone: string;
11399 readonly postalCode: string;
11400 readonly recipient: string;
11401 readonly region: string;
11402 readonly sortingCode: string;
11406 declare var PaymentAddress: {
11407 prototype: PaymentAddress;
11408 new(): PaymentAddress;
11411 interface PaymentRequestEventMap {
11412 "shippingaddresschange": Event;
11413 "shippingoptionchange": Event;
11416 /** 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. */
11417 interface PaymentRequest extends EventTarget {
11418 readonly id: string;
11419 onshippingaddresschange: ((this: PaymentRequest, ev: Event) => any) | null;
11420 onshippingoptionchange: ((this: PaymentRequest, ev: Event) => any) | null;
11421 readonly shippingAddress: PaymentAddress | null;
11422 readonly shippingOption: string | null;
11423 readonly shippingType: PaymentShippingType | null;
11424 abort(): Promise<void>;
11425 canMakePayment(): Promise<boolean>;
11426 show(): Promise<PaymentResponse>;
11427 addEventListener<K extends keyof PaymentRequestEventMap>(type: K, listener: (this: PaymentRequest, ev: PaymentRequestEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11428 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11429 removeEventListener<K extends keyof PaymentRequestEventMap>(type: K, listener: (this: PaymentRequest, ev: PaymentRequestEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11430 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11433 declare var PaymentRequest: {
11434 prototype: PaymentRequest;
11435 new(methodData: PaymentMethodData[], details: PaymentDetailsInit, options?: PaymentOptions): PaymentRequest;
11438 /** This Payment Request API interface enables a web page to update the details of a PaymentRequest in response to a user action. */
11439 interface PaymentRequestUpdateEvent extends Event {
11440 updateWith(detailsPromise: PaymentDetailsUpdate | Promise<PaymentDetailsUpdate>): void;
11443 declare var PaymentRequestUpdateEvent: {
11444 prototype: PaymentRequestUpdateEvent;
11445 new(type: string, eventInitDict?: PaymentRequestUpdateEventInit): PaymentRequestUpdateEvent;
11448 /** This Payment Request API interface is returned after a user selects a payment method and approves a payment request. */
11449 interface PaymentResponse {
11450 readonly details: any;
11451 readonly methodName: string;
11452 readonly payerEmail: string | null;
11453 readonly payerName: string | null;
11454 readonly payerPhone: string | null;
11455 readonly requestId: string;
11456 readonly shippingAddress: PaymentAddress | null;
11457 readonly shippingOption: string | null;
11458 complete(result?: PaymentComplete): Promise<void>;
11462 declare var PaymentResponse: {
11463 prototype: PaymentResponse;
11464 new(): PaymentResponse;
11467 interface PerfWidgetExternal {
11468 readonly activeNetworkRequestCount: number;
11469 readonly averageFrameTime: number;
11470 readonly averagePaintTime: number;
11471 readonly extraInformationEnabled: boolean;
11472 readonly independentRenderingEnabled: boolean;
11473 readonly irDisablingContentString: string;
11474 readonly irStatusAvailable: boolean;
11475 readonly maxCpuSpeed: number;
11476 readonly paintRequestsPerSecond: number;
11477 readonly performanceCounter: number;
11478 readonly performanceCounterFrequency: number;
11479 addEventListener(eventType: string, callback: Function): void;
11480 getMemoryUsage(): number;
11481 getProcessCpuUsage(): number;
11482 getRecentCpuUsage(last: number | null): any;
11483 getRecentFrames(last: number | null): any;
11484 getRecentMemoryUsage(last: number | null): any;
11485 getRecentPaintRequests(last: number | null): any;
11486 removeEventListener(eventType: string, callback: Function): void;
11487 repositionWindow(x: number, y: number): void;
11488 resizeWindow(width: number, height: number): void;
11491 declare var PerfWidgetExternal: {
11492 prototype: PerfWidgetExternal;
11493 new(): PerfWidgetExternal;
11496 interface PerformanceEventMap {
11497 "resourcetimingbufferfull": Event;
11500 /** 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. */
11501 interface Performance extends EventTarget {
11503 readonly navigation: PerformanceNavigation;
11504 onresourcetimingbufferfull: ((this: Performance, ev: Event) => any) | null;
11505 readonly timeOrigin: number;
11507 readonly timing: PerformanceTiming;
11508 clearMarks(markName?: string): void;
11509 clearMeasures(measureName?: string): void;
11510 clearResourceTimings(): void;
11511 getEntries(): PerformanceEntryList;
11512 getEntriesByName(name: string, type?: string): PerformanceEntryList;
11513 getEntriesByType(type: string): PerformanceEntryList;
11514 mark(markName: string): void;
11515 measure(measureName: string, startMark?: string, endMark?: string): void;
11517 setResourceTimingBufferSize(maxSize: number): void;
11519 addEventListener<K extends keyof PerformanceEventMap>(type: K, listener: (this: Performance, ev: PerformanceEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11520 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11521 removeEventListener<K extends keyof PerformanceEventMap>(type: K, listener: (this: Performance, ev: PerformanceEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11522 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11525 declare var Performance: {
11526 prototype: Performance;
11527 new(): Performance;
11530 /** 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). */
11531 interface PerformanceEntry {
11532 readonly duration: number;
11533 readonly entryType: string;
11534 readonly name: string;
11535 readonly startTime: number;
11539 declare var PerformanceEntry: {
11540 prototype: PerformanceEntry;
11541 new(): PerformanceEntry;
11544 /** 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. */
11545 interface PerformanceMark extends PerformanceEntry {
11548 declare var PerformanceMark: {
11549 prototype: PerformanceMark;
11550 new(): PerformanceMark;
11553 /** 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. */
11554 interface PerformanceMeasure extends PerformanceEntry {
11557 declare var PerformanceMeasure: {
11558 prototype: PerformanceMeasure;
11559 new(): PerformanceMeasure;
11562 /** The legacy PerformanceNavigation interface represents information about how the navigation to the current document was done. */
11563 interface PerformanceNavigation {
11564 readonly redirectCount: number;
11565 readonly type: number;
11567 readonly TYPE_BACK_FORWARD: number;
11568 readonly TYPE_NAVIGATE: number;
11569 readonly TYPE_RELOAD: number;
11570 readonly TYPE_RESERVED: number;
11573 declare var PerformanceNavigation: {
11574 prototype: PerformanceNavigation;
11575 new(): PerformanceNavigation;
11576 readonly TYPE_BACK_FORWARD: number;
11577 readonly TYPE_NAVIGATE: number;
11578 readonly TYPE_RELOAD: number;
11579 readonly TYPE_RESERVED: number;
11582 /** 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. */
11583 interface PerformanceNavigationTiming extends PerformanceResourceTiming {
11584 readonly domComplete: number;
11585 readonly domContentLoadedEventEnd: number;
11586 readonly domContentLoadedEventStart: number;
11587 readonly domInteractive: number;
11588 readonly loadEventEnd: number;
11589 readonly loadEventStart: number;
11590 readonly redirectCount: number;
11591 readonly type: NavigationType;
11592 readonly unloadEventEnd: number;
11593 readonly unloadEventStart: number;
11597 declare var PerformanceNavigationTiming: {
11598 prototype: PerformanceNavigationTiming;
11599 new(): PerformanceNavigationTiming;
11602 interface PerformanceObserver {
11603 disconnect(): void;
11604 observe(options?: PerformanceObserverInit): void;
11605 takeRecords(): PerformanceEntryList;
11608 declare var PerformanceObserver: {
11609 prototype: PerformanceObserver;
11610 new(callback: PerformanceObserverCallback): PerformanceObserver;
11611 readonly supportedEntryTypes: ReadonlyArray<string>;
11614 interface PerformanceObserverEntryList {
11615 getEntries(): PerformanceEntryList;
11616 getEntriesByName(name: string, type?: string): PerformanceEntryList;
11617 getEntriesByType(type: string): PerformanceEntryList;
11620 declare var PerformanceObserverEntryList: {
11621 prototype: PerformanceObserverEntryList;
11622 new(): PerformanceObserverEntryList;
11625 /** 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. */
11626 interface PerformanceResourceTiming extends PerformanceEntry {
11627 readonly connectEnd: number;
11628 readonly connectStart: number;
11629 readonly decodedBodySize: number;
11630 readonly domainLookupEnd: number;
11631 readonly domainLookupStart: number;
11632 readonly encodedBodySize: number;
11633 readonly fetchStart: number;
11634 readonly initiatorType: string;
11635 readonly nextHopProtocol: string;
11636 readonly redirectEnd: number;
11637 readonly redirectStart: number;
11638 readonly requestStart: number;
11639 readonly responseEnd: number;
11640 readonly responseStart: number;
11641 readonly secureConnectionStart: number;
11642 readonly transferSize: number;
11643 readonly workerStart: number;
11647 declare var PerformanceResourceTiming: {
11648 prototype: PerformanceResourceTiming;
11649 new(): PerformanceResourceTiming;
11652 /** 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. */
11653 interface PerformanceTiming {
11654 readonly connectEnd: number;
11655 readonly connectStart: number;
11656 readonly domComplete: number;
11657 readonly domContentLoadedEventEnd: number;
11658 readonly domContentLoadedEventStart: number;
11659 readonly domInteractive: number;
11660 readonly domLoading: number;
11661 readonly domainLookupEnd: number;
11662 readonly domainLookupStart: number;
11663 readonly fetchStart: number;
11664 readonly loadEventEnd: number;
11665 readonly loadEventStart: number;
11666 readonly navigationStart: number;
11667 readonly redirectEnd: number;
11668 readonly redirectStart: number;
11669 readonly requestStart: number;
11670 readonly responseEnd: number;
11671 readonly responseStart: number;
11672 readonly secureConnectionStart: number;
11673 readonly unloadEventEnd: number;
11674 readonly unloadEventStart: number;
11678 declare var PerformanceTiming: {
11679 prototype: PerformanceTiming;
11680 new(): PerformanceTiming;
11683 /** 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(). */
11684 interface PeriodicWave {
11687 declare var PeriodicWave: {
11688 prototype: PeriodicWave;
11689 new(context: BaseAudioContext, options?: PeriodicWaveOptions): PeriodicWave;
11692 interface PermissionRequest extends DeferredPermissionRequest {
11693 readonly state: MSWebViewPermissionState;
11697 declare var PermissionRequest: {
11698 prototype: PermissionRequest;
11699 new(): PermissionRequest;
11702 interface PermissionRequestedEvent extends Event {
11703 readonly permissionRequest: PermissionRequest;
11706 declare var PermissionRequestedEvent: {
11707 prototype: PermissionRequestedEvent;
11708 new(): PermissionRequestedEvent;
11711 interface PermissionStatusEventMap {
11715 interface PermissionStatus extends EventTarget {
11716 onchange: ((this: PermissionStatus, ev: Event) => any) | null;
11717 readonly state: PermissionState;
11718 addEventListener<K extends keyof PermissionStatusEventMap>(type: K, listener: (this: PermissionStatus, ev: PermissionStatusEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11719 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11720 removeEventListener<K extends keyof PermissionStatusEventMap>(type: K, listener: (this: PermissionStatus, ev: PermissionStatusEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11721 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11724 declare var PermissionStatus: {
11725 prototype: PermissionStatus;
11726 new(): PermissionStatus;
11729 interface Permissions {
11730 query(permissionDesc: PermissionDescriptor | DevicePermissionDescriptor | MidiPermissionDescriptor | PushPermissionDescriptor): Promise<PermissionStatus>;
11733 declare var Permissions: {
11734 prototype: Permissions;
11735 new(): Permissions;
11738 /** Provides information about a browser plugin. */
11741 * Returns the plugin's description.
11743 readonly description: string;
11745 * Returns the plugin library's filename, if applicable on the current platform.
11747 readonly filename: string;
11749 * Returns the number of MIME types, represented by MimeType objects, supported by the plugin.
11751 readonly length: number;
11753 * Returns the plugin's name.
11755 readonly name: string;
11757 * Returns the specified MimeType object.
11759 item(index: number): MimeType | null;
11760 namedItem(name: string): MimeType | null;
11761 [index: number]: MimeType;
11764 declare var Plugin: {
11769 /** 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. */
11770 interface PluginArray {
11771 readonly length: number;
11772 item(index: number): Plugin | null;
11773 namedItem(name: string): Plugin | null;
11774 refresh(reload?: boolean): void;
11775 [index: number]: Plugin;
11778 declare var PluginArray: {
11779 prototype: PluginArray;
11780 new(): PluginArray;
11783 /** 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. */
11784 interface PointerEvent extends MouseEvent {
11785 readonly height: number;
11786 readonly isPrimary: boolean;
11787 readonly pointerId: number;
11788 readonly pointerType: string;
11789 readonly pressure: number;
11790 readonly tangentialPressure: number;
11791 readonly tiltX: number;
11792 readonly tiltY: number;
11793 readonly twist: number;
11794 readonly width: number;
11797 declare var PointerEvent: {
11798 prototype: PointerEvent;
11799 new(type: string, eventInitDict?: PointerEventInit): PointerEvent;
11802 /** PopStateEvent is an event handler for the popstate event on the window. */
11803 interface PopStateEvent extends Event {
11805 * Returns a copy of the information that was provided to pushState() or replaceState().
11807 readonly state: any;
11810 declare var PopStateEvent: {
11811 prototype: PopStateEvent;
11812 new(type: string, eventInitDict?: PopStateEventInit): PopStateEvent;
11815 /** A processing instruction embeds application-specific instructions in XML which can be ignored by other applications that don't recognize them. */
11816 interface ProcessingInstruction extends CharacterData, LinkStyle {
11817 readonly ownerDocument: Document;
11818 readonly target: string;
11821 declare var ProcessingInstruction: {
11822 prototype: ProcessingInstruction;
11823 new(): ProcessingInstruction;
11826 /** 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>). */
11827 interface ProgressEvent<T extends EventTarget = EventTarget> extends Event {
11828 readonly lengthComputable: boolean;
11829 readonly loaded: number;
11830 readonly target: T | null;
11831 readonly total: number;
11834 declare var ProgressEvent: {
11835 prototype: ProgressEvent;
11836 new(type: string, eventInitDict?: ProgressEventInit): ProgressEvent;
11839 interface PromiseRejectionEvent extends Event {
11840 readonly promise: Promise<any>;
11841 readonly reason: any;
11844 declare var PromiseRejectionEvent: {
11845 prototype: PromiseRejectionEvent;
11846 new(type: string, eventInitDict: PromiseRejectionEventInit): PromiseRejectionEvent;
11849 interface PublicKeyCredential extends Credential {
11850 readonly rawId: ArrayBuffer;
11851 readonly response: AuthenticatorResponse;
11852 getClientExtensionResults(): AuthenticationExtensionsClientOutputs;
11855 declare var PublicKeyCredential: {
11856 prototype: PublicKeyCredential;
11857 new(): PublicKeyCredential;
11858 isUserVerifyingPlatformAuthenticatorAvailable(): Promise<boolean>;
11861 /** This Push API interface provides a way to receive notifications from third-party servers as well as request URLs for push notifications. */
11862 interface PushManager {
11863 getSubscription(): Promise<PushSubscription | null>;
11864 permissionState(options?: PushSubscriptionOptionsInit): Promise<PushPermissionState>;
11865 subscribe(options?: PushSubscriptionOptionsInit): Promise<PushSubscription>;
11868 declare var PushManager: {
11869 prototype: PushManager;
11870 new(): PushManager;
11871 readonly supportedContentEncodings: ReadonlyArray<string>;
11874 /** This Push API interface provides a subcription's URL endpoint and allows unsubscription from a push service. */
11875 interface PushSubscription {
11876 readonly endpoint: string;
11877 readonly expirationTime: number | null;
11878 readonly options: PushSubscriptionOptions;
11879 getKey(name: PushEncryptionKeyName): ArrayBuffer | null;
11880 toJSON(): PushSubscriptionJSON;
11881 unsubscribe(): Promise<boolean>;
11884 declare var PushSubscription: {
11885 prototype: PushSubscription;
11886 new(): PushSubscription;
11889 interface PushSubscriptionOptions {
11890 readonly applicationServerKey: ArrayBuffer | null;
11891 readonly userVisibleOnly: boolean;
11894 declare var PushSubscriptionOptions: {
11895 prototype: PushSubscriptionOptions;
11896 new(): PushSubscriptionOptions;
11899 interface RTCCertificate {
11900 readonly expires: number;
11901 getFingerprints(): RTCDtlsFingerprint[];
11904 declare var RTCCertificate: {
11905 prototype: RTCCertificate;
11906 new(): RTCCertificate;
11907 getSupportedAlgorithms(): AlgorithmIdentifier[];
11910 interface RTCDTMFSenderEventMap {
11911 "tonechange": RTCDTMFToneChangeEvent;
11914 interface RTCDTMFSender extends EventTarget {
11915 readonly canInsertDTMF: boolean;
11916 ontonechange: ((this: RTCDTMFSender, ev: RTCDTMFToneChangeEvent) => any) | null;
11917 readonly toneBuffer: string;
11918 insertDTMF(tones: string, duration?: number, interToneGap?: number): void;
11919 addEventListener<K extends keyof RTCDTMFSenderEventMap>(type: K, listener: (this: RTCDTMFSender, ev: RTCDTMFSenderEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11920 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11921 removeEventListener<K extends keyof RTCDTMFSenderEventMap>(type: K, listener: (this: RTCDTMFSender, ev: RTCDTMFSenderEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11922 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11925 declare var RTCDTMFSender: {
11926 prototype: RTCDTMFSender;
11927 new(): RTCDTMFSender;
11930 /** Events sent to indicate that DTMF tones have started or finished playing. This interface is used by the tonechange event. */
11931 interface RTCDTMFToneChangeEvent extends Event {
11932 readonly tone: string;
11935 declare var RTCDTMFToneChangeEvent: {
11936 prototype: RTCDTMFToneChangeEvent;
11937 new(type: string, eventInitDict: RTCDTMFToneChangeEventInit): RTCDTMFToneChangeEvent;
11940 interface RTCDataChannelEventMap {
11941 "bufferedamountlow": Event;
11943 "error": RTCErrorEvent;
11944 "message": MessageEvent;
11948 interface RTCDataChannel extends EventTarget {
11949 binaryType: string;
11950 readonly bufferedAmount: number;
11951 bufferedAmountLowThreshold: number;
11952 readonly id: number | null;
11953 readonly label: string;
11954 readonly maxPacketLifeTime: number | null;
11955 readonly maxRetransmits: number | null;
11956 readonly negotiated: boolean;
11957 onbufferedamountlow: ((this: RTCDataChannel, ev: Event) => any) | null;
11958 onclose: ((this: RTCDataChannel, ev: Event) => any) | null;
11959 onerror: ((this: RTCDataChannel, ev: RTCErrorEvent) => any) | null;
11960 onmessage: ((this: RTCDataChannel, ev: MessageEvent) => any) | null;
11961 onopen: ((this: RTCDataChannel, ev: Event) => any) | null;
11962 readonly ordered: boolean;
11963 readonly priority: RTCPriorityType;
11964 readonly protocol: string;
11965 readonly readyState: RTCDataChannelState;
11967 send(data: string): void;
11968 send(data: Blob): void;
11969 send(data: ArrayBuffer): void;
11970 send(data: ArrayBufferView): void;
11971 addEventListener<K extends keyof RTCDataChannelEventMap>(type: K, listener: (this: RTCDataChannel, ev: RTCDataChannelEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11972 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11973 removeEventListener<K extends keyof RTCDataChannelEventMap>(type: K, listener: (this: RTCDataChannel, ev: RTCDataChannelEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11974 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11977 declare var RTCDataChannel: {
11978 prototype: RTCDataChannel;
11979 new(): RTCDataChannel;
11982 interface RTCDataChannelEvent extends Event {
11983 readonly channel: RTCDataChannel;
11986 declare var RTCDataChannelEvent: {
11987 prototype: RTCDataChannelEvent;
11988 new(type: string, eventInitDict: RTCDataChannelEventInit): RTCDataChannelEvent;
11991 interface RTCDtlsTransportEventMap {
11992 "error": RTCErrorEvent;
11993 "statechange": Event;
11996 interface RTCDtlsTransport extends EventTarget {
11997 readonly iceTransport: RTCIceTransport;
11998 onerror: ((this: RTCDtlsTransport, ev: RTCErrorEvent) => any) | null;
11999 onstatechange: ((this: RTCDtlsTransport, ev: Event) => any) | null;
12000 readonly state: RTCDtlsTransportState;
12001 getRemoteCertificates(): ArrayBuffer[];
12002 addEventListener<K extends keyof RTCDtlsTransportEventMap>(type: K, listener: (this: RTCDtlsTransport, ev: RTCDtlsTransportEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12003 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12004 removeEventListener<K extends keyof RTCDtlsTransportEventMap>(type: K, listener: (this: RTCDtlsTransport, ev: RTCDtlsTransportEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12005 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12008 declare var RTCDtlsTransport: {
12009 prototype: RTCDtlsTransport;
12010 new(): RTCDtlsTransport;
12013 interface RTCDtlsTransportStateChangedEvent extends Event {
12014 readonly state: RTCDtlsTransportState;
12017 declare var RTCDtlsTransportStateChangedEvent: {
12018 prototype: RTCDtlsTransportStateChangedEvent;
12019 new(): RTCDtlsTransportStateChangedEvent;
12022 interface RTCDtmfSenderEventMap {
12023 "tonechange": RTCDTMFToneChangeEvent;
12026 interface RTCDtmfSender extends EventTarget {
12027 readonly canInsertDTMF: boolean;
12028 readonly duration: number;
12029 readonly interToneGap: number;
12030 ontonechange: ((this: RTCDtmfSender, ev: RTCDTMFToneChangeEvent) => any) | null;
12031 readonly sender: RTCRtpSender;
12032 readonly toneBuffer: string;
12033 insertDTMF(tones: string, duration?: number, interToneGap?: number): void;
12034 addEventListener<K extends keyof RTCDtmfSenderEventMap>(type: K, listener: (this: RTCDtmfSender, ev: RTCDtmfSenderEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12035 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12036 removeEventListener<K extends keyof RTCDtmfSenderEventMap>(type: K, listener: (this: RTCDtmfSender, ev: RTCDtmfSenderEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12037 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12040 declare var RTCDtmfSender: {
12041 prototype: RTCDtmfSender;
12042 new(sender: RTCRtpSender): RTCDtmfSender;
12045 interface RTCError extends DOMException {
12046 readonly errorDetail: RTCErrorDetailType;
12047 readonly httpRequestStatusCode: number | null;
12048 readonly receivedAlert: number | null;
12049 readonly sctpCauseCode: number | null;
12050 readonly sdpLineNumber: number | null;
12051 readonly sentAlert: number | null;
12054 declare var RTCError: {
12055 prototype: RTCError;
12056 new(init: RTCErrorInit, message?: string): RTCError;
12059 interface RTCErrorEvent extends Event {
12060 readonly error: RTCError;
12063 declare var RTCErrorEvent: {
12064 prototype: RTCErrorEvent;
12065 new(type: string, eventInitDict: RTCErrorEventInit): RTCErrorEvent;
12068 /** The RTCIceCandidate interface—part of the WebRTC API—represents a candidate Internet Connectivity Establishment (ICE) configuration which may be used to establish an RTCPeerConnection. */
12069 interface RTCIceCandidate {
12070 readonly candidate: string;
12071 readonly component: RTCIceComponent | null;
12072 readonly foundation: string | null;
12073 readonly port: number | null;
12074 readonly priority: number | null;
12075 readonly protocol: RTCIceProtocol | null;
12076 readonly relatedAddress: string | null;
12077 readonly relatedPort: number | null;
12078 readonly sdpMLineIndex: number | null;
12079 readonly sdpMid: string | null;
12080 readonly tcpType: RTCIceTcpCandidateType | null;
12081 readonly type: RTCIceCandidateType | null;
12082 readonly usernameFragment: string | null;
12083 toJSON(): RTCIceCandidateInit;
12086 declare var RTCIceCandidate: {
12087 prototype: RTCIceCandidate;
12088 new(candidateInitDict?: RTCIceCandidateInit): RTCIceCandidate;
12091 interface RTCIceCandidatePairChangedEvent extends Event {
12092 readonly pair: RTCIceCandidatePair;
12095 declare var RTCIceCandidatePairChangedEvent: {
12096 prototype: RTCIceCandidatePairChangedEvent;
12097 new(): RTCIceCandidatePairChangedEvent;
12100 interface RTCIceGathererEventMap {
12102 "localcandidate": RTCIceGathererEvent;
12105 interface RTCIceGatherer extends RTCStatsProvider {
12106 readonly component: RTCIceComponent;
12107 onerror: ((this: RTCIceGatherer, ev: Event) => any) | null;
12108 onlocalcandidate: ((this: RTCIceGatherer, ev: RTCIceGathererEvent) => any) | null;
12109 createAssociatedGatherer(): RTCIceGatherer;
12110 getLocalCandidates(): RTCIceCandidateDictionary[];
12111 getLocalParameters(): RTCIceParameters;
12112 addEventListener<K extends keyof RTCIceGathererEventMap>(type: K, listener: (this: RTCIceGatherer, ev: RTCIceGathererEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12113 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12114 removeEventListener<K extends keyof RTCIceGathererEventMap>(type: K, listener: (this: RTCIceGatherer, ev: RTCIceGathererEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12115 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12118 declare var RTCIceGatherer: {
12119 prototype: RTCIceGatherer;
12120 new(options: RTCIceGatherOptions): RTCIceGatherer;
12123 interface RTCIceGathererEvent extends Event {
12124 readonly candidate: RTCIceCandidateDictionary | RTCIceCandidateComplete;
12127 declare var RTCIceGathererEvent: {
12128 prototype: RTCIceGathererEvent;
12129 new(): RTCIceGathererEvent;
12132 interface RTCIceTransportEventMap {
12133 "gatheringstatechange": Event;
12134 "selectedcandidatepairchange": Event;
12135 "statechange": Event;
12138 /** Provides access to information about the ICE transport layer over which the data is being sent and received. */
12139 interface RTCIceTransport extends EventTarget {
12140 readonly component: RTCIceComponent;
12141 readonly gatheringState: RTCIceGathererState;
12142 ongatheringstatechange: ((this: RTCIceTransport, ev: Event) => any) | null;
12143 onselectedcandidatepairchange: ((this: RTCIceTransport, ev: Event) => any) | null;
12144 onstatechange: ((this: RTCIceTransport, ev: Event) => any) | null;
12145 readonly role: RTCIceRole;
12146 readonly state: RTCIceTransportState;
12147 getLocalCandidates(): RTCIceCandidate[];
12148 getLocalParameters(): RTCIceParameters | null;
12149 getRemoteCandidates(): RTCIceCandidate[];
12150 getRemoteParameters(): RTCIceParameters | null;
12151 getSelectedCandidatePair(): RTCIceCandidatePair | null;
12152 addEventListener<K extends keyof RTCIceTransportEventMap>(type: K, listener: (this: RTCIceTransport, ev: RTCIceTransportEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12153 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12154 removeEventListener<K extends keyof RTCIceTransportEventMap>(type: K, listener: (this: RTCIceTransport, ev: RTCIceTransportEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12155 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12158 declare var RTCIceTransport: {
12159 prototype: RTCIceTransport;
12160 new(): RTCIceTransport;
12163 interface RTCIceTransportStateChangedEvent extends Event {
12164 readonly state: RTCIceTransportState;
12167 declare var RTCIceTransportStateChangedEvent: {
12168 prototype: RTCIceTransportStateChangedEvent;
12169 new(): RTCIceTransportStateChangedEvent;
12172 interface RTCIdentityAssertion {
12177 declare var RTCIdentityAssertion: {
12178 prototype: RTCIdentityAssertion;
12179 new(idp: string, name: string): RTCIdentityAssertion;
12182 interface RTCPeerConnectionEventMap {
12183 "connectionstatechange": Event;
12184 "datachannel": RTCDataChannelEvent;
12185 "icecandidate": RTCPeerConnectionIceEvent;
12186 "icecandidateerror": RTCPeerConnectionIceErrorEvent;
12187 "iceconnectionstatechange": Event;
12188 "icegatheringstatechange": Event;
12189 "negotiationneeded": Event;
12190 "signalingstatechange": Event;
12191 "statsended": RTCStatsEvent;
12192 "track": RTCTrackEvent;
12195 /** 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. */
12196 interface RTCPeerConnection extends EventTarget {
12197 readonly canTrickleIceCandidates: boolean | null;
12198 readonly connectionState: RTCPeerConnectionState;
12199 readonly currentLocalDescription: RTCSessionDescription | null;
12200 readonly currentRemoteDescription: RTCSessionDescription | null;
12201 readonly iceConnectionState: RTCIceConnectionState;
12202 readonly iceGatheringState: RTCIceGatheringState;
12203 readonly idpErrorInfo: string | null;
12204 readonly idpLoginUrl: string | null;
12205 readonly localDescription: RTCSessionDescription | null;
12206 onconnectionstatechange: ((this: RTCPeerConnection, ev: Event) => any) | null;
12207 ondatachannel: ((this: RTCPeerConnection, ev: RTCDataChannelEvent) => any) | null;
12208 onicecandidate: ((this: RTCPeerConnection, ev: RTCPeerConnectionIceEvent) => any) | null;
12209 onicecandidateerror: ((this: RTCPeerConnection, ev: RTCPeerConnectionIceErrorEvent) => any) | null;
12210 oniceconnectionstatechange: ((this: RTCPeerConnection, ev: Event) => any) | null;
12211 onicegatheringstatechange: ((this: RTCPeerConnection, ev: Event) => any) | null;
12212 onnegotiationneeded: ((this: RTCPeerConnection, ev: Event) => any) | null;
12213 onsignalingstatechange: ((this: RTCPeerConnection, ev: Event) => any) | null;
12214 onstatsended: ((this: RTCPeerConnection, ev: RTCStatsEvent) => any) | null;
12215 ontrack: ((this: RTCPeerConnection, ev: RTCTrackEvent) => any) | null;
12216 readonly peerIdentity: Promise<RTCIdentityAssertion>;
12217 readonly pendingLocalDescription: RTCSessionDescription | null;
12218 readonly pendingRemoteDescription: RTCSessionDescription | null;
12219 readonly remoteDescription: RTCSessionDescription | null;
12220 readonly sctp: RTCSctpTransport | null;
12221 readonly signalingState: RTCSignalingState;
12222 addIceCandidate(candidate: RTCIceCandidateInit | RTCIceCandidate): Promise<void>;
12223 addTrack(track: MediaStreamTrack, ...streams: MediaStream[]): RTCRtpSender;
12224 addTransceiver(trackOrKind: MediaStreamTrack | string, init?: RTCRtpTransceiverInit): RTCRtpTransceiver;
12226 createAnswer(options?: RTCOfferOptions): Promise<RTCSessionDescriptionInit>;
12227 createDataChannel(label: string, dataChannelDict?: RTCDataChannelInit): RTCDataChannel;
12228 createOffer(options?: RTCOfferOptions): Promise<RTCSessionDescriptionInit>;
12229 getConfiguration(): RTCConfiguration;
12230 getIdentityAssertion(): Promise<string>;
12231 getReceivers(): RTCRtpReceiver[];
12232 getSenders(): RTCRtpSender[];
12233 getStats(selector?: MediaStreamTrack | null): Promise<RTCStatsReport>;
12234 getTransceivers(): RTCRtpTransceiver[];
12235 removeTrack(sender: RTCRtpSender): void;
12236 setConfiguration(configuration: RTCConfiguration): void;
12237 setIdentityProvider(provider: string, options?: RTCIdentityProviderOptions): void;
12238 setLocalDescription(description: RTCSessionDescriptionInit): Promise<void>;
12239 setRemoteDescription(description: RTCSessionDescriptionInit): Promise<void>;
12240 addEventListener<K extends keyof RTCPeerConnectionEventMap>(type: K, listener: (this: RTCPeerConnection, ev: RTCPeerConnectionEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12241 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12242 removeEventListener<K extends keyof RTCPeerConnectionEventMap>(type: K, listener: (this: RTCPeerConnection, ev: RTCPeerConnectionEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12243 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12246 declare var RTCPeerConnection: {
12247 prototype: RTCPeerConnection;
12248 new(configuration?: RTCConfiguration): RTCPeerConnection;
12249 generateCertificate(keygenAlgorithm: AlgorithmIdentifier): Promise<RTCCertificate>;
12250 getDefaultIceServers(): RTCIceServer[];
12253 interface RTCPeerConnectionIceErrorEvent extends Event {
12254 readonly errorCode: number;
12255 readonly errorText: string;
12256 readonly hostCandidate: string;
12257 readonly url: string;
12260 declare var RTCPeerConnectionIceErrorEvent: {
12261 prototype: RTCPeerConnectionIceErrorEvent;
12262 new(type: string, eventInitDict: RTCPeerConnectionIceErrorEventInit): RTCPeerConnectionIceErrorEvent;
12265 /** Events that occurs in relation to ICE candidates with the target, usually an RTCPeerConnection. Only one event is of this type: icecandidate. */
12266 interface RTCPeerConnectionIceEvent extends Event {
12267 readonly candidate: RTCIceCandidate | null;
12268 readonly url: string | null;
12271 declare var RTCPeerConnectionIceEvent: {
12272 prototype: RTCPeerConnectionIceEvent;
12273 new(type: string, eventInitDict?: RTCPeerConnectionIceEventInit): RTCPeerConnectionIceEvent;
12276 /** This WebRTC API interface manages the reception and decoding of data for a MediaStreamTrack on an RTCPeerConnection. */
12277 interface RTCRtpReceiver {
12278 readonly rtcpTransport: RTCDtlsTransport | null;
12279 readonly track: MediaStreamTrack;
12280 readonly transport: RTCDtlsTransport | null;
12281 getContributingSources(): RTCRtpContributingSource[];
12282 getParameters(): RTCRtpReceiveParameters;
12283 getStats(): Promise<RTCStatsReport>;
12284 getSynchronizationSources(): RTCRtpSynchronizationSource[];
12287 declare var RTCRtpReceiver: {
12288 prototype: RTCRtpReceiver;
12289 new(): RTCRtpReceiver;
12290 getCapabilities(kind: string): RTCRtpCapabilities | null;
12293 /** Provides the ability to control and obtain details about how a particular MediaStreamTrack is encoded and sent to a remote peer. */
12294 interface RTCRtpSender {
12295 readonly dtmf: RTCDTMFSender | null;
12296 readonly rtcpTransport: RTCDtlsTransport | null;
12297 readonly track: MediaStreamTrack | null;
12298 readonly transport: RTCDtlsTransport | null;
12299 getParameters(): RTCRtpSendParameters;
12300 getStats(): Promise<RTCStatsReport>;
12301 replaceTrack(withTrack: MediaStreamTrack | null): Promise<void>;
12302 setParameters(parameters: RTCRtpSendParameters): Promise<void>;
12303 setStreams(...streams: MediaStream[]): void;
12306 declare var RTCRtpSender: {
12307 prototype: RTCRtpSender;
12308 new(): RTCRtpSender;
12309 getCapabilities(kind: string): RTCRtpCapabilities | null;
12312 interface RTCRtpTransceiver {
12313 readonly currentDirection: RTCRtpTransceiverDirection | null;
12314 direction: RTCRtpTransceiverDirection;
12315 readonly mid: string | null;
12316 readonly receiver: RTCRtpReceiver;
12317 readonly sender: RTCRtpSender;
12318 setCodecPreferences(codecs: RTCRtpCodecCapability[]): void;
12322 declare var RTCRtpTransceiver: {
12323 prototype: RTCRtpTransceiver;
12324 new(): RTCRtpTransceiver;
12327 interface RTCSctpTransportEventMap {
12328 "statechange": Event;
12331 interface RTCSctpTransport extends EventTarget {
12332 readonly maxChannels: number | null;
12333 readonly maxMessageSize: number;
12334 onstatechange: ((this: RTCSctpTransport, ev: Event) => any) | null;
12335 readonly state: RTCSctpTransportState;
12336 readonly transport: RTCDtlsTransport;
12337 addEventListener<K extends keyof RTCSctpTransportEventMap>(type: K, listener: (this: RTCSctpTransport, ev: RTCSctpTransportEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12338 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12339 removeEventListener<K extends keyof RTCSctpTransportEventMap>(type: K, listener: (this: RTCSctpTransport, ev: RTCSctpTransportEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12340 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12343 declare var RTCSctpTransport: {
12344 prototype: RTCSctpTransport;
12345 new(): RTCSctpTransport;
12348 /** 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. */
12349 interface RTCSessionDescription {
12350 readonly sdp: string;
12351 readonly type: RTCSdpType;
12355 declare var RTCSessionDescription: {
12356 prototype: RTCSessionDescription;
12357 new(descriptionInitDict?: RTCSessionDescriptionInit): RTCSessionDescription;
12360 interface RTCSrtpSdesTransportEventMap {
12364 interface RTCSrtpSdesTransport extends EventTarget {
12365 onerror: ((this: RTCSrtpSdesTransport, ev: Event) => any) | null;
12366 readonly transport: RTCIceTransport;
12367 addEventListener<K extends keyof RTCSrtpSdesTransportEventMap>(type: K, listener: (this: RTCSrtpSdesTransport, ev: RTCSrtpSdesTransportEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12368 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12369 removeEventListener<K extends keyof RTCSrtpSdesTransportEventMap>(type: K, listener: (this: RTCSrtpSdesTransport, ev: RTCSrtpSdesTransportEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12370 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12373 declare var RTCSrtpSdesTransport: {
12374 prototype: RTCSrtpSdesTransport;
12375 new(transport: RTCIceTransport, encryptParameters: RTCSrtpSdesParameters, decryptParameters: RTCSrtpSdesParameters): RTCSrtpSdesTransport;
12376 getLocalParameters(): RTCSrtpSdesParameters[];
12379 interface RTCSsrcConflictEvent extends Event {
12380 readonly ssrc: number;
12383 declare var RTCSsrcConflictEvent: {
12384 prototype: RTCSsrcConflictEvent;
12385 new(): RTCSsrcConflictEvent;
12388 interface RTCStatsEvent extends Event {
12389 readonly report: RTCStatsReport;
12392 declare var RTCStatsEvent: {
12393 prototype: RTCStatsEvent;
12394 new(type: string, eventInitDict: RTCStatsEventInit): RTCStatsEvent;
12397 interface RTCStatsProvider extends EventTarget {
12398 getStats(): Promise<RTCStatsReport>;
12399 msGetStats(): Promise<RTCStatsReport>;
12402 declare var RTCStatsProvider: {
12403 prototype: RTCStatsProvider;
12404 new(): RTCStatsProvider;
12407 interface RTCStatsReport {
12408 forEach(callbackfn: (value: any, key: string, parent: RTCStatsReport) => void, thisArg?: any): void;
12411 declare var RTCStatsReport: {
12412 prototype: RTCStatsReport;
12413 new(): RTCStatsReport;
12416 interface RTCTrackEvent extends Event {
12417 readonly receiver: RTCRtpReceiver;
12418 readonly streams: ReadonlyArray<MediaStream>;
12419 readonly track: MediaStreamTrack;
12420 readonly transceiver: RTCRtpTransceiver;
12423 declare var RTCTrackEvent: {
12424 prototype: RTCTrackEvent;
12425 new(type: string, eventInitDict: RTCTrackEventInit): RTCTrackEvent;
12428 interface RadioNodeList extends NodeList {
12432 declare var RadioNodeList: {
12433 prototype: RadioNodeList;
12434 new(): RadioNodeList;
12437 interface RandomSource {
12438 getRandomValues<T extends Int8Array | Uint8ClampedArray | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array>(array: T): T;
12441 declare var RandomSource: {
12442 prototype: RandomSource;
12443 new(): RandomSource;
12446 /** A fragment of a document that can contain nodes and parts of text nodes. */
12447 interface Range extends AbstractRange {
12449 * Returns the node, furthest away from the document, that is an ancestor of both range's start node and end node.
12451 readonly commonAncestorContainer: Node;
12452 cloneContents(): DocumentFragment;
12453 cloneRange(): Range;
12454 collapse(toStart?: boolean): void;
12455 compareBoundaryPoints(how: number, sourceRange: Range): number;
12457 * 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.
12459 comparePoint(node: Node, offset: number): number;
12460 createContextualFragment(fragment: string): DocumentFragment;
12461 deleteContents(): void;
12463 extractContents(): DocumentFragment;
12464 getBoundingClientRect(): DOMRect;
12465 getClientRects(): DOMRectList;
12466 insertNode(node: Node): void;
12468 * Returns whether range intersects node.
12470 intersectsNode(node: Node): boolean;
12471 isPointInRange(node: Node, offset: number): boolean;
12472 selectNode(node: Node): void;
12473 selectNodeContents(node: Node): void;
12474 setEnd(node: Node, offset: number): void;
12475 setEndAfter(node: Node): void;
12476 setEndBefore(node: Node): void;
12477 setStart(node: Node, offset: number): void;
12478 setStartAfter(node: Node): void;
12479 setStartBefore(node: Node): void;
12480 surroundContents(newParent: Node): void;
12481 toString(): string;
12482 readonly END_TO_END: number;
12483 readonly END_TO_START: number;
12484 readonly START_TO_END: number;
12485 readonly START_TO_START: number;
12488 declare var Range: {
12491 readonly END_TO_END: number;
12492 readonly END_TO_START: number;
12493 readonly START_TO_END: number;
12494 readonly START_TO_START: number;
12495 toString(): string;
12498 interface ReadableByteStreamController {
12499 readonly byobRequest: ReadableStreamBYOBRequest | undefined;
12500 readonly desiredSize: number | null;
12502 enqueue(chunk: ArrayBufferView): void;
12503 error(error?: any): void;
12506 declare var ReadableByteStreamController: {
12507 prototype: ReadableByteStreamController;
12508 new(): ReadableByteStreamController;
12511 /** 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. */
12512 interface ReadableStream<R = any> {
12513 readonly locked: boolean;
12514 cancel(reason?: any): Promise<void>;
12515 getReader(options: { mode: "byob" }): ReadableStreamBYOBReader;
12516 getReader(): ReadableStreamDefaultReader<R>;
12517 pipeThrough<T>({ writable, readable }: { writable: WritableStream<R>, readable: ReadableStream<T> }, options?: PipeOptions): ReadableStream<T>;
12518 pipeTo(dest: WritableStream<R>, options?: PipeOptions): Promise<void>;
12519 tee(): [ReadableStream<R>, ReadableStream<R>];
12522 declare var ReadableStream: {
12523 prototype: ReadableStream;
12524 new(underlyingSource: UnderlyingByteSource, strategy?: { highWaterMark?: number, size?: undefined }): ReadableStream<Uint8Array>;
12525 new<R = any>(underlyingSource?: UnderlyingSource<R>, strategy?: QueuingStrategy<R>): ReadableStream<R>;
12528 interface ReadableStreamBYOBReader {
12529 readonly closed: Promise<void>;
12530 cancel(reason?: any): Promise<void>;
12531 read<T extends ArrayBufferView>(view: T): Promise<ReadableStreamReadResult<T>>;
12532 releaseLock(): void;
12535 declare var ReadableStreamBYOBReader: {
12536 prototype: ReadableStreamBYOBReader;
12537 new(): ReadableStreamBYOBReader;
12540 interface ReadableStreamBYOBRequest {
12541 readonly view: ArrayBufferView;
12542 respond(bytesWritten: number): void;
12543 respondWithNewView(view: ArrayBufferView): void;
12546 declare var ReadableStreamBYOBRequest: {
12547 prototype: ReadableStreamBYOBRequest;
12548 new(): ReadableStreamBYOBRequest;
12551 interface ReadableStreamDefaultController<R = any> {
12552 readonly desiredSize: number | null;
12554 enqueue(chunk: R): void;
12555 error(error?: any): void;
12558 declare var ReadableStreamDefaultController: {
12559 prototype: ReadableStreamDefaultController;
12560 new(): ReadableStreamDefaultController;
12563 interface ReadableStreamDefaultReader<R = any> {
12564 readonly closed: Promise<void>;
12565 cancel(reason?: any): Promise<void>;
12566 read(): Promise<ReadableStreamReadResult<R>>;
12567 releaseLock(): void;
12570 declare var ReadableStreamDefaultReader: {
12571 prototype: ReadableStreamDefaultReader;
12572 new(): ReadableStreamDefaultReader;
12575 interface ReadableStreamReader<R = any> {
12576 cancel(): Promise<void>;
12577 read(): Promise<ReadableStreamReadResult<R>>;
12578 releaseLock(): void;
12581 declare var ReadableStreamReader: {
12582 prototype: ReadableStreamReader;
12583 new(): ReadableStreamReader;
12586 /** This Fetch API interface represents a resource request. */
12587 interface Request extends Body {
12589 * Returns the cache mode associated with request, which is a string indicating how the request will interact with the browser's cache when fetching.
12591 readonly cache: RequestCache;
12593 * 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.
12595 readonly credentials: RequestCredentials;
12597 * Returns the kind of resource requested by request, e.g., "document" or "script".
12599 readonly destination: RequestDestination;
12601 * 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.
12603 readonly headers: Headers;
12605 * 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]
12607 readonly integrity: string;
12609 * Returns a boolean indicating whether or not request is for a history navigation (a.k.a. back-foward navigation).
12611 readonly isHistoryNavigation: boolean;
12613 * Returns a boolean indicating whether or not request is for a reload navigation.
12615 readonly isReloadNavigation: boolean;
12617 * Returns a boolean indicating whether or not request can outlive the global in which it was created.
12619 readonly keepalive: boolean;
12621 * Returns request's HTTP method, which is "GET" by default.
12623 readonly method: string;
12625 * 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.
12627 readonly mode: RequestMode;
12629 * 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.
12631 readonly redirect: RequestRedirect;
12633 * 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.
12635 readonly referrer: string;
12637 * Returns the referrer policy associated with request. This is used during fetching to compute the value of the request's referrer.
12639 readonly referrerPolicy: ReferrerPolicy;
12641 * Returns the signal associated with request, which is an AbortSignal object indicating whether or not request has been aborted, and its abort event handler.
12643 readonly signal: AbortSignal;
12645 * Returns the URL of request as a string.
12647 readonly url: string;
12651 declare var Request: {
12652 prototype: Request;
12653 new(input: RequestInfo, init?: RequestInit): Request;
12656 /** This Fetch API interface represents the response to a request. */
12657 interface Response extends Body {
12658 readonly headers: Headers;
12659 readonly ok: boolean;
12660 readonly redirected: boolean;
12661 readonly status: number;
12662 readonly statusText: string;
12663 readonly trailer: Promise<Headers>;
12664 readonly type: ResponseType;
12665 readonly url: string;
12669 declare var Response: {
12670 prototype: Response;
12671 new(body?: BodyInit | null, init?: ResponseInit): Response;
12673 redirect(url: string, status?: number): Response;
12676 /** Provides access to the properties of <a> element, as well as methods to manipulate them. */
12677 interface SVGAElement extends SVGGraphicsElement, SVGURIReference {
12678 readonly target: SVGAnimatedString;
12679 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGAElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12680 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12681 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGAElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12682 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12685 declare var SVGAElement: {
12686 prototype: SVGAElement;
12687 new(): SVGAElement;
12690 /** Used to represent a value that can be an <angle> or <number> value. An SVGAngle reflected through the animVal attribute is always read only. */
12691 interface SVGAngle {
12692 readonly unitType: number;
12694 valueAsString: string;
12695 valueInSpecifiedUnits: number;
12696 convertToSpecifiedUnits(unitType: number): void;
12697 newValueSpecifiedUnits(unitType: number, valueInSpecifiedUnits: number): void;
12698 readonly SVG_ANGLETYPE_DEG: number;
12699 readonly SVG_ANGLETYPE_GRAD: number;
12700 readonly SVG_ANGLETYPE_RAD: number;
12701 readonly SVG_ANGLETYPE_UNKNOWN: number;
12702 readonly SVG_ANGLETYPE_UNSPECIFIED: number;
12705 declare var SVGAngle: {
12706 prototype: SVGAngle;
12708 readonly SVG_ANGLETYPE_DEG: number;
12709 readonly SVG_ANGLETYPE_GRAD: number;
12710 readonly SVG_ANGLETYPE_RAD: number;
12711 readonly SVG_ANGLETYPE_UNKNOWN: number;
12712 readonly SVG_ANGLETYPE_UNSPECIFIED: number;
12715 interface SVGAnimateElement extends SVGAnimationElement {
12716 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGAnimateElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12717 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12718 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGAnimateElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12719 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12722 declare var SVGAnimateElement: {
12723 prototype: SVGAnimateElement;
12724 new(): SVGAnimateElement;
12727 interface SVGAnimateMotionElement extends SVGAnimationElement {
12728 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGAnimateMotionElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12729 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12730 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGAnimateMotionElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12731 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12734 declare var SVGAnimateMotionElement: {
12735 prototype: SVGAnimateMotionElement;
12736 new(): SVGAnimateMotionElement;
12739 interface SVGAnimateTransformElement extends SVGAnimationElement {
12740 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGAnimateTransformElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12741 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12742 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGAnimateTransformElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12743 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12746 declare var SVGAnimateTransformElement: {
12747 prototype: SVGAnimateTransformElement;
12748 new(): SVGAnimateTransformElement;
12751 /** Used for attributes of basic type <angle> which can be animated. */
12752 interface SVGAnimatedAngle {
12753 readonly animVal: SVGAngle;
12754 readonly baseVal: SVGAngle;
12757 declare var SVGAnimatedAngle: {
12758 prototype: SVGAnimatedAngle;
12759 new(): SVGAnimatedAngle;
12762 /** Used for attributes of type boolean which can be animated. */
12763 interface SVGAnimatedBoolean {
12764 readonly animVal: boolean;
12768 declare var SVGAnimatedBoolean: {
12769 prototype: SVGAnimatedBoolean;
12770 new(): SVGAnimatedBoolean;
12773 /** Used for attributes whose value must be a constant from a particular enumeration and which can be animated. */
12774 interface SVGAnimatedEnumeration {
12775 readonly animVal: number;
12779 declare var SVGAnimatedEnumeration: {
12780 prototype: SVGAnimatedEnumeration;
12781 new(): SVGAnimatedEnumeration;
12784 /** Used for attributes of basic type <integer> which can be animated. */
12785 interface SVGAnimatedInteger {
12786 readonly animVal: number;
12790 declare var SVGAnimatedInteger: {
12791 prototype: SVGAnimatedInteger;
12792 new(): SVGAnimatedInteger;
12795 /** Used for attributes of basic type <length> which can be animated. */
12796 interface SVGAnimatedLength {
12797 readonly animVal: SVGLength;
12798 readonly baseVal: SVGLength;
12801 declare var SVGAnimatedLength: {
12802 prototype: SVGAnimatedLength;
12803 new(): SVGAnimatedLength;
12806 /** Used for attributes of type SVGLengthList which can be animated. */
12807 interface SVGAnimatedLengthList {
12808 readonly animVal: SVGLengthList;
12809 readonly baseVal: SVGLengthList;
12812 declare var SVGAnimatedLengthList: {
12813 prototype: SVGAnimatedLengthList;
12814 new(): SVGAnimatedLengthList;
12817 /** Used for attributes of basic type <Number> which can be animated. */
12818 interface SVGAnimatedNumber {
12819 readonly animVal: number;
12823 declare var SVGAnimatedNumber: {
12824 prototype: SVGAnimatedNumber;
12825 new(): SVGAnimatedNumber;
12828 /** The SVGAnimatedNumber interface is used for attributes which take a list of numbers and which can be animated. */
12829 interface SVGAnimatedNumberList {
12830 readonly animVal: SVGNumberList;
12831 readonly baseVal: SVGNumberList;
12834 declare var SVGAnimatedNumberList: {
12835 prototype: SVGAnimatedNumberList;
12836 new(): SVGAnimatedNumberList;
12839 interface SVGAnimatedPoints {
12840 readonly animatedPoints: SVGPointList;
12841 readonly points: SVGPointList;
12844 /** Used for attributes of type SVGPreserveAspectRatio which can be animated. */
12845 interface SVGAnimatedPreserveAspectRatio {
12846 readonly animVal: SVGPreserveAspectRatio;
12847 readonly baseVal: SVGPreserveAspectRatio;
12850 declare var SVGAnimatedPreserveAspectRatio: {
12851 prototype: SVGAnimatedPreserveAspectRatio;
12852 new(): SVGAnimatedPreserveAspectRatio;
12855 /** Used for attributes of basic SVGRect which can be animated. */
12856 interface SVGAnimatedRect {
12857 readonly animVal: DOMRectReadOnly;
12858 readonly baseVal: DOMRect;
12861 declare var SVGAnimatedRect: {
12862 prototype: SVGAnimatedRect;
12863 new(): SVGAnimatedRect;
12866 /** 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. */
12867 interface SVGAnimatedString {
12868 readonly animVal: string;
12872 declare var SVGAnimatedString: {
12873 prototype: SVGAnimatedString;
12874 new(): SVGAnimatedString;
12877 /** Used for attributes which take a list of numbers and which can be animated. */
12878 interface SVGAnimatedTransformList {
12879 readonly animVal: SVGTransformList;
12880 readonly baseVal: SVGTransformList;
12883 declare var SVGAnimatedTransformList: {
12884 prototype: SVGAnimatedTransformList;
12885 new(): SVGAnimatedTransformList;
12888 interface SVGAnimationElement extends SVGElement {
12889 readonly targetElement: SVGElement;
12890 getCurrentTime(): number;
12891 getSimpleDuration(): number;
12892 getStartTime(): number;
12893 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGAnimationElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12894 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12895 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGAnimationElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12896 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12899 declare var SVGAnimationElement: {
12900 prototype: SVGAnimationElement;
12901 new(): SVGAnimationElement;
12904 /** 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. */
12905 interface SVGCircleElement extends SVGGeometryElement {
12906 readonly cx: SVGAnimatedLength;
12907 readonly cy: SVGAnimatedLength;
12908 readonly r: SVGAnimatedLength;
12909 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGCircleElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12910 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12911 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGCircleElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12912 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12915 declare var SVGCircleElement: {
12916 prototype: SVGCircleElement;
12917 new(): SVGCircleElement;
12920 /** Provides access to the properties of <clipPath> elements, as well as methods to manipulate them. */
12921 interface SVGClipPathElement extends SVGElement {
12922 readonly clipPathUnits: SVGAnimatedEnumeration;
12923 readonly transform: SVGAnimatedTransformList;
12924 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGClipPathElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12925 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12926 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGClipPathElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12927 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12930 declare var SVGClipPathElement: {
12931 prototype: SVGClipPathElement;
12932 new(): SVGClipPathElement;
12935 /** A base interface used by the component transfer function interfaces. */
12936 interface SVGComponentTransferFunctionElement extends SVGElement {
12937 readonly amplitude: SVGAnimatedNumber;
12938 readonly exponent: SVGAnimatedNumber;
12939 readonly intercept: SVGAnimatedNumber;
12940 readonly offset: SVGAnimatedNumber;
12941 readonly slope: SVGAnimatedNumber;
12942 readonly tableValues: SVGAnimatedNumberList;
12943 readonly type: SVGAnimatedEnumeration;
12944 readonly SVG_FECOMPONENTTRANSFER_TYPE_DISCRETE: number;
12945 readonly SVG_FECOMPONENTTRANSFER_TYPE_GAMMA: number;
12946 readonly SVG_FECOMPONENTTRANSFER_TYPE_IDENTITY: number;
12947 readonly SVG_FECOMPONENTTRANSFER_TYPE_LINEAR: number;
12948 readonly SVG_FECOMPONENTTRANSFER_TYPE_TABLE: number;
12949 readonly SVG_FECOMPONENTTRANSFER_TYPE_UNKNOWN: number;
12950 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGComponentTransferFunctionElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12951 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12952 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGComponentTransferFunctionElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12953 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12956 declare var SVGComponentTransferFunctionElement: {
12957 prototype: SVGComponentTransferFunctionElement;
12958 new(): SVGComponentTransferFunctionElement;
12959 readonly SVG_FECOMPONENTTRANSFER_TYPE_DISCRETE: number;
12960 readonly SVG_FECOMPONENTTRANSFER_TYPE_GAMMA: number;
12961 readonly SVG_FECOMPONENTTRANSFER_TYPE_IDENTITY: number;
12962 readonly SVG_FECOMPONENTTRANSFER_TYPE_LINEAR: number;
12963 readonly SVG_FECOMPONENTTRANSFER_TYPE_TABLE: number;
12964 readonly SVG_FECOMPONENTTRANSFER_TYPE_UNKNOWN: number;
12967 interface SVGCursorElement extends SVGElement {
12968 readonly x: SVGAnimatedLength;
12969 readonly y: SVGAnimatedLength;
12970 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGCursorElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12971 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12972 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGCursorElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12973 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12976 declare var SVGCursorElement: {
12977 prototype: SVGCursorElement;
12978 new(): SVGCursorElement;
12981 /** Corresponds to the <defs> element. */
12982 interface SVGDefsElement extends SVGGraphicsElement {
12983 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGDefsElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12984 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12985 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGDefsElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12986 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12989 declare var SVGDefsElement: {
12990 prototype: SVGDefsElement;
12991 new(): SVGDefsElement;
12994 /** Corresponds to the <desc> element. */
12995 interface SVGDescElement extends SVGElement {
12996 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGDescElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12997 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12998 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGDescElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12999 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13002 declare var SVGDescElement: {
13003 prototype: SVGDescElement;
13004 new(): SVGDescElement;
13007 interface SVGElementEventMap extends ElementEventMap, GlobalEventHandlersEventMap, DocumentAndElementEventHandlersEventMap {
13010 /** All of the SVG DOM interfaces that correspond directly to elements in the SVG language derive from the SVGElement interface. */
13011 interface SVGElement extends Element, DocumentAndElementEventHandlers, DocumentAndElementEventHandlers, ElementCSSInlineStyle, GlobalEventHandlers, GlobalEventHandlers, HTMLOrSVGElement, SVGElementInstance {
13013 readonly className: any;
13014 readonly ownerSVGElement: SVGSVGElement | null;
13015 readonly viewportElement: SVGElement | null;
13016 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13017 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13018 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13019 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13022 declare var SVGElement: {
13023 prototype: SVGElement;
13027 interface SVGElementInstance extends EventTarget {
13028 readonly correspondingElement: SVGElement;
13029 readonly correspondingUseElement: SVGUseElement;
13032 declare var SVGElementInstance: {
13033 prototype: SVGElementInstance;
13034 new(): SVGElementInstance;
13037 interface SVGElementInstanceList {
13039 readonly length: number;
13041 item(index: number): SVGElementInstance;
13044 declare var SVGElementInstanceList: {
13045 prototype: SVGElementInstanceList;
13046 new(): SVGElementInstanceList;
13049 /** Provides access to the properties of <ellipse> elements. */
13050 interface SVGEllipseElement extends SVGGeometryElement {
13051 readonly cx: SVGAnimatedLength;
13052 readonly cy: SVGAnimatedLength;
13053 readonly rx: SVGAnimatedLength;
13054 readonly ry: SVGAnimatedLength;
13055 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGEllipseElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13056 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13057 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGEllipseElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13058 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13061 declare var SVGEllipseElement: {
13062 prototype: SVGEllipseElement;
13063 new(): SVGEllipseElement;
13066 /** Corresponds to the <feBlend> element. */
13067 interface SVGFEBlendElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13068 readonly in1: SVGAnimatedString;
13069 readonly in2: SVGAnimatedString;
13070 readonly mode: SVGAnimatedEnumeration;
13071 readonly SVG_FEBLEND_MODE_COLOR: number;
13072 readonly SVG_FEBLEND_MODE_COLOR_BURN: number;
13073 readonly SVG_FEBLEND_MODE_COLOR_DODGE: number;
13074 readonly SVG_FEBLEND_MODE_DARKEN: number;
13075 readonly SVG_FEBLEND_MODE_DIFFERENCE: number;
13076 readonly SVG_FEBLEND_MODE_EXCLUSION: number;
13077 readonly SVG_FEBLEND_MODE_HARD_LIGHT: number;
13078 readonly SVG_FEBLEND_MODE_HUE: number;
13079 readonly SVG_FEBLEND_MODE_LIGHTEN: number;
13080 readonly SVG_FEBLEND_MODE_LUMINOSITY: number;
13081 readonly SVG_FEBLEND_MODE_MULTIPLY: number;
13082 readonly SVG_FEBLEND_MODE_NORMAL: number;
13083 readonly SVG_FEBLEND_MODE_OVERLAY: number;
13084 readonly SVG_FEBLEND_MODE_SATURATION: number;
13085 readonly SVG_FEBLEND_MODE_SCREEN: number;
13086 readonly SVG_FEBLEND_MODE_SOFT_LIGHT: number;
13087 readonly SVG_FEBLEND_MODE_UNKNOWN: number;
13088 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEBlendElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13089 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13090 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEBlendElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13091 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13094 declare var SVGFEBlendElement: {
13095 prototype: SVGFEBlendElement;
13096 new(): SVGFEBlendElement;
13097 readonly SVG_FEBLEND_MODE_COLOR: number;
13098 readonly SVG_FEBLEND_MODE_COLOR_BURN: number;
13099 readonly SVG_FEBLEND_MODE_COLOR_DODGE: number;
13100 readonly SVG_FEBLEND_MODE_DARKEN: number;
13101 readonly SVG_FEBLEND_MODE_DIFFERENCE: number;
13102 readonly SVG_FEBLEND_MODE_EXCLUSION: number;
13103 readonly SVG_FEBLEND_MODE_HARD_LIGHT: number;
13104 readonly SVG_FEBLEND_MODE_HUE: number;
13105 readonly SVG_FEBLEND_MODE_LIGHTEN: number;
13106 readonly SVG_FEBLEND_MODE_LUMINOSITY: number;
13107 readonly SVG_FEBLEND_MODE_MULTIPLY: number;
13108 readonly SVG_FEBLEND_MODE_NORMAL: number;
13109 readonly SVG_FEBLEND_MODE_OVERLAY: number;
13110 readonly SVG_FEBLEND_MODE_SATURATION: number;
13111 readonly SVG_FEBLEND_MODE_SCREEN: number;
13112 readonly SVG_FEBLEND_MODE_SOFT_LIGHT: number;
13113 readonly SVG_FEBLEND_MODE_UNKNOWN: number;
13116 /** Corresponds to the <feColorMatrix> element. */
13117 interface SVGFEColorMatrixElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13118 readonly in1: SVGAnimatedString;
13119 readonly type: SVGAnimatedEnumeration;
13120 readonly values: SVGAnimatedNumberList;
13121 readonly SVG_FECOLORMATRIX_TYPE_HUEROTATE: number;
13122 readonly SVG_FECOLORMATRIX_TYPE_LUMINANCETOALPHA: number;
13123 readonly SVG_FECOLORMATRIX_TYPE_MATRIX: number;
13124 readonly SVG_FECOLORMATRIX_TYPE_SATURATE: number;
13125 readonly SVG_FECOLORMATRIX_TYPE_UNKNOWN: number;
13126 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEColorMatrixElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13127 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13128 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEColorMatrixElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13129 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13132 declare var SVGFEColorMatrixElement: {
13133 prototype: SVGFEColorMatrixElement;
13134 new(): SVGFEColorMatrixElement;
13135 readonly SVG_FECOLORMATRIX_TYPE_HUEROTATE: number;
13136 readonly SVG_FECOLORMATRIX_TYPE_LUMINANCETOALPHA: number;
13137 readonly SVG_FECOLORMATRIX_TYPE_MATRIX: number;
13138 readonly SVG_FECOLORMATRIX_TYPE_SATURATE: number;
13139 readonly SVG_FECOLORMATRIX_TYPE_UNKNOWN: number;
13142 /** Corresponds to the <feComponentTransfer> element. */
13143 interface SVGFEComponentTransferElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13144 readonly in1: SVGAnimatedString;
13145 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEComponentTransferElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13146 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13147 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEComponentTransferElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13148 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13151 declare var SVGFEComponentTransferElement: {
13152 prototype: SVGFEComponentTransferElement;
13153 new(): SVGFEComponentTransferElement;
13156 /** Corresponds to the <feComposite> element. */
13157 interface SVGFECompositeElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13158 readonly in1: SVGAnimatedString;
13159 readonly in2: SVGAnimatedString;
13160 readonly k1: SVGAnimatedNumber;
13161 readonly k2: SVGAnimatedNumber;
13162 readonly k3: SVGAnimatedNumber;
13163 readonly k4: SVGAnimatedNumber;
13164 readonly operator: SVGAnimatedEnumeration;
13165 readonly SVG_FECOMPOSITE_OPERATOR_ARITHMETIC: number;
13166 readonly SVG_FECOMPOSITE_OPERATOR_ATOP: number;
13167 readonly SVG_FECOMPOSITE_OPERATOR_IN: number;
13168 readonly SVG_FECOMPOSITE_OPERATOR_OUT: number;
13169 readonly SVG_FECOMPOSITE_OPERATOR_OVER: number;
13170 readonly SVG_FECOMPOSITE_OPERATOR_UNKNOWN: number;
13171 readonly SVG_FECOMPOSITE_OPERATOR_XOR: number;
13172 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFECompositeElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13173 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13174 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFECompositeElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13175 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13178 declare var SVGFECompositeElement: {
13179 prototype: SVGFECompositeElement;
13180 new(): SVGFECompositeElement;
13181 readonly SVG_FECOMPOSITE_OPERATOR_ARITHMETIC: number;
13182 readonly SVG_FECOMPOSITE_OPERATOR_ATOP: number;
13183 readonly SVG_FECOMPOSITE_OPERATOR_IN: number;
13184 readonly SVG_FECOMPOSITE_OPERATOR_OUT: number;
13185 readonly SVG_FECOMPOSITE_OPERATOR_OVER: number;
13186 readonly SVG_FECOMPOSITE_OPERATOR_UNKNOWN: number;
13187 readonly SVG_FECOMPOSITE_OPERATOR_XOR: number;
13190 /** Corresponds to the <feConvolveMatrix> element. */
13191 interface SVGFEConvolveMatrixElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13192 readonly bias: SVGAnimatedNumber;
13193 readonly divisor: SVGAnimatedNumber;
13194 readonly edgeMode: SVGAnimatedEnumeration;
13195 readonly in1: SVGAnimatedString;
13196 readonly kernelMatrix: SVGAnimatedNumberList;
13197 readonly kernelUnitLengthX: SVGAnimatedNumber;
13198 readonly kernelUnitLengthY: SVGAnimatedNumber;
13199 readonly orderX: SVGAnimatedInteger;
13200 readonly orderY: SVGAnimatedInteger;
13201 readonly preserveAlpha: SVGAnimatedBoolean;
13202 readonly targetX: SVGAnimatedInteger;
13203 readonly targetY: SVGAnimatedInteger;
13204 readonly SVG_EDGEMODE_DUPLICATE: number;
13205 readonly SVG_EDGEMODE_NONE: number;
13206 readonly SVG_EDGEMODE_UNKNOWN: number;
13207 readonly SVG_EDGEMODE_WRAP: number;
13208 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEConvolveMatrixElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13209 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13210 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEConvolveMatrixElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13211 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13214 declare var SVGFEConvolveMatrixElement: {
13215 prototype: SVGFEConvolveMatrixElement;
13216 new(): SVGFEConvolveMatrixElement;
13217 readonly SVG_EDGEMODE_DUPLICATE: number;
13218 readonly SVG_EDGEMODE_NONE: number;
13219 readonly SVG_EDGEMODE_UNKNOWN: number;
13220 readonly SVG_EDGEMODE_WRAP: number;
13223 /** Corresponds to the <feDiffuseLighting> element. */
13224 interface SVGFEDiffuseLightingElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13225 readonly diffuseConstant: SVGAnimatedNumber;
13226 readonly in1: SVGAnimatedString;
13227 readonly kernelUnitLengthX: SVGAnimatedNumber;
13228 readonly kernelUnitLengthY: SVGAnimatedNumber;
13229 readonly surfaceScale: SVGAnimatedNumber;
13230 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEDiffuseLightingElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13231 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13232 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEDiffuseLightingElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13233 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13236 declare var SVGFEDiffuseLightingElement: {
13237 prototype: SVGFEDiffuseLightingElement;
13238 new(): SVGFEDiffuseLightingElement;
13241 /** Corresponds to the <feDisplacementMap> element. */
13242 interface SVGFEDisplacementMapElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13243 readonly in1: SVGAnimatedString;
13244 readonly in2: SVGAnimatedString;
13245 readonly scale: SVGAnimatedNumber;
13246 readonly xChannelSelector: SVGAnimatedEnumeration;
13247 readonly yChannelSelector: SVGAnimatedEnumeration;
13248 readonly SVG_CHANNEL_A: number;
13249 readonly SVG_CHANNEL_B: number;
13250 readonly SVG_CHANNEL_G: number;
13251 readonly SVG_CHANNEL_R: number;
13252 readonly SVG_CHANNEL_UNKNOWN: number;
13253 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEDisplacementMapElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13254 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13255 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEDisplacementMapElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13256 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13259 declare var SVGFEDisplacementMapElement: {
13260 prototype: SVGFEDisplacementMapElement;
13261 new(): SVGFEDisplacementMapElement;
13262 readonly SVG_CHANNEL_A: number;
13263 readonly SVG_CHANNEL_B: number;
13264 readonly SVG_CHANNEL_G: number;
13265 readonly SVG_CHANNEL_R: number;
13266 readonly SVG_CHANNEL_UNKNOWN: number;
13269 /** Corresponds to the <feDistantLight> element. */
13270 interface SVGFEDistantLightElement extends SVGElement {
13271 readonly azimuth: SVGAnimatedNumber;
13272 readonly elevation: SVGAnimatedNumber;
13273 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEDistantLightElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13274 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13275 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEDistantLightElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13276 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13279 declare var SVGFEDistantLightElement: {
13280 prototype: SVGFEDistantLightElement;
13281 new(): SVGFEDistantLightElement;
13284 interface SVGFEDropShadowElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13285 readonly dx: SVGAnimatedNumber;
13286 readonly dy: SVGAnimatedNumber;
13287 readonly in1: SVGAnimatedString;
13288 readonly stdDeviationX: SVGAnimatedNumber;
13289 readonly stdDeviationY: SVGAnimatedNumber;
13290 setStdDeviation(stdDeviationX: number, stdDeviationY: number): void;
13291 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEDropShadowElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13292 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13293 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEDropShadowElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13294 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13297 declare var SVGFEDropShadowElement: {
13298 prototype: SVGFEDropShadowElement;
13299 new(): SVGFEDropShadowElement;
13302 /** Corresponds to the <feFlood> element. */
13303 interface SVGFEFloodElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13304 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEFloodElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13305 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13306 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEFloodElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13307 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13310 declare var SVGFEFloodElement: {
13311 prototype: SVGFEFloodElement;
13312 new(): SVGFEFloodElement;
13315 /** Corresponds to the <feFuncA> element. */
13316 interface SVGFEFuncAElement extends SVGComponentTransferFunctionElement {
13317 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEFuncAElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13318 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13319 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEFuncAElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13320 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13323 declare var SVGFEFuncAElement: {
13324 prototype: SVGFEFuncAElement;
13325 new(): SVGFEFuncAElement;
13328 /** Corresponds to the <feFuncB> element. */
13329 interface SVGFEFuncBElement extends SVGComponentTransferFunctionElement {
13330 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEFuncBElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13331 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13332 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEFuncBElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13333 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13336 declare var SVGFEFuncBElement: {
13337 prototype: SVGFEFuncBElement;
13338 new(): SVGFEFuncBElement;
13341 /** Corresponds to the <feFuncG> element. */
13342 interface SVGFEFuncGElement extends SVGComponentTransferFunctionElement {
13343 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEFuncGElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13344 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13345 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEFuncGElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13346 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13349 declare var SVGFEFuncGElement: {
13350 prototype: SVGFEFuncGElement;
13351 new(): SVGFEFuncGElement;
13354 /** Corresponds to the <feFuncR> element. */
13355 interface SVGFEFuncRElement extends SVGComponentTransferFunctionElement {
13356 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEFuncRElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13357 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13358 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEFuncRElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13359 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13362 declare var SVGFEFuncRElement: {
13363 prototype: SVGFEFuncRElement;
13364 new(): SVGFEFuncRElement;
13367 /** Corresponds to the <feGaussianBlur> element. */
13368 interface SVGFEGaussianBlurElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13369 readonly in1: SVGAnimatedString;
13370 readonly stdDeviationX: SVGAnimatedNumber;
13371 readonly stdDeviationY: SVGAnimatedNumber;
13372 setStdDeviation(stdDeviationX: number, stdDeviationY: number): void;
13373 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEGaussianBlurElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13374 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13375 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEGaussianBlurElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13376 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13379 declare var SVGFEGaussianBlurElement: {
13380 prototype: SVGFEGaussianBlurElement;
13381 new(): SVGFEGaussianBlurElement;
13384 /** Corresponds to the <feImage> element. */
13385 interface SVGFEImageElement extends SVGElement, SVGFilterPrimitiveStandardAttributes, SVGURIReference {
13386 readonly preserveAspectRatio: SVGAnimatedPreserveAspectRatio;
13387 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEImageElement, 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: SVGFEImageElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13390 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13393 declare var SVGFEImageElement: {
13394 prototype: SVGFEImageElement;
13395 new(): SVGFEImageElement;
13398 /** Corresponds to the <feMerge> element. */
13399 interface SVGFEMergeElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13400 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEMergeElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13401 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13402 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEMergeElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13403 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13406 declare var SVGFEMergeElement: {
13407 prototype: SVGFEMergeElement;
13408 new(): SVGFEMergeElement;
13411 /** Corresponds to the <feMergeNode> element. */
13412 interface SVGFEMergeNodeElement extends SVGElement {
13413 readonly in1: SVGAnimatedString;
13414 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEMergeNodeElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13415 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13416 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEMergeNodeElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13417 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13420 declare var SVGFEMergeNodeElement: {
13421 prototype: SVGFEMergeNodeElement;
13422 new(): SVGFEMergeNodeElement;
13425 /** Corresponds to the <feMorphology> element. */
13426 interface SVGFEMorphologyElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13427 readonly in1: SVGAnimatedString;
13428 readonly operator: SVGAnimatedEnumeration;
13429 readonly radiusX: SVGAnimatedNumber;
13430 readonly radiusY: SVGAnimatedNumber;
13431 readonly SVG_MORPHOLOGY_OPERATOR_DILATE: number;
13432 readonly SVG_MORPHOLOGY_OPERATOR_ERODE: number;
13433 readonly SVG_MORPHOLOGY_OPERATOR_UNKNOWN: number;
13434 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEMorphologyElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13435 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13436 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEMorphologyElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13437 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13440 declare var SVGFEMorphologyElement: {
13441 prototype: SVGFEMorphologyElement;
13442 new(): SVGFEMorphologyElement;
13443 readonly SVG_MORPHOLOGY_OPERATOR_DILATE: number;
13444 readonly SVG_MORPHOLOGY_OPERATOR_ERODE: number;
13445 readonly SVG_MORPHOLOGY_OPERATOR_UNKNOWN: number;
13448 /** Corresponds to the <feOffset> element. */
13449 interface SVGFEOffsetElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13450 readonly dx: SVGAnimatedNumber;
13451 readonly dy: SVGAnimatedNumber;
13452 readonly in1: SVGAnimatedString;
13453 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEOffsetElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13454 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13455 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEOffsetElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13456 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13459 declare var SVGFEOffsetElement: {
13460 prototype: SVGFEOffsetElement;
13461 new(): SVGFEOffsetElement;
13464 /** Corresponds to the <fePointLight> element. */
13465 interface SVGFEPointLightElement extends SVGElement {
13466 readonly x: SVGAnimatedNumber;
13467 readonly y: SVGAnimatedNumber;
13468 readonly z: SVGAnimatedNumber;
13469 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEPointLightElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13470 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13471 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEPointLightElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13472 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13475 declare var SVGFEPointLightElement: {
13476 prototype: SVGFEPointLightElement;
13477 new(): SVGFEPointLightElement;
13480 /** Corresponds to the <feSpecularLighting> element. */
13481 interface SVGFESpecularLightingElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13482 readonly in1: SVGAnimatedString;
13483 readonly kernelUnitLengthX: SVGAnimatedNumber;
13484 readonly kernelUnitLengthY: SVGAnimatedNumber;
13485 readonly specularConstant: SVGAnimatedNumber;
13486 readonly specularExponent: SVGAnimatedNumber;
13487 readonly surfaceScale: SVGAnimatedNumber;
13488 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFESpecularLightingElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13489 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13490 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFESpecularLightingElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13491 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13494 declare var SVGFESpecularLightingElement: {
13495 prototype: SVGFESpecularLightingElement;
13496 new(): SVGFESpecularLightingElement;
13499 /** Corresponds to the <feSpotLight> element. */
13500 interface SVGFESpotLightElement extends SVGElement {
13501 readonly limitingConeAngle: SVGAnimatedNumber;
13502 readonly pointsAtX: SVGAnimatedNumber;
13503 readonly pointsAtY: SVGAnimatedNumber;
13504 readonly pointsAtZ: SVGAnimatedNumber;
13505 readonly specularExponent: SVGAnimatedNumber;
13506 readonly x: SVGAnimatedNumber;
13507 readonly y: SVGAnimatedNumber;
13508 readonly z: SVGAnimatedNumber;
13509 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFESpotLightElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13510 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13511 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFESpotLightElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13512 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13515 declare var SVGFESpotLightElement: {
13516 prototype: SVGFESpotLightElement;
13517 new(): SVGFESpotLightElement;
13520 /** Corresponds to the <feTile> element. */
13521 interface SVGFETileElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13522 readonly in1: SVGAnimatedString;
13523 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFETileElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13524 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13525 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFETileElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13526 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13529 declare var SVGFETileElement: {
13530 prototype: SVGFETileElement;
13531 new(): SVGFETileElement;
13534 /** Corresponds to the <feTurbulence> element. */
13535 interface SVGFETurbulenceElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13536 readonly baseFrequencyX: SVGAnimatedNumber;
13537 readonly baseFrequencyY: SVGAnimatedNumber;
13538 readonly numOctaves: SVGAnimatedInteger;
13539 readonly seed: SVGAnimatedNumber;
13540 readonly stitchTiles: SVGAnimatedEnumeration;
13541 readonly type: SVGAnimatedEnumeration;
13542 readonly SVG_STITCHTYPE_NOSTITCH: number;
13543 readonly SVG_STITCHTYPE_STITCH: number;
13544 readonly SVG_STITCHTYPE_UNKNOWN: number;
13545 readonly SVG_TURBULENCE_TYPE_FRACTALNOISE: number;
13546 readonly SVG_TURBULENCE_TYPE_TURBULENCE: number;
13547 readonly SVG_TURBULENCE_TYPE_UNKNOWN: number;
13548 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFETurbulenceElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13549 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13550 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFETurbulenceElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13551 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13554 declare var SVGFETurbulenceElement: {
13555 prototype: SVGFETurbulenceElement;
13556 new(): SVGFETurbulenceElement;
13557 readonly SVG_STITCHTYPE_NOSTITCH: number;
13558 readonly SVG_STITCHTYPE_STITCH: number;
13559 readonly SVG_STITCHTYPE_UNKNOWN: number;
13560 readonly SVG_TURBULENCE_TYPE_FRACTALNOISE: number;
13561 readonly SVG_TURBULENCE_TYPE_TURBULENCE: number;
13562 readonly SVG_TURBULENCE_TYPE_UNKNOWN: number;
13565 /** Provides access to the properties of <filter> elements, as well as methods to manipulate them. */
13566 interface SVGFilterElement extends SVGElement, SVGURIReference {
13567 readonly filterUnits: SVGAnimatedEnumeration;
13568 readonly height: SVGAnimatedLength;
13569 readonly primitiveUnits: SVGAnimatedEnumeration;
13570 readonly width: SVGAnimatedLength;
13571 readonly x: SVGAnimatedLength;
13572 readonly y: SVGAnimatedLength;
13573 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFilterElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13574 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13575 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFilterElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13576 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13579 declare var SVGFilterElement: {
13580 prototype: SVGFilterElement;
13581 new(): SVGFilterElement;
13584 interface SVGFilterPrimitiveStandardAttributes {
13585 readonly height: SVGAnimatedLength;
13586 readonly result: SVGAnimatedString;
13587 readonly width: SVGAnimatedLength;
13588 readonly x: SVGAnimatedLength;
13589 readonly y: SVGAnimatedLength;
13592 interface SVGFitToViewBox {
13593 readonly preserveAspectRatio: SVGAnimatedPreserveAspectRatio;
13594 readonly viewBox: SVGAnimatedRect;
13597 /** Provides access to the properties of <foreignObject> elements, as well as methods to manipulate them. */
13598 interface SVGForeignObjectElement extends SVGGraphicsElement {
13599 readonly height: SVGAnimatedLength;
13600 readonly width: SVGAnimatedLength;
13601 readonly x: SVGAnimatedLength;
13602 readonly y: SVGAnimatedLength;
13603 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGForeignObjectElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13604 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13605 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGForeignObjectElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13606 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13609 declare var SVGForeignObjectElement: {
13610 prototype: SVGForeignObjectElement;
13611 new(): SVGForeignObjectElement;
13614 /** Corresponds to the <g> element. */
13615 interface SVGGElement extends SVGGraphicsElement {
13616 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGGElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13617 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13618 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGGElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13619 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13622 declare var SVGGElement: {
13623 prototype: SVGGElement;
13624 new(): SVGGElement;
13627 interface SVGGeometryElement extends SVGGraphicsElement {
13628 readonly pathLength: SVGAnimatedNumber;
13629 getPointAtLength(distance: number): DOMPoint;
13630 getTotalLength(): number;
13631 isPointInFill(point?: DOMPointInit): boolean;
13632 isPointInStroke(point?: DOMPointInit): boolean;
13633 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGGeometryElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13634 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13635 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGGeometryElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13636 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13639 declare var SVGGeometryElement: {
13640 prototype: SVGGeometryElement;
13641 new(): SVGGeometryElement;
13644 /** The SVGGradient interface is a base interface used by SVGLinearGradientElement and SVGRadialGradientElement. */
13645 interface SVGGradientElement extends SVGElement, SVGURIReference {
13646 readonly gradientTransform: SVGAnimatedTransformList;
13647 readonly gradientUnits: SVGAnimatedEnumeration;
13648 readonly spreadMethod: SVGAnimatedEnumeration;
13649 readonly SVG_SPREADMETHOD_PAD: number;
13650 readonly SVG_SPREADMETHOD_REFLECT: number;
13651 readonly SVG_SPREADMETHOD_REPEAT: number;
13652 readonly SVG_SPREADMETHOD_UNKNOWN: number;
13653 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGGradientElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13654 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13655 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGGradientElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13656 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13659 declare var SVGGradientElement: {
13660 prototype: SVGGradientElement;
13661 new(): SVGGradientElement;
13662 readonly SVG_SPREADMETHOD_PAD: number;
13663 readonly SVG_SPREADMETHOD_REFLECT: number;
13664 readonly SVG_SPREADMETHOD_REPEAT: number;
13665 readonly SVG_SPREADMETHOD_UNKNOWN: number;
13668 /** SVG elements whose primary purpose is to directly render graphics into a group. */
13669 interface SVGGraphicsElement extends SVGElement, SVGTests {
13670 readonly transform: SVGAnimatedTransformList;
13671 getBBox(options?: SVGBoundingBoxOptions): DOMRect;
13672 getCTM(): DOMMatrix | null;
13673 getScreenCTM(): DOMMatrix | null;
13674 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGGraphicsElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13675 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13676 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGGraphicsElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13677 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13680 declare var SVGGraphicsElement: {
13681 prototype: SVGGraphicsElement;
13682 new(): SVGGraphicsElement;
13685 /** Corresponds to the <image> element. */
13686 interface SVGImageElement extends SVGGraphicsElement, SVGURIReference {
13687 readonly height: SVGAnimatedLength;
13688 readonly preserveAspectRatio: SVGAnimatedPreserveAspectRatio;
13689 readonly width: SVGAnimatedLength;
13690 readonly x: SVGAnimatedLength;
13691 readonly y: SVGAnimatedLength;
13692 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGImageElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13693 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13694 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGImageElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13695 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13698 declare var SVGImageElement: {
13699 prototype: SVGImageElement;
13700 new(): SVGImageElement;
13703 /** Correspond to the <length> basic data type. */
13704 interface SVGLength {
13705 readonly unitType: number;
13707 valueAsString: string;
13708 valueInSpecifiedUnits: number;
13709 convertToSpecifiedUnits(unitType: number): void;
13710 newValueSpecifiedUnits(unitType: number, valueInSpecifiedUnits: number): void;
13711 readonly SVG_LENGTHTYPE_CM: number;
13712 readonly SVG_LENGTHTYPE_EMS: number;
13713 readonly SVG_LENGTHTYPE_EXS: number;
13714 readonly SVG_LENGTHTYPE_IN: number;
13715 readonly SVG_LENGTHTYPE_MM: number;
13716 readonly SVG_LENGTHTYPE_NUMBER: number;
13717 readonly SVG_LENGTHTYPE_PC: number;
13718 readonly SVG_LENGTHTYPE_PERCENTAGE: number;
13719 readonly SVG_LENGTHTYPE_PT: number;
13720 readonly SVG_LENGTHTYPE_PX: number;
13721 readonly SVG_LENGTHTYPE_UNKNOWN: number;
13724 declare var SVGLength: {
13725 prototype: SVGLength;
13727 readonly SVG_LENGTHTYPE_CM: number;
13728 readonly SVG_LENGTHTYPE_EMS: number;
13729 readonly SVG_LENGTHTYPE_EXS: number;
13730 readonly SVG_LENGTHTYPE_IN: number;
13731 readonly SVG_LENGTHTYPE_MM: number;
13732 readonly SVG_LENGTHTYPE_NUMBER: number;
13733 readonly SVG_LENGTHTYPE_PC: number;
13734 readonly SVG_LENGTHTYPE_PERCENTAGE: number;
13735 readonly SVG_LENGTHTYPE_PT: number;
13736 readonly SVG_LENGTHTYPE_PX: number;
13737 readonly SVG_LENGTHTYPE_UNKNOWN: number;
13740 /** The SVGLengthList defines a list of SVGLength objects. */
13741 interface SVGLengthList {
13742 readonly length: number;
13743 readonly numberOfItems: number;
13744 appendItem(newItem: SVGLength): SVGLength;
13746 getItem(index: number): SVGLength;
13747 initialize(newItem: SVGLength): SVGLength;
13748 insertItemBefore(newItem: SVGLength, index: number): SVGLength;
13749 removeItem(index: number): SVGLength;
13750 replaceItem(newItem: SVGLength, index: number): SVGLength;
13751 [index: number]: SVGLength;
13754 declare var SVGLengthList: {
13755 prototype: SVGLengthList;
13756 new(): SVGLengthList;
13759 /** Provides access to the properties of <line> elements, as well as methods to manipulate them. */
13760 interface SVGLineElement extends SVGGeometryElement {
13761 readonly x1: SVGAnimatedLength;
13762 readonly x2: SVGAnimatedLength;
13763 readonly y1: SVGAnimatedLength;
13764 readonly y2: SVGAnimatedLength;
13765 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGLineElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13766 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13767 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGLineElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13768 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13771 declare var SVGLineElement: {
13772 prototype: SVGLineElement;
13773 new(): SVGLineElement;
13776 /** Corresponds to the <linearGradient> element. */
13777 interface SVGLinearGradientElement extends SVGGradientElement {
13778 readonly x1: SVGAnimatedLength;
13779 readonly x2: SVGAnimatedLength;
13780 readonly y1: SVGAnimatedLength;
13781 readonly y2: SVGAnimatedLength;
13782 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGLinearGradientElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13783 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13784 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGLinearGradientElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13785 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13788 declare var SVGLinearGradientElement: {
13789 prototype: SVGLinearGradientElement;
13790 new(): SVGLinearGradientElement;
13793 interface SVGMarkerElement extends SVGElement, SVGFitToViewBox {
13794 readonly markerHeight: SVGAnimatedLength;
13795 readonly markerUnits: SVGAnimatedEnumeration;
13796 readonly markerWidth: SVGAnimatedLength;
13797 readonly orientAngle: SVGAnimatedAngle;
13798 readonly orientType: SVGAnimatedEnumeration;
13799 readonly refX: SVGAnimatedLength;
13800 readonly refY: SVGAnimatedLength;
13801 setOrientToAngle(angle: SVGAngle): void;
13802 setOrientToAuto(): void;
13803 readonly SVG_MARKERUNITS_STROKEWIDTH: number;
13804 readonly SVG_MARKERUNITS_UNKNOWN: number;
13805 readonly SVG_MARKERUNITS_USERSPACEONUSE: number;
13806 readonly SVG_MARKER_ORIENT_ANGLE: number;
13807 readonly SVG_MARKER_ORIENT_AUTO: number;
13808 readonly SVG_MARKER_ORIENT_UNKNOWN: number;
13809 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGMarkerElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13810 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13811 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGMarkerElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13812 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13815 declare var SVGMarkerElement: {
13816 prototype: SVGMarkerElement;
13817 new(): SVGMarkerElement;
13818 readonly SVG_MARKERUNITS_STROKEWIDTH: number;
13819 readonly SVG_MARKERUNITS_UNKNOWN: number;
13820 readonly SVG_MARKERUNITS_USERSPACEONUSE: number;
13821 readonly SVG_MARKER_ORIENT_ANGLE: number;
13822 readonly SVG_MARKER_ORIENT_AUTO: number;
13823 readonly SVG_MARKER_ORIENT_UNKNOWN: number;
13826 /** Provides access to the properties of <mask> elements, as well as methods to manipulate them. */
13827 interface SVGMaskElement extends SVGElement {
13828 readonly height: SVGAnimatedLength;
13829 readonly maskContentUnits: SVGAnimatedEnumeration;
13830 readonly maskUnits: SVGAnimatedEnumeration;
13831 readonly width: SVGAnimatedLength;
13832 readonly x: SVGAnimatedLength;
13833 readonly y: SVGAnimatedLength;
13834 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGMaskElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13835 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13836 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGMaskElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13837 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13840 declare var SVGMaskElement: {
13841 prototype: SVGMaskElement;
13842 new(): SVGMaskElement;
13845 /** Corresponds to the <metadata> element. */
13846 interface SVGMetadataElement extends SVGElement {
13847 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGMetadataElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13848 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13849 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGMetadataElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13850 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13853 declare var SVGMetadataElement: {
13854 prototype: SVGMetadataElement;
13855 new(): SVGMetadataElement;
13858 /** Corresponds to the <number> basic data type. */
13859 interface SVGNumber {
13863 declare var SVGNumber: {
13864 prototype: SVGNumber;
13868 /** The SVGNumberList defines a list of SVGNumber objects. */
13869 interface SVGNumberList {
13870 readonly length: number;
13871 readonly numberOfItems: number;
13872 appendItem(newItem: SVGNumber): SVGNumber;
13874 getItem(index: number): SVGNumber;
13875 initialize(newItem: SVGNumber): SVGNumber;
13876 insertItemBefore(newItem: SVGNumber, index: number): SVGNumber;
13877 removeItem(index: number): SVGNumber;
13878 replaceItem(newItem: SVGNumber, index: number): SVGNumber;
13879 [index: number]: SVGNumber;
13882 declare var SVGNumberList: {
13883 prototype: SVGNumberList;
13884 new(): SVGNumberList;
13887 /** Corresponds to the <path> element. */
13888 interface SVGPathElement extends SVGGraphicsElement {
13890 readonly pathSegList: SVGPathSegList;
13892 createSVGPathSegArcAbs(x: number, y: number, r1: number, r2: number, angle: number, largeArcFlag: boolean, sweepFlag: boolean): SVGPathSegArcAbs;
13894 createSVGPathSegArcRel(x: number, y: number, r1: number, r2: number, angle: number, largeArcFlag: boolean, sweepFlag: boolean): SVGPathSegArcRel;
13896 createSVGPathSegClosePath(): SVGPathSegClosePath;
13898 createSVGPathSegCurvetoCubicAbs(x: number, y: number, x1: number, y1: number, x2: number, y2: number): SVGPathSegCurvetoCubicAbs;
13900 createSVGPathSegCurvetoCubicRel(x: number, y: number, x1: number, y1: number, x2: number, y2: number): SVGPathSegCurvetoCubicRel;
13902 createSVGPathSegCurvetoCubicSmoothAbs(x: number, y: number, x2: number, y2: number): SVGPathSegCurvetoCubicSmoothAbs;
13904 createSVGPathSegCurvetoCubicSmoothRel(x: number, y: number, x2: number, y2: number): SVGPathSegCurvetoCubicSmoothRel;
13906 createSVGPathSegCurvetoQuadraticAbs(x: number, y: number, x1: number, y1: number): SVGPathSegCurvetoQuadraticAbs;
13908 createSVGPathSegCurvetoQuadraticRel(x: number, y: number, x1: number, y1: number): SVGPathSegCurvetoQuadraticRel;
13910 createSVGPathSegCurvetoQuadraticSmoothAbs(x: number, y: number): SVGPathSegCurvetoQuadraticSmoothAbs;
13912 createSVGPathSegCurvetoQuadraticSmoothRel(x: number, y: number): SVGPathSegCurvetoQuadraticSmoothRel;
13914 createSVGPathSegLinetoAbs(x: number, y: number): SVGPathSegLinetoAbs;
13916 createSVGPathSegLinetoHorizontalAbs(x: number): SVGPathSegLinetoHorizontalAbs;
13918 createSVGPathSegLinetoHorizontalRel(x: number): SVGPathSegLinetoHorizontalRel;
13920 createSVGPathSegLinetoRel(x: number, y: number): SVGPathSegLinetoRel;
13922 createSVGPathSegLinetoVerticalAbs(y: number): SVGPathSegLinetoVerticalAbs;
13924 createSVGPathSegLinetoVerticalRel(y: number): SVGPathSegLinetoVerticalRel;
13926 createSVGPathSegMovetoAbs(x: number, y: number): SVGPathSegMovetoAbs;
13928 createSVGPathSegMovetoRel(x: number, y: number): SVGPathSegMovetoRel;
13930 getPathSegAtLength(distance: number): number;
13931 getPointAtLength(distance: number): SVGPoint;
13932 getTotalLength(): number;
13933 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGPathElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13934 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13935 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGPathElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13936 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13939 declare var SVGPathElement: {
13940 prototype: SVGPathElement;
13941 new(): SVGPathElement;
13944 interface SVGPathSeg {
13945 readonly pathSegType: number;
13946 readonly pathSegTypeAsLetter: string;
13947 readonly PATHSEG_ARC_ABS: number;
13948 readonly PATHSEG_ARC_REL: number;
13949 readonly PATHSEG_CLOSEPATH: number;
13950 readonly PATHSEG_CURVETO_CUBIC_ABS: number;
13951 readonly PATHSEG_CURVETO_CUBIC_REL: number;
13952 readonly PATHSEG_CURVETO_CUBIC_SMOOTH_ABS: number;
13953 readonly PATHSEG_CURVETO_CUBIC_SMOOTH_REL: number;
13954 readonly PATHSEG_CURVETO_QUADRATIC_ABS: number;
13955 readonly PATHSEG_CURVETO_QUADRATIC_REL: number;
13956 readonly PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS: number;
13957 readonly PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL: number;
13958 readonly PATHSEG_LINETO_ABS: number;
13959 readonly PATHSEG_LINETO_HORIZONTAL_ABS: number;
13960 readonly PATHSEG_LINETO_HORIZONTAL_REL: number;
13961 readonly PATHSEG_LINETO_REL: number;
13962 readonly PATHSEG_LINETO_VERTICAL_ABS: number;
13963 readonly PATHSEG_LINETO_VERTICAL_REL: number;
13964 readonly PATHSEG_MOVETO_ABS: number;
13965 readonly PATHSEG_MOVETO_REL: number;
13966 readonly PATHSEG_UNKNOWN: number;
13969 declare var SVGPathSeg: {
13970 prototype: SVGPathSeg;
13972 readonly PATHSEG_ARC_ABS: number;
13973 readonly PATHSEG_ARC_REL: number;
13974 readonly PATHSEG_CLOSEPATH: number;
13975 readonly PATHSEG_CURVETO_CUBIC_ABS: number;
13976 readonly PATHSEG_CURVETO_CUBIC_REL: number;
13977 readonly PATHSEG_CURVETO_CUBIC_SMOOTH_ABS: number;
13978 readonly PATHSEG_CURVETO_CUBIC_SMOOTH_REL: number;
13979 readonly PATHSEG_CURVETO_QUADRATIC_ABS: number;
13980 readonly PATHSEG_CURVETO_QUADRATIC_REL: number;
13981 readonly PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS: number;
13982 readonly PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL: number;
13983 readonly PATHSEG_LINETO_ABS: number;
13984 readonly PATHSEG_LINETO_HORIZONTAL_ABS: number;
13985 readonly PATHSEG_LINETO_HORIZONTAL_REL: number;
13986 readonly PATHSEG_LINETO_REL: number;
13987 readonly PATHSEG_LINETO_VERTICAL_ABS: number;
13988 readonly PATHSEG_LINETO_VERTICAL_REL: number;
13989 readonly PATHSEG_MOVETO_ABS: number;
13990 readonly PATHSEG_MOVETO_REL: number;
13991 readonly PATHSEG_UNKNOWN: number;
13994 interface SVGPathSegArcAbs extends SVGPathSeg {
13996 largeArcFlag: boolean;
13999 sweepFlag: boolean;
14004 declare var SVGPathSegArcAbs: {
14005 prototype: SVGPathSegArcAbs;
14006 new(): SVGPathSegArcAbs;
14009 interface SVGPathSegArcRel extends SVGPathSeg {
14011 largeArcFlag: boolean;
14014 sweepFlag: boolean;
14019 declare var SVGPathSegArcRel: {
14020 prototype: SVGPathSegArcRel;
14021 new(): SVGPathSegArcRel;
14024 interface SVGPathSegClosePath extends SVGPathSeg {
14027 declare var SVGPathSegClosePath: {
14028 prototype: SVGPathSegClosePath;
14029 new(): SVGPathSegClosePath;
14032 interface SVGPathSegCurvetoCubicAbs extends SVGPathSeg {
14041 declare var SVGPathSegCurvetoCubicAbs: {
14042 prototype: SVGPathSegCurvetoCubicAbs;
14043 new(): SVGPathSegCurvetoCubicAbs;
14046 interface SVGPathSegCurvetoCubicRel extends SVGPathSeg {
14055 declare var SVGPathSegCurvetoCubicRel: {
14056 prototype: SVGPathSegCurvetoCubicRel;
14057 new(): SVGPathSegCurvetoCubicRel;
14060 interface SVGPathSegCurvetoCubicSmoothAbs extends SVGPathSeg {
14067 declare var SVGPathSegCurvetoCubicSmoothAbs: {
14068 prototype: SVGPathSegCurvetoCubicSmoothAbs;
14069 new(): SVGPathSegCurvetoCubicSmoothAbs;
14072 interface SVGPathSegCurvetoCubicSmoothRel extends SVGPathSeg {
14079 declare var SVGPathSegCurvetoCubicSmoothRel: {
14080 prototype: SVGPathSegCurvetoCubicSmoothRel;
14081 new(): SVGPathSegCurvetoCubicSmoothRel;
14084 interface SVGPathSegCurvetoQuadraticAbs extends SVGPathSeg {
14091 declare var SVGPathSegCurvetoQuadraticAbs: {
14092 prototype: SVGPathSegCurvetoQuadraticAbs;
14093 new(): SVGPathSegCurvetoQuadraticAbs;
14096 interface SVGPathSegCurvetoQuadraticRel extends SVGPathSeg {
14103 declare var SVGPathSegCurvetoQuadraticRel: {
14104 prototype: SVGPathSegCurvetoQuadraticRel;
14105 new(): SVGPathSegCurvetoQuadraticRel;
14108 interface SVGPathSegCurvetoQuadraticSmoothAbs extends SVGPathSeg {
14113 declare var SVGPathSegCurvetoQuadraticSmoothAbs: {
14114 prototype: SVGPathSegCurvetoQuadraticSmoothAbs;
14115 new(): SVGPathSegCurvetoQuadraticSmoothAbs;
14118 interface SVGPathSegCurvetoQuadraticSmoothRel extends SVGPathSeg {
14123 declare var SVGPathSegCurvetoQuadraticSmoothRel: {
14124 prototype: SVGPathSegCurvetoQuadraticSmoothRel;
14125 new(): SVGPathSegCurvetoQuadraticSmoothRel;
14128 interface SVGPathSegLinetoAbs extends SVGPathSeg {
14133 declare var SVGPathSegLinetoAbs: {
14134 prototype: SVGPathSegLinetoAbs;
14135 new(): SVGPathSegLinetoAbs;
14138 interface SVGPathSegLinetoHorizontalAbs extends SVGPathSeg {
14142 declare var SVGPathSegLinetoHorizontalAbs: {
14143 prototype: SVGPathSegLinetoHorizontalAbs;
14144 new(): SVGPathSegLinetoHorizontalAbs;
14147 interface SVGPathSegLinetoHorizontalRel extends SVGPathSeg {
14151 declare var SVGPathSegLinetoHorizontalRel: {
14152 prototype: SVGPathSegLinetoHorizontalRel;
14153 new(): SVGPathSegLinetoHorizontalRel;
14156 interface SVGPathSegLinetoRel extends SVGPathSeg {
14161 declare var SVGPathSegLinetoRel: {
14162 prototype: SVGPathSegLinetoRel;
14163 new(): SVGPathSegLinetoRel;
14166 interface SVGPathSegLinetoVerticalAbs extends SVGPathSeg {
14170 declare var SVGPathSegLinetoVerticalAbs: {
14171 prototype: SVGPathSegLinetoVerticalAbs;
14172 new(): SVGPathSegLinetoVerticalAbs;
14175 interface SVGPathSegLinetoVerticalRel extends SVGPathSeg {
14179 declare var SVGPathSegLinetoVerticalRel: {
14180 prototype: SVGPathSegLinetoVerticalRel;
14181 new(): SVGPathSegLinetoVerticalRel;
14184 interface SVGPathSegList {
14185 readonly numberOfItems: number;
14186 appendItem(newItem: SVGPathSeg): SVGPathSeg;
14188 getItem(index: number): SVGPathSeg;
14189 initialize(newItem: SVGPathSeg): SVGPathSeg;
14190 insertItemBefore(newItem: SVGPathSeg, index: number): SVGPathSeg;
14191 removeItem(index: number): SVGPathSeg;
14192 replaceItem(newItem: SVGPathSeg, index: number): SVGPathSeg;
14195 declare var SVGPathSegList: {
14196 prototype: SVGPathSegList;
14197 new(): SVGPathSegList;
14200 interface SVGPathSegMovetoAbs extends SVGPathSeg {
14205 declare var SVGPathSegMovetoAbs: {
14206 prototype: SVGPathSegMovetoAbs;
14207 new(): SVGPathSegMovetoAbs;
14210 interface SVGPathSegMovetoRel extends SVGPathSeg {
14215 declare var SVGPathSegMovetoRel: {
14216 prototype: SVGPathSegMovetoRel;
14217 new(): SVGPathSegMovetoRel;
14220 /** Corresponds to the <pattern> element. */
14221 interface SVGPatternElement extends SVGElement, SVGFitToViewBox, SVGURIReference {
14222 readonly height: SVGAnimatedLength;
14223 readonly patternContentUnits: SVGAnimatedEnumeration;
14224 readonly patternTransform: SVGAnimatedTransformList;
14225 readonly patternUnits: SVGAnimatedEnumeration;
14226 readonly width: SVGAnimatedLength;
14227 readonly x: SVGAnimatedLength;
14228 readonly y: SVGAnimatedLength;
14229 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGPatternElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14230 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14231 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGPatternElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14232 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14235 declare var SVGPatternElement: {
14236 prototype: SVGPatternElement;
14237 new(): SVGPatternElement;
14240 interface SVGPointList {
14241 readonly length: number;
14242 readonly numberOfItems: number;
14243 appendItem(newItem: DOMPoint): DOMPoint;
14245 getItem(index: number): DOMPoint;
14246 initialize(newItem: DOMPoint): DOMPoint;
14247 insertItemBefore(newItem: DOMPoint, index: number): DOMPoint;
14248 removeItem(index: number): DOMPoint;
14249 replaceItem(newItem: DOMPoint, index: number): DOMPoint;
14250 [index: number]: DOMPoint;
14253 declare var SVGPointList: {
14254 prototype: SVGPointList;
14255 new(): SVGPointList;
14258 /** Provides access to the properties of <polygon> elements, as well as methods to manipulate them. */
14259 interface SVGPolygonElement extends SVGGeometryElement, SVGAnimatedPoints {
14260 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGPolygonElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14261 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14262 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGPolygonElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14263 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14266 declare var SVGPolygonElement: {
14267 prototype: SVGPolygonElement;
14268 new(): SVGPolygonElement;
14271 /** Provides access to the properties of <polyline> elements, as well as methods to manipulate them. */
14272 interface SVGPolylineElement extends SVGGeometryElement, SVGAnimatedPoints {
14273 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGPolylineElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14274 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14275 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGPolylineElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14276 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14279 declare var SVGPolylineElement: {
14280 prototype: SVGPolylineElement;
14281 new(): SVGPolylineElement;
14284 /** Corresponds to the preserveAspectRatio attribute, which is available for some of SVG's elements. */
14285 interface SVGPreserveAspectRatio {
14287 meetOrSlice: number;
14288 readonly SVG_MEETORSLICE_MEET: number;
14289 readonly SVG_MEETORSLICE_SLICE: number;
14290 readonly SVG_MEETORSLICE_UNKNOWN: number;
14291 readonly SVG_PRESERVEASPECTRATIO_NONE: number;
14292 readonly SVG_PRESERVEASPECTRATIO_UNKNOWN: number;
14293 readonly SVG_PRESERVEASPECTRATIO_XMAXYMAX: number;
14294 readonly SVG_PRESERVEASPECTRATIO_XMAXYMID: number;
14295 readonly SVG_PRESERVEASPECTRATIO_XMAXYMIN: number;
14296 readonly SVG_PRESERVEASPECTRATIO_XMIDYMAX: number;
14297 readonly SVG_PRESERVEASPECTRATIO_XMIDYMID: number;
14298 readonly SVG_PRESERVEASPECTRATIO_XMIDYMIN: number;
14299 readonly SVG_PRESERVEASPECTRATIO_XMINYMAX: number;
14300 readonly SVG_PRESERVEASPECTRATIO_XMINYMID: number;
14301 readonly SVG_PRESERVEASPECTRATIO_XMINYMIN: number;
14304 declare var SVGPreserveAspectRatio: {
14305 prototype: SVGPreserveAspectRatio;
14306 new(): SVGPreserveAspectRatio;
14307 readonly SVG_MEETORSLICE_MEET: number;
14308 readonly SVG_MEETORSLICE_SLICE: number;
14309 readonly SVG_MEETORSLICE_UNKNOWN: number;
14310 readonly SVG_PRESERVEASPECTRATIO_NONE: number;
14311 readonly SVG_PRESERVEASPECTRATIO_UNKNOWN: number;
14312 readonly SVG_PRESERVEASPECTRATIO_XMAXYMAX: number;
14313 readonly SVG_PRESERVEASPECTRATIO_XMAXYMID: number;
14314 readonly SVG_PRESERVEASPECTRATIO_XMAXYMIN: number;
14315 readonly SVG_PRESERVEASPECTRATIO_XMIDYMAX: number;
14316 readonly SVG_PRESERVEASPECTRATIO_XMIDYMID: number;
14317 readonly SVG_PRESERVEASPECTRATIO_XMIDYMIN: number;
14318 readonly SVG_PRESERVEASPECTRATIO_XMINYMAX: number;
14319 readonly SVG_PRESERVEASPECTRATIO_XMINYMID: number;
14320 readonly SVG_PRESERVEASPECTRATIO_XMINYMIN: number;
14323 /** Corresponds to the <RadialGradient> element. */
14324 interface SVGRadialGradientElement extends SVGGradientElement {
14325 readonly cx: SVGAnimatedLength;
14326 readonly cy: SVGAnimatedLength;
14327 readonly fr: SVGAnimatedLength;
14328 readonly fx: SVGAnimatedLength;
14329 readonly fy: SVGAnimatedLength;
14330 readonly r: SVGAnimatedLength;
14331 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGRadialGradientElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14332 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14333 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGRadialGradientElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14334 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14337 declare var SVGRadialGradientElement: {
14338 prototype: SVGRadialGradientElement;
14339 new(): SVGRadialGradientElement;
14342 /** Provides access to the properties of <rect> elements, as well as methods to manipulate them. */
14343 interface SVGRectElement extends SVGGeometryElement {
14344 readonly height: SVGAnimatedLength;
14345 readonly rx: SVGAnimatedLength;
14346 readonly ry: SVGAnimatedLength;
14347 readonly width: SVGAnimatedLength;
14348 readonly x: SVGAnimatedLength;
14349 readonly y: SVGAnimatedLength;
14350 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGRectElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14351 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14352 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGRectElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14353 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14356 declare var SVGRectElement: {
14357 prototype: SVGRectElement;
14358 new(): SVGRectElement;
14361 interface SVGSVGElementEventMap extends SVGElementEventMap {
14362 "SVGUnload": Event;
14363 "SVGZoom": SVGZoomEvent;
14366 /** 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. */
14367 interface SVGSVGElement extends SVGGraphicsElement, DocumentEvent, SVGFitToViewBox, SVGZoomAndPan {
14369 contentScriptType: string;
14371 contentStyleType: string;
14372 currentScale: number;
14373 readonly currentTranslate: SVGPoint;
14374 readonly height: SVGAnimatedLength;
14375 onunload: ((this: SVGSVGElement, ev: Event) => any) | null;
14376 onzoom: ((this: SVGSVGElement, ev: SVGZoomEvent) => any) | null;
14378 readonly pixelUnitToMillimeterX: number;
14380 readonly pixelUnitToMillimeterY: number;
14382 readonly screenPixelToMillimeterX: number;
14384 readonly screenPixelToMillimeterY: number;
14386 readonly viewport: SVGRect;
14387 readonly width: SVGAnimatedLength;
14388 readonly x: SVGAnimatedLength;
14389 readonly y: SVGAnimatedLength;
14390 animationsPaused(): boolean;
14391 checkEnclosure(element: SVGElement, rect: SVGRect): boolean;
14392 checkIntersection(element: SVGElement, rect: SVGRect): boolean;
14393 createSVGAngle(): SVGAngle;
14394 createSVGLength(): SVGLength;
14395 createSVGMatrix(): SVGMatrix;
14396 createSVGNumber(): SVGNumber;
14397 createSVGPoint(): SVGPoint;
14398 createSVGRect(): SVGRect;
14399 createSVGTransform(): SVGTransform;
14400 createSVGTransformFromMatrix(matrix: SVGMatrix): SVGTransform;
14401 deselectAll(): void;
14403 forceRedraw(): void;
14404 getComputedStyle(elt: Element, pseudoElt?: string | null): CSSStyleDeclaration;
14405 getCurrentTime(): number;
14406 getElementById(elementId: string): Element;
14407 getEnclosureList(rect: SVGRect, referenceElement: SVGElement | null): NodeListOf<SVGCircleElement | SVGEllipseElement | SVGImageElement | SVGLineElement | SVGPathElement | SVGPolygonElement | SVGPolylineElement | SVGRectElement | SVGTextElement | SVGUseElement>;
14408 getIntersectionList(rect: SVGRect, referenceElement: SVGElement | null): NodeListOf<SVGCircleElement | SVGEllipseElement | SVGImageElement | SVGLineElement | SVGPathElement | SVGPolygonElement | SVGPolylineElement | SVGRectElement | SVGTextElement | SVGUseElement>;
14409 pauseAnimations(): void;
14410 setCurrentTime(seconds: number): void;
14412 suspendRedraw(maxWaitMilliseconds: number): number;
14413 unpauseAnimations(): void;
14415 unsuspendRedraw(suspendHandleID: number): void;
14417 unsuspendRedrawAll(): void;
14418 addEventListener<K extends keyof SVGSVGElementEventMap>(type: K, listener: (this: SVGSVGElement, ev: SVGSVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14419 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14420 removeEventListener<K extends keyof SVGSVGElementEventMap>(type: K, listener: (this: SVGSVGElement, ev: SVGSVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14421 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14424 declare var SVGSVGElement: {
14425 prototype: SVGSVGElement;
14426 new(): SVGSVGElement;
14427 readonly SVG_ZOOMANDPAN_DISABLE: number;
14428 readonly SVG_ZOOMANDPAN_MAGNIFY: number;
14429 readonly SVG_ZOOMANDPAN_UNKNOWN: number;
14432 /** Corresponds to the SVG <script> element. */
14433 interface SVGScriptElement extends SVGElement, SVGURIReference {
14435 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGScriptElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14436 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14437 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGScriptElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14438 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14441 declare var SVGScriptElement: {
14442 prototype: SVGScriptElement;
14443 new(): SVGScriptElement;
14446 /** Corresponds to the <stop> element. */
14447 interface SVGStopElement extends SVGElement {
14448 readonly offset: SVGAnimatedNumber;
14449 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGStopElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14450 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14451 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGStopElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14452 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14455 declare var SVGStopElement: {
14456 prototype: SVGStopElement;
14457 new(): SVGStopElement;
14460 /** The SVGStringList defines a list of DOMString objects. */
14461 interface SVGStringList {
14462 readonly length: number;
14463 readonly numberOfItems: number;
14464 appendItem(newItem: string): string;
14466 getItem(index: number): string;
14467 initialize(newItem: string): string;
14468 insertItemBefore(newItem: string, index: number): string;
14469 removeItem(index: number): string;
14470 replaceItem(newItem: string, index: number): string;
14471 [index: number]: string;
14474 declare var SVGStringList: {
14475 prototype: SVGStringList;
14476 new(): SVGStringList;
14479 /** Corresponds to the SVG <style> element. */
14480 interface SVGStyleElement extends SVGElement {
14485 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGStyleElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14486 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14487 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGStyleElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14488 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14491 declare var SVGStyleElement: {
14492 prototype: SVGStyleElement;
14493 new(): SVGStyleElement;
14496 /** Corresponds to the <switch> element. */
14497 interface SVGSwitchElement extends SVGGraphicsElement {
14498 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGSwitchElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14499 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14500 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGSwitchElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14501 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14504 declare var SVGSwitchElement: {
14505 prototype: SVGSwitchElement;
14506 new(): SVGSwitchElement;
14509 /** Corresponds to the <symbol> element. */
14510 interface SVGSymbolElement extends SVGElement, SVGFitToViewBox {
14511 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGSymbolElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14512 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14513 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGSymbolElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14514 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14517 declare var SVGSymbolElement: {
14518 prototype: SVGSymbolElement;
14519 new(): SVGSymbolElement;
14522 /** A <tspan> element. */
14523 interface SVGTSpanElement extends SVGTextPositioningElement {
14524 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTSpanElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14525 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14526 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTSpanElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14527 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14530 declare var SVGTSpanElement: {
14531 prototype: SVGTSpanElement;
14532 new(): SVGTSpanElement;
14535 interface SVGTests {
14536 readonly requiredExtensions: SVGStringList;
14537 readonly systemLanguage: SVGStringList;
14540 /** 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. */
14541 interface SVGTextContentElement extends SVGGraphicsElement {
14542 readonly lengthAdjust: SVGAnimatedEnumeration;
14543 readonly textLength: SVGAnimatedLength;
14544 getCharNumAtPosition(point?: DOMPointInit): number;
14545 getComputedTextLength(): number;
14546 getEndPositionOfChar(charnum: number): DOMPoint;
14547 getExtentOfChar(charnum: number): DOMRect;
14548 getNumberOfChars(): number;
14549 getRotationOfChar(charnum: number): number;
14550 getStartPositionOfChar(charnum: number): DOMPoint;
14551 getSubStringLength(charnum: number, nchars: number): number;
14552 selectSubString(charnum: number, nchars: number): void;
14553 readonly LENGTHADJUST_SPACING: number;
14554 readonly LENGTHADJUST_SPACINGANDGLYPHS: number;
14555 readonly LENGTHADJUST_UNKNOWN: number;
14556 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTextContentElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14557 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14558 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTextContentElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14559 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14562 declare var SVGTextContentElement: {
14563 prototype: SVGTextContentElement;
14564 new(): SVGTextContentElement;
14565 readonly LENGTHADJUST_SPACING: number;
14566 readonly LENGTHADJUST_SPACINGANDGLYPHS: number;
14567 readonly LENGTHADJUST_UNKNOWN: number;
14570 /** Corresponds to the <text> elements. */
14571 interface SVGTextElement extends SVGTextPositioningElement {
14572 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTextElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14573 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14574 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTextElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14575 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14578 declare var SVGTextElement: {
14579 prototype: SVGTextElement;
14580 new(): SVGTextElement;
14583 /** Corresponds to the <textPath> element. */
14584 interface SVGTextPathElement extends SVGTextContentElement, SVGURIReference {
14585 readonly method: SVGAnimatedEnumeration;
14586 readonly spacing: SVGAnimatedEnumeration;
14587 readonly startOffset: SVGAnimatedLength;
14588 readonly TEXTPATH_METHODTYPE_ALIGN: number;
14589 readonly TEXTPATH_METHODTYPE_STRETCH: number;
14590 readonly TEXTPATH_METHODTYPE_UNKNOWN: number;
14591 readonly TEXTPATH_SPACINGTYPE_AUTO: number;
14592 readonly TEXTPATH_SPACINGTYPE_EXACT: number;
14593 readonly TEXTPATH_SPACINGTYPE_UNKNOWN: number;
14594 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTextPathElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14595 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14596 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTextPathElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14597 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14600 declare var SVGTextPathElement: {
14601 prototype: SVGTextPathElement;
14602 new(): SVGTextPathElement;
14603 readonly TEXTPATH_METHODTYPE_ALIGN: number;
14604 readonly TEXTPATH_METHODTYPE_STRETCH: number;
14605 readonly TEXTPATH_METHODTYPE_UNKNOWN: number;
14606 readonly TEXTPATH_SPACINGTYPE_AUTO: number;
14607 readonly TEXTPATH_SPACINGTYPE_EXACT: number;
14608 readonly TEXTPATH_SPACINGTYPE_UNKNOWN: number;
14611 /** Implemented by elements that support attributes that position individual text glyphs. It is inherited by SVGTextElement, SVGTSpanElement, SVGTRefElement and SVGAltGlyphElement. */
14612 interface SVGTextPositioningElement extends SVGTextContentElement {
14613 readonly dx: SVGAnimatedLengthList;
14614 readonly dy: SVGAnimatedLengthList;
14615 readonly rotate: SVGAnimatedNumberList;
14616 readonly x: SVGAnimatedLengthList;
14617 readonly y: SVGAnimatedLengthList;
14618 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTextPositioningElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14619 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14620 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTextPositioningElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14621 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14624 declare var SVGTextPositioningElement: {
14625 prototype: SVGTextPositioningElement;
14626 new(): SVGTextPositioningElement;
14629 /** Corresponds to the <title> element. */
14630 interface SVGTitleElement extends SVGElement {
14631 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTitleElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14632 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14633 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTitleElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14634 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14637 declare var SVGTitleElement: {
14638 prototype: SVGTitleElement;
14639 new(): SVGTitleElement;
14642 /** 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. */
14643 interface SVGTransform {
14644 readonly angle: number;
14645 readonly matrix: SVGMatrix;
14646 readonly type: number;
14647 setMatrix(matrix: SVGMatrix): void;
14648 setRotate(angle: number, cx: number, cy: number): void;
14649 setScale(sx: number, sy: number): void;
14650 setSkewX(angle: number): void;
14651 setSkewY(angle: number): void;
14652 setTranslate(tx: number, ty: number): void;
14653 readonly SVG_TRANSFORM_MATRIX: number;
14654 readonly SVG_TRANSFORM_ROTATE: number;
14655 readonly SVG_TRANSFORM_SCALE: number;
14656 readonly SVG_TRANSFORM_SKEWX: number;
14657 readonly SVG_TRANSFORM_SKEWY: number;
14658 readonly SVG_TRANSFORM_TRANSLATE: number;
14659 readonly SVG_TRANSFORM_UNKNOWN: number;
14662 declare var SVGTransform: {
14663 prototype: SVGTransform;
14664 new(): SVGTransform;
14665 readonly SVG_TRANSFORM_MATRIX: number;
14666 readonly SVG_TRANSFORM_ROTATE: number;
14667 readonly SVG_TRANSFORM_SCALE: number;
14668 readonly SVG_TRANSFORM_SKEWX: number;
14669 readonly SVG_TRANSFORM_SKEWY: number;
14670 readonly SVG_TRANSFORM_TRANSLATE: number;
14671 readonly SVG_TRANSFORM_UNKNOWN: number;
14674 /** The SVGTransformList defines a list of SVGTransform objects. */
14675 interface SVGTransformList {
14676 readonly numberOfItems: number;
14677 appendItem(newItem: SVGTransform): SVGTransform;
14679 consolidate(): SVGTransform;
14680 createSVGTransformFromMatrix(matrix: SVGMatrix): SVGTransform;
14681 getItem(index: number): SVGTransform;
14682 initialize(newItem: SVGTransform): SVGTransform;
14683 insertItemBefore(newItem: SVGTransform, index: number): SVGTransform;
14684 removeItem(index: number): SVGTransform;
14685 replaceItem(newItem: SVGTransform, index: number): SVGTransform;
14688 declare var SVGTransformList: {
14689 prototype: SVGTransformList;
14690 new(): SVGTransformList;
14693 interface SVGURIReference {
14694 readonly href: SVGAnimatedString;
14697 /** A commonly used set of constants used for reflecting gradientUnits, patternContentUnits and other similar attributes. */
14698 interface SVGUnitTypes {
14699 readonly SVG_UNIT_TYPE_OBJECTBOUNDINGBOX: number;
14700 readonly SVG_UNIT_TYPE_UNKNOWN: number;
14701 readonly SVG_UNIT_TYPE_USERSPACEONUSE: number;
14704 declare var SVGUnitTypes: {
14705 prototype: SVGUnitTypes;
14706 new(): SVGUnitTypes;
14707 readonly SVG_UNIT_TYPE_OBJECTBOUNDINGBOX: number;
14708 readonly SVG_UNIT_TYPE_UNKNOWN: number;
14709 readonly SVG_UNIT_TYPE_USERSPACEONUSE: number;
14712 /** Corresponds to the <use> element. */
14713 interface SVGUseElement extends SVGGraphicsElement, SVGURIReference {
14714 readonly animatedInstanceRoot: SVGElementInstance | null;
14715 readonly height: SVGAnimatedLength;
14716 readonly instanceRoot: SVGElementInstance | null;
14717 readonly width: SVGAnimatedLength;
14718 readonly x: SVGAnimatedLength;
14719 readonly y: SVGAnimatedLength;
14720 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGUseElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14721 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14722 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGUseElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14723 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14726 declare var SVGUseElement: {
14727 prototype: SVGUseElement;
14728 new(): SVGUseElement;
14731 /** Provides access to the properties of <view> elements, as well as methods to manipulate them. */
14732 interface SVGViewElement extends SVGElement, SVGFitToViewBox, SVGZoomAndPan {
14734 readonly viewTarget: SVGStringList;
14735 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGViewElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14736 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14737 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGViewElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14738 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14741 declare var SVGViewElement: {
14742 prototype: SVGViewElement;
14743 new(): SVGViewElement;
14744 readonly SVG_ZOOMANDPAN_DISABLE: number;
14745 readonly SVG_ZOOMANDPAN_MAGNIFY: number;
14746 readonly SVG_ZOOMANDPAN_UNKNOWN: number;
14749 /** Used to reflect the zoomAndPan attribute, and is mixed in to other interfaces for elements that support this attribute. */
14750 interface SVGZoomAndPan {
14751 readonly zoomAndPan: number;
14754 declare var SVGZoomAndPan: {
14755 readonly SVG_ZOOMANDPAN_DISABLE: number;
14756 readonly SVG_ZOOMANDPAN_MAGNIFY: number;
14757 readonly SVG_ZOOMANDPAN_UNKNOWN: number;
14760 interface SVGZoomEvent extends UIEvent {
14761 readonly newScale: number;
14762 readonly newTranslate: SVGPoint;
14763 readonly previousScale: number;
14764 readonly previousTranslate: SVGPoint;
14765 readonly zoomRectScreen: SVGRect;
14768 declare var SVGZoomEvent: {
14769 prototype: SVGZoomEvent;
14770 new(): SVGZoomEvent;
14773 interface ScopedCredential {
14774 readonly id: ArrayBuffer;
14775 readonly type: ScopedCredentialType;
14778 declare var ScopedCredential: {
14779 prototype: ScopedCredential;
14780 new(): ScopedCredential;
14783 interface ScopedCredentialInfo {
14784 readonly credential: ScopedCredential;
14785 readonly publicKey: CryptoKey;
14788 declare var ScopedCredentialInfo: {
14789 prototype: ScopedCredentialInfo;
14790 new(): ScopedCredentialInfo;
14793 /** A screen, usually the one on which the current window is being rendered, and is obtained using window.screen. */
14795 readonly availHeight: number;
14796 readonly availWidth: number;
14797 readonly colorDepth: number;
14798 readonly height: number;
14799 readonly orientation: ScreenOrientation;
14800 readonly pixelDepth: number;
14801 readonly width: number;
14804 declare var Screen: {
14809 interface ScreenOrientationEventMap {
14813 interface ScreenOrientation extends EventTarget {
14814 readonly angle: number;
14815 onchange: ((this: ScreenOrientation, ev: Event) => any) | null;
14816 readonly type: OrientationType;
14817 lock(orientation: OrientationLockType): Promise<void>;
14819 addEventListener<K extends keyof ScreenOrientationEventMap>(type: K, listener: (this: ScreenOrientation, ev: ScreenOrientationEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14820 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14821 removeEventListener<K extends keyof ScreenOrientationEventMap>(type: K, listener: (this: ScreenOrientation, ev: ScreenOrientationEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14822 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14825 declare var ScreenOrientation: {
14826 prototype: ScreenOrientation;
14827 new(): ScreenOrientation;
14830 interface ScriptProcessorNodeEventMap {
14831 "audioprocess": AudioProcessingEvent;
14834 /** Allows the generation, processing, or analyzing of audio using JavaScript. */
14835 interface ScriptProcessorNode extends AudioNode {
14837 readonly bufferSize: number;
14839 onaudioprocess: ((this: ScriptProcessorNode, ev: AudioProcessingEvent) => any) | null;
14840 addEventListener<K extends keyof ScriptProcessorNodeEventMap>(type: K, listener: (this: ScriptProcessorNode, ev: ScriptProcessorNodeEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14841 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14842 removeEventListener<K extends keyof ScriptProcessorNodeEventMap>(type: K, listener: (this: ScriptProcessorNode, ev: ScriptProcessorNodeEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14843 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14846 declare var ScriptProcessorNode: {
14847 prototype: ScriptProcessorNode;
14848 new(): ScriptProcessorNode;
14851 /** Inherits from Event, and represents the event object of an event sent on a document or worker when its content security policy is violated. */
14852 interface SecurityPolicyViolationEvent extends Event {
14853 readonly blockedURI: string;
14854 readonly columnNumber: number;
14855 readonly documentURI: string;
14856 readonly effectiveDirective: string;
14857 readonly lineNumber: number;
14858 readonly originalPolicy: string;
14859 readonly referrer: string;
14860 readonly sourceFile: string;
14861 readonly statusCode: number;
14862 readonly violatedDirective: string;
14865 declare var SecurityPolicyViolationEvent: {
14866 prototype: SecurityPolicyViolationEvent;
14867 new(type: string, eventInitDict?: SecurityPolicyViolationEventInit): SecurityPolicyViolationEvent;
14870 /** 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(). */
14871 interface Selection {
14872 readonly anchorNode: Node | null;
14873 readonly anchorOffset: number;
14874 readonly focusNode: Node | null;
14875 readonly focusOffset: number;
14876 readonly isCollapsed: boolean;
14877 readonly rangeCount: number;
14878 readonly type: string;
14879 addRange(range: Range): void;
14880 collapse(node: Node | null, offset?: number): void;
14881 collapseToEnd(): void;
14882 collapseToStart(): void;
14883 containsNode(node: Node, allowPartialContainment?: boolean): boolean;
14884 deleteFromDocument(): void;
14886 extend(node: Node, offset?: number): void;
14887 getRangeAt(index: number): Range;
14888 removeAllRanges(): void;
14889 removeRange(range: Range): void;
14890 selectAllChildren(node: Node): void;
14891 setBaseAndExtent(anchorNode: Node, anchorOffset: number, focusNode: Node, focusOffset: number): void;
14892 setPosition(node: Node | null, offset?: number): void;
14893 toString(): string;
14896 declare var Selection: {
14897 prototype: Selection;
14899 toString(): string;
14902 interface ServiceUIFrameContext {
14903 getCachedFrameMessage(key: string): string;
14904 postFrameMessage(key: string, data: string): void;
14906 declare var ServiceUIFrameContext: ServiceUIFrameContext;
14908 interface ServiceWorkerEventMap extends AbstractWorkerEventMap {
14909 "statechange": Event;
14912 /** 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. */
14913 interface ServiceWorker extends EventTarget, AbstractWorker {
14914 onstatechange: ((this: ServiceWorker, ev: Event) => any) | null;
14915 readonly scriptURL: string;
14916 readonly state: ServiceWorkerState;
14917 postMessage(message: any, transfer: Transferable[]): void;
14918 postMessage(message: any, options?: PostMessageOptions): void;
14919 addEventListener<K extends keyof ServiceWorkerEventMap>(type: K, listener: (this: ServiceWorker, ev: ServiceWorkerEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14920 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14921 removeEventListener<K extends keyof ServiceWorkerEventMap>(type: K, listener: (this: ServiceWorker, ev: ServiceWorkerEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14922 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14925 declare var ServiceWorker: {
14926 prototype: ServiceWorker;
14927 new(): ServiceWorker;
14930 interface ServiceWorkerContainerEventMap {
14931 "controllerchange": Event;
14932 "message": MessageEvent;
14933 "messageerror": MessageEvent;
14936 /** 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. */
14937 interface ServiceWorkerContainer extends EventTarget {
14938 readonly controller: ServiceWorker | null;
14939 oncontrollerchange: ((this: ServiceWorkerContainer, ev: Event) => any) | null;
14940 onmessage: ((this: ServiceWorkerContainer, ev: MessageEvent) => any) | null;
14941 onmessageerror: ((this: ServiceWorkerContainer, ev: MessageEvent) => any) | null;
14942 readonly ready: Promise<ServiceWorkerRegistration>;
14943 getRegistration(clientURL?: string): Promise<ServiceWorkerRegistration | undefined>;
14944 getRegistrations(): Promise<ReadonlyArray<ServiceWorkerRegistration>>;
14945 register(scriptURL: string, options?: RegistrationOptions): Promise<ServiceWorkerRegistration>;
14946 startMessages(): void;
14947 addEventListener<K extends keyof ServiceWorkerContainerEventMap>(type: K, listener: (this: ServiceWorkerContainer, ev: ServiceWorkerContainerEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14948 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14949 removeEventListener<K extends keyof ServiceWorkerContainerEventMap>(type: K, listener: (this: ServiceWorkerContainer, ev: ServiceWorkerContainerEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14950 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14953 declare var ServiceWorkerContainer: {
14954 prototype: ServiceWorkerContainer;
14955 new(): ServiceWorkerContainer;
14958 /** 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. */
14959 interface ServiceWorkerMessageEvent extends Event {
14960 readonly data: any;
14961 readonly lastEventId: string;
14962 readonly origin: string;
14963 readonly ports: ReadonlyArray<MessagePort> | null;
14964 readonly source: ServiceWorker | MessagePort | null;
14967 declare var ServiceWorkerMessageEvent: {
14968 prototype: ServiceWorkerMessageEvent;
14969 new(type: string, eventInitDict?: ServiceWorkerMessageEventInit): ServiceWorkerMessageEvent;
14972 interface ServiceWorkerRegistrationEventMap {
14973 "updatefound": Event;
14976 /** 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. */
14977 interface ServiceWorkerRegistration extends EventTarget {
14978 readonly active: ServiceWorker | null;
14979 readonly installing: ServiceWorker | null;
14980 readonly navigationPreload: NavigationPreloadManager;
14981 onupdatefound: ((this: ServiceWorkerRegistration, ev: Event) => any) | null;
14982 readonly pushManager: PushManager;
14983 readonly scope: string;
14984 readonly sync: SyncManager;
14985 readonly updateViaCache: ServiceWorkerUpdateViaCache;
14986 readonly waiting: ServiceWorker | null;
14987 getNotifications(filter?: GetNotificationOptions): Promise<Notification[]>;
14988 showNotification(title: string, options?: NotificationOptions): Promise<void>;
14989 unregister(): Promise<boolean>;
14990 update(): Promise<void>;
14991 addEventListener<K extends keyof ServiceWorkerRegistrationEventMap>(type: K, listener: (this: ServiceWorkerRegistration, ev: ServiceWorkerRegistrationEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14992 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14993 removeEventListener<K extends keyof ServiceWorkerRegistrationEventMap>(type: K, listener: (this: ServiceWorkerRegistration, ev: ServiceWorkerRegistrationEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14994 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14997 declare var ServiceWorkerRegistration: {
14998 prototype: ServiceWorkerRegistration;
14999 new(): ServiceWorkerRegistration;
15002 interface ShadowRoot extends DocumentFragment, DocumentOrShadowRoot, InnerHTML {
15003 readonly host: Element;
15004 readonly mode: ShadowRootMode;
15006 * Throws a "NotSupportedError" DOMException if context object is a shadow root.
15010 declare var ShadowRoot: {
15011 prototype: ShadowRoot;
15015 interface SharedWorker extends EventTarget, AbstractWorker {
15017 * Returns sharedWorker's MessagePort object which can be used to communicate with the global environment.
15019 readonly port: MessagePort;
15020 addEventListener<K extends keyof AbstractWorkerEventMap>(type: K, listener: (this: SharedWorker, ev: AbstractWorkerEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
15021 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
15022 removeEventListener<K extends keyof AbstractWorkerEventMap>(type: K, listener: (this: SharedWorker, ev: AbstractWorkerEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
15023 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
15026 declare var SharedWorker: {
15027 prototype: SharedWorker;
15028 new(scriptURL: string, options?: string | WorkerOptions): SharedWorker;
15031 interface Slottable {
15032 readonly assignedSlot: HTMLSlotElement | null;
15035 interface SourceBufferEventMap {
15039 "updateend": Event;
15040 "updatestart": Event;
15043 /** 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. */
15044 interface SourceBuffer extends EventTarget {
15045 appendWindowEnd: number;
15046 appendWindowStart: number;
15047 readonly buffered: TimeRanges;
15049 onabort: ((this: SourceBuffer, ev: Event) => any) | null;
15050 onerror: ((this: SourceBuffer, ev: Event) => any) | null;
15051 onupdate: ((this: SourceBuffer, ev: Event) => any) | null;
15052 onupdateend: ((this: SourceBuffer, ev: Event) => any) | null;
15053 onupdatestart: ((this: SourceBuffer, ev: Event) => any) | null;
15054 timestampOffset: number;
15055 readonly updating: boolean;
15057 appendBuffer(data: BufferSource): void;
15058 remove(start: number, end: number): void;
15059 addEventListener<K extends keyof SourceBufferEventMap>(type: K, listener: (this: SourceBuffer, ev: SourceBufferEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
15060 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
15061 removeEventListener<K extends keyof SourceBufferEventMap>(type: K, listener: (this: SourceBuffer, ev: SourceBufferEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
15062 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
15065 declare var SourceBuffer: {
15066 prototype: SourceBuffer;
15067 new(): SourceBuffer;
15070 interface SourceBufferListEventMap {
15071 "addsourcebuffer": Event;
15072 "removesourcebuffer": Event;
15075 /** A simple container list for multiple SourceBuffer objects. */
15076 interface SourceBufferList extends EventTarget {
15077 readonly length: number;
15078 onaddsourcebuffer: ((this: SourceBufferList, ev: Event) => any) | null;
15079 onremovesourcebuffer: ((this: SourceBufferList, ev: Event) => any) | null;
15080 addEventListener<K extends keyof SourceBufferListEventMap>(type: K, listener: (this: SourceBufferList, ev: SourceBufferListEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
15081 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
15082 removeEventListener<K extends keyof SourceBufferListEventMap>(type: K, listener: (this: SourceBufferList, ev: SourceBufferListEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
15083 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
15084 [index: number]: SourceBuffer;
15087 declare var SourceBufferList: {
15088 prototype: SourceBufferList;
15089 new(): SourceBufferList;
15092 interface SpeechGrammar {
15097 declare var SpeechGrammar: {
15098 prototype: SpeechGrammar;
15099 new(): SpeechGrammar;
15102 interface SpeechGrammarList {
15103 readonly length: number;
15104 addFromString(string: string, weight?: number): void;
15105 addFromURI(src: string, weight?: number): void;
15106 item(index: number): SpeechGrammar;
15107 [index: number]: SpeechGrammar;
15110 declare var SpeechGrammarList: {
15111 prototype: SpeechGrammarList;
15112 new(): SpeechGrammarList;
15115 interface SpeechRecognitionEventMap {
15117 "audiostart": Event;
15119 "error": ErrorEvent;
15120 "nomatch": SpeechRecognitionEvent;
15121 "result": SpeechRecognitionEvent;
15123 "soundstart": Event;
15124 "speechend": Event;
15125 "speechstart": Event;
15129 interface SpeechRecognition extends EventTarget {
15130 continuous: boolean;
15131 grammars: SpeechGrammarList;
15132 interimResults: boolean;
15134 maxAlternatives: number;
15135 onaudioend: ((this: SpeechRecognition, ev: Event) => any) | null;
15136 onaudiostart: ((this: SpeechRecognition, ev: Event) => any) | null;
15137 onend: ((this: SpeechRecognition, ev: Event) => any) | null;
15138 onerror: ((this: SpeechRecognition, ev: ErrorEvent) => any) | null;
15139 onnomatch: ((this: SpeechRecognition, ev: SpeechRecognitionEvent) => any) | null;
15140 onresult: ((this: SpeechRecognition, ev: SpeechRecognitionEvent) => any) | null;
15141 onsoundend: ((this: SpeechRecognition, ev: Event) => any) | null;
15142 onsoundstart: ((this: SpeechRecognition, ev: Event) => any) | null;
15143 onspeechend: ((this: SpeechRecognition, ev: Event) => any) | null;
15144 onspeechstart: ((this: SpeechRecognition, ev: Event) => any) | null;
15145 onstart: ((this: SpeechRecognition, ev: Event) => any) | null;
15149 addEventListener<K extends keyof SpeechRecognitionEventMap>(type: K, listener: (this: SpeechRecognition, ev: SpeechRecognitionEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
15150 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
15151 removeEventListener<K extends keyof SpeechRecognitionEventMap>(type: K, listener: (this: SpeechRecognition, ev: SpeechRecognitionEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
15152 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
15155 declare var SpeechRecognition: {
15156 prototype: SpeechRecognition;
15157 new(): SpeechRecognition;
15160 interface SpeechRecognitionAlternative {
15161 readonly confidence: number;
15162 readonly transcript: string;
15165 declare var SpeechRecognitionAlternative: {
15166 prototype: SpeechRecognitionAlternative;
15167 new(): SpeechRecognitionAlternative;
15170 interface SpeechRecognitionEvent extends Event {
15171 readonly resultIndex: number;
15172 readonly results: SpeechRecognitionResultList;
15175 declare var SpeechRecognitionEvent: {
15176 prototype: SpeechRecognitionEvent;
15177 new(): SpeechRecognitionEvent;
15180 interface SpeechRecognitionResult {
15181 readonly isFinal: boolean;
15182 readonly length: number;
15183 item(index: number): SpeechRecognitionAlternative;
15184 [index: number]: SpeechRecognitionAlternative;
15187 declare var SpeechRecognitionResult: {
15188 prototype: SpeechRecognitionResult;
15189 new(): SpeechRecognitionResult;
15192 interface SpeechRecognitionResultList {
15193 readonly length: number;
15194 item(index: number): SpeechRecognitionResult;
15195 [index: number]: SpeechRecognitionResult;
15198 declare var SpeechRecognitionResultList: {
15199 prototype: SpeechRecognitionResultList;
15200 new(): SpeechRecognitionResultList;
15203 interface SpeechSynthesisEventMap {
15204 "voiceschanged": Event;
15207 /** 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. */
15208 interface SpeechSynthesis extends EventTarget {
15209 onvoiceschanged: ((this: SpeechSynthesis, ev: Event) => any) | null;
15210 readonly paused: boolean;
15211 readonly pending: boolean;
15212 readonly speaking: boolean;
15214 getVoices(): SpeechSynthesisVoice[];
15217 speak(utterance: SpeechSynthesisUtterance): void;
15218 addEventListener<K extends keyof SpeechSynthesisEventMap>(type: K, listener: (this: SpeechSynthesis, ev: SpeechSynthesisEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
15219 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
15220 removeEventListener<K extends keyof SpeechSynthesisEventMap>(type: K, listener: (this: SpeechSynthesis, ev: SpeechSynthesisEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
15221 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
15224 declare var SpeechSynthesis: {
15225 prototype: SpeechSynthesis;
15226 new(): SpeechSynthesis;
15229 interface SpeechSynthesisErrorEvent extends SpeechSynthesisEvent {
15230 readonly error: SpeechSynthesisErrorCode;
15233 declare var SpeechSynthesisErrorEvent: {
15234 prototype: SpeechSynthesisErrorEvent;
15235 new(type: string, eventInitDict: SpeechSynthesisErrorEventInit): SpeechSynthesisErrorEvent;
15238 /** This Web Speech API interface contains information about the current state of SpeechSynthesisUtterance objects that have been processed in the speech service. */
15239 interface SpeechSynthesisEvent extends Event {
15240 readonly charIndex: number;
15241 readonly charLength: number;
15242 readonly elapsedTime: number;
15243 readonly name: string;
15244 readonly utterance: SpeechSynthesisUtterance;
15247 declare var SpeechSynthesisEvent: {
15248 prototype: SpeechSynthesisEvent;
15249 new(type: string, eventInitDict: SpeechSynthesisEventInit): SpeechSynthesisEvent;
15252 interface SpeechSynthesisUtteranceEventMap {
15253 "boundary": SpeechSynthesisEvent;
15254 "end": SpeechSynthesisEvent;
15255 "error": SpeechSynthesisErrorEvent;
15256 "mark": SpeechSynthesisEvent;
15257 "pause": SpeechSynthesisEvent;
15258 "resume": SpeechSynthesisEvent;
15259 "start": SpeechSynthesisEvent;
15262 /** 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.) */
15263 interface SpeechSynthesisUtterance extends EventTarget {
15265 onboundary: ((this: SpeechSynthesisUtterance, ev: SpeechSynthesisEvent) => any) | null;
15266 onend: ((this: SpeechSynthesisUtterance, ev: SpeechSynthesisEvent) => any) | null;
15267 onerror: ((this: SpeechSynthesisUtterance, ev: SpeechSynthesisErrorEvent) => any) | null;
15268 onmark: ((this: SpeechSynthesisUtterance, ev: SpeechSynthesisEvent) => any) | null;
15269 onpause: ((this: SpeechSynthesisUtterance, ev: SpeechSynthesisEvent) => any) | null;
15270 onresume: ((this: SpeechSynthesisUtterance, ev: SpeechSynthesisEvent) => any) | null;
15271 onstart: ((this: SpeechSynthesisUtterance, ev: SpeechSynthesisEvent) => any) | null;
15275 voice: SpeechSynthesisVoice | null;
15277 addEventListener<K extends keyof SpeechSynthesisUtteranceEventMap>(type: K, listener: (this: SpeechSynthesisUtterance, ev: SpeechSynthesisUtteranceEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
15278 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
15279 removeEventListener<K extends keyof SpeechSynthesisUtteranceEventMap>(type: K, listener: (this: SpeechSynthesisUtterance, ev: SpeechSynthesisUtteranceEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
15280 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
15283 declare var SpeechSynthesisUtterance: {
15284 prototype: SpeechSynthesisUtterance;
15285 new(text?: string): SpeechSynthesisUtterance;
15288 /** 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. */
15289 interface SpeechSynthesisVoice {
15290 readonly default: boolean;
15291 readonly lang: string;
15292 readonly localService: boolean;
15293 readonly name: string;
15294 readonly voiceURI: string;
15297 declare var SpeechSynthesisVoice: {
15298 prototype: SpeechSynthesisVoice;
15299 new(): SpeechSynthesisVoice;
15302 interface StaticRange extends AbstractRange {
15305 declare var StaticRange: {
15306 prototype: StaticRange;
15307 new(init: StaticRangeInit): StaticRange;
15310 /** 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. */
15311 interface StereoPannerNode extends AudioNode {
15312 readonly pan: AudioParam;
15315 declare var StereoPannerNode: {
15316 prototype: StereoPannerNode;
15317 new(context: BaseAudioContext, options?: StereoPannerOptions): StereoPannerNode;
15320 /** 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. */
15321 interface Storage {
15323 * Returns the number of key/value pairs currently present in the list associated with the object.
15325 readonly length: number;
15327 * Empties the list associated with the object of all key/value pairs, if there are any.
15331 * 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.
15333 getItem(key: string): string | null;
15335 * 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.
15337 key(index: number): string | null;
15339 * 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.
15341 removeItem(key: string): void;
15343 * Sets the value of the pair identified by key to value, creating a new key/value pair if none existed for key previously.
15345 * 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.)
15347 setItem(key: string, value: string): void;
15348 [name: string]: any;
15351 declare var Storage: {
15352 prototype: Storage;
15356 /** A StorageEvent is sent to a window when a storage area it has access to is changed within the context of another document. */
15357 interface StorageEvent extends Event {
15359 * Returns the key of the storage item being changed.
15361 readonly key: string | null;
15363 * Returns the new value of the key of the storage item whose value is being changed.
15365 readonly newValue: string | null;
15367 * Returns the old value of the key of the storage item whose value is being changed.
15369 readonly oldValue: string | null;
15371 * Returns the Storage object that was affected.
15373 readonly storageArea: Storage | null;
15375 * Returns the URL of the document whose storage item changed.
15377 readonly url: string;
15380 declare var StorageEvent: {
15381 prototype: StorageEvent;
15382 new(type: string, eventInitDict?: StorageEventInit): StorageEvent;
15385 interface StorageManager {
15386 estimate(): Promise<StorageEstimate>;
15387 persist(): Promise<boolean>;
15388 persisted(): Promise<boolean>;
15391 declare var StorageManager: {
15392 prototype: StorageManager;
15393 new(): StorageManager;
15396 interface StyleMedia {
15397 readonly type: string;
15398 matchMedium(mediaquery: string): boolean;
15401 declare var StyleMedia: {
15402 prototype: StyleMedia;
15406 /** A single style sheet. CSS style sheets will further implement the more specialized CSSStyleSheet interface. */
15407 interface StyleSheet {
15409 readonly href: string | null;
15410 readonly media: MediaList;
15411 readonly ownerNode: Element | ProcessingInstruction | null;
15412 readonly parentStyleSheet: CSSStyleSheet | null;
15413 readonly title: string | null;
15414 readonly type: string;
15417 declare var StyleSheet: {
15418 prototype: StyleSheet;
15422 /** A list of StyleSheet. */
15423 interface StyleSheetList {
15424 readonly length: number;
15425 item(index: number): CSSStyleSheet | null;
15426 [index: number]: CSSStyleSheet;
15429 declare var StyleSheetList: {
15430 prototype: StyleSheetList;
15431 new(): StyleSheetList;
15434 /** 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). */
15435 interface SubtleCrypto {
15436 decrypt(algorithm: AlgorithmIdentifier | RsaOaepParams | AesCtrParams | AesCbcParams | AesCmacParams | AesGcmParams | AesCfbParams, key: CryptoKey, data: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer): Promise<ArrayBuffer>;
15437 deriveBits(algorithm: AlgorithmIdentifier | EcdhKeyDeriveParams | DhKeyDeriveParams | ConcatParams | HkdfParams | Pbkdf2Params, baseKey: CryptoKey, length: number): Promise<ArrayBuffer>;
15438 deriveKey(algorithm: AlgorithmIdentifier | EcdhKeyDeriveParams | DhKeyDeriveParams | ConcatParams | HkdfParams | Pbkdf2Params, baseKey: CryptoKey, derivedKeyType: string | AesDerivedKeyParams | HmacImportParams | ConcatParams | HkdfParams | Pbkdf2Params, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey>;
15439 digest(algorithm: AlgorithmIdentifier, data: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer): Promise<ArrayBuffer>;
15440 encrypt(algorithm: AlgorithmIdentifier | RsaOaepParams | AesCtrParams | AesCbcParams | AesCmacParams | AesGcmParams | AesCfbParams, key: CryptoKey, data: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer): Promise<ArrayBuffer>;
15441 exportKey(format: "jwk", key: CryptoKey): Promise<JsonWebKey>;
15442 exportKey(format: "raw" | "pkcs8" | "spki", key: CryptoKey): Promise<ArrayBuffer>;
15443 exportKey(format: string, key: CryptoKey): Promise<JsonWebKey | ArrayBuffer>;
15444 generateKey(algorithm: RsaHashedKeyGenParams | EcKeyGenParams | DhKeyGenParams, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKeyPair>;
15445 generateKey(algorithm: AesKeyGenParams | HmacKeyGenParams | Pbkdf2Params, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey>;
15446 generateKey(algorithm: AlgorithmIdentifier, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKeyPair | CryptoKey>;
15447 importKey(format: "jwk", keyData: JsonWebKey, algorithm: AlgorithmIdentifier | RsaHashedImportParams | EcKeyImportParams | HmacImportParams | DhImportKeyParams | AesKeyAlgorithm, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey>;
15448 importKey(format: "raw" | "pkcs8" | "spki", keyData: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer, algorithm: AlgorithmIdentifier | RsaHashedImportParams | EcKeyImportParams | HmacImportParams | DhImportKeyParams | AesKeyAlgorithm, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey>;
15449 importKey(format: string, keyData: JsonWebKey | Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer, algorithm: AlgorithmIdentifier | RsaHashedImportParams | EcKeyImportParams | HmacImportParams | DhImportKeyParams | AesKeyAlgorithm, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey>;
15450 sign(algorithm: AlgorithmIdentifier | RsaPssParams | EcdsaParams | AesCmacParams, key: CryptoKey, data: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer): Promise<ArrayBuffer>;
15451 unwrapKey(format: "raw" | "pkcs8" | "spki" | "jwk" | string, wrappedKey: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer, unwrappingKey: CryptoKey, unwrapAlgorithm: AlgorithmIdentifier | RsaOaepParams | AesCtrParams | AesCbcParams | AesCmacParams | AesGcmParams | AesCfbParams, unwrappedKeyAlgorithm: AlgorithmIdentifier | RsaHashedImportParams | EcKeyImportParams | HmacImportParams | DhImportKeyParams | AesKeyAlgorithm, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey>;
15452 verify(algorithm: AlgorithmIdentifier | RsaPssParams | EcdsaParams | AesCmacParams, key: CryptoKey, signature: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer, data: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer): Promise<boolean>;
15453 wrapKey(format: "raw" | "pkcs8" | "spki" | "jwk" | string, key: CryptoKey, wrappingKey: CryptoKey, wrapAlgorithm: AlgorithmIdentifier | RsaOaepParams | AesCtrParams | AesCbcParams | AesCmacParams | AesGcmParams | AesCfbParams): Promise<ArrayBuffer>;
15456 declare var SubtleCrypto: {
15457 prototype: SubtleCrypto;
15458 new(): SubtleCrypto;
15461 /** This ServiceWorker API interface provides an interface for registering and listing sync registrations. */
15462 interface SyncManager {
15463 getTags(): Promise<string[]>;
15464 register(tag: string): Promise<void>;
15467 declare var SyncManager: {
15468 prototype: SyncManager;
15469 new(): SyncManager;
15472 /** 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. */
15473 interface Text extends CharacterData, Slottable {
15474 readonly assignedSlot: HTMLSlotElement | null;
15476 * Returns the combined data of all direct Text node siblings.
15478 readonly wholeText: string;
15480 * Splits data at the given offset and returns the remainder as Text node.
15482 splitText(offset: number): Text;
15485 declare var Text: {
15487 new(data?: string): Text;
15490 /** 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. */
15491 interface TextDecoder extends TextDecoderCommon {
15493 * 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.
15496 * var string = "", decoder = new TextDecoder(encoding), buffer;
15497 * while(buffer = next_chunk()) {
15498 * string += decoder.decode(buffer, {stream:true});
15500 * string += decoder.decode(); // end-of-stream
15503 * If the error mode is "fatal" and encoding's decoder returns error, throws a TypeError.
15505 decode(input?: BufferSource, options?: TextDecodeOptions): string;
15508 declare var TextDecoder: {
15509 prototype: TextDecoder;
15510 new(label?: string, options?: TextDecoderOptions): TextDecoder;
15513 interface TextDecoderCommon {
15515 * Returns encoding's name, lowercased.
15517 readonly encoding: string;
15519 * Returns true if error mode is "fatal", and false otherwise.
15521 readonly fatal: boolean;
15523 * Returns true if ignore BOM flag is set, and false otherwise.
15525 readonly ignoreBOM: boolean;
15528 interface TextDecoderStream extends GenericTransformStream, TextDecoderCommon {
15529 readonly readable: ReadableStream<string>;
15530 readonly writable: WritableStream<BufferSource>;
15533 declare var TextDecoderStream: {
15534 prototype: TextDecoderStream;
15535 new(label?: string, options?: TextDecoderOptions): TextDecoderStream;
15538 /** 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. */
15539 interface TextEncoder extends TextEncoderCommon {
15541 * Returns the result of running UTF-8's encoder.
15543 encode(input?: string): Uint8Array;
15545 * 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.
15547 encodeInto(source: string, destination: Uint8Array): TextEncoderEncodeIntoResult;
15550 declare var TextEncoder: {
15551 prototype: TextEncoder;
15552 new(): TextEncoder;
15555 interface TextEncoderCommon {
15559 readonly encoding: string;
15562 interface TextEncoderStream extends GenericTransformStream, TextEncoderCommon {
15563 readonly readable: ReadableStream<Uint8Array>;
15564 readonly writable: WritableStream<string>;
15567 declare var TextEncoderStream: {
15568 prototype: TextEncoderStream;
15569 new(): TextEncoderStream;
15572 interface TextEvent extends UIEvent {
15573 readonly data: string;
15574 initTextEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, viewArg: Window, dataArg: string, inputMethod: number, locale: string): void;
15575 readonly DOM_INPUT_METHOD_DROP: number;
15576 readonly DOM_INPUT_METHOD_HANDWRITING: number;
15577 readonly DOM_INPUT_METHOD_IME: number;
15578 readonly DOM_INPUT_METHOD_KEYBOARD: number;
15579 readonly DOM_INPUT_METHOD_MULTIMODAL: number;
15580 readonly DOM_INPUT_METHOD_OPTION: number;
15581 readonly DOM_INPUT_METHOD_PASTE: number;
15582 readonly DOM_INPUT_METHOD_SCRIPT: number;
15583 readonly DOM_INPUT_METHOD_UNKNOWN: number;
15584 readonly DOM_INPUT_METHOD_VOICE: number;
15587 declare var TextEvent: {
15588 prototype: TextEvent;
15590 readonly DOM_INPUT_METHOD_DROP: number;
15591 readonly DOM_INPUT_METHOD_HANDWRITING: number;
15592 readonly DOM_INPUT_METHOD_IME: number;
15593 readonly DOM_INPUT_METHOD_KEYBOARD: number;
15594 readonly DOM_INPUT_METHOD_MULTIMODAL: number;
15595 readonly DOM_INPUT_METHOD_OPTION: number;
15596 readonly DOM_INPUT_METHOD_PASTE: number;
15597 readonly DOM_INPUT_METHOD_SCRIPT: number;
15598 readonly DOM_INPUT_METHOD_UNKNOWN: number;
15599 readonly DOM_INPUT_METHOD_VOICE: number;
15602 /** The dimensions of a piece of text in the canvas, as created by the CanvasRenderingContext2D.measureText() method. */
15603 interface TextMetrics {
15605 * Returns the measurement described below.
15607 readonly actualBoundingBoxAscent: number;
15609 * Returns the measurement described below.
15611 readonly actualBoundingBoxDescent: number;
15613 * Returns the measurement described below.
15615 readonly actualBoundingBoxLeft: number;
15617 * Returns the measurement described below.
15619 readonly actualBoundingBoxRight: number;
15621 * Returns the measurement described below.
15623 readonly alphabeticBaseline: number;
15625 * Returns the measurement described below.
15627 readonly emHeightAscent: number;
15629 * Returns the measurement described below.
15631 readonly emHeightDescent: number;
15633 * Returns the measurement described below.
15635 readonly fontBoundingBoxAscent: number;
15637 * Returns the measurement described below.
15639 readonly fontBoundingBoxDescent: number;
15641 * Returns the measurement described below.
15643 readonly hangingBaseline: number;
15645 * Returns the measurement described below.
15647 readonly ideographicBaseline: number;
15649 * Returns the measurement described below.
15651 readonly width: number;
15654 declare var TextMetrics: {
15655 prototype: TextMetrics;
15656 new(): TextMetrics;
15659 interface TextTrackEventMap {
15660 "cuechange": Event;
15663 /** This interface also inherits properties from EventTarget. */
15664 interface TextTrack extends EventTarget {
15666 * 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.
15668 readonly activeCues: TextTrackCueList | null;
15670 * Returns the text track list of cues, as a TextTrackCueList object.
15672 readonly cues: TextTrackCueList | null;
15674 * Returns the ID of the given track.
15676 * 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.
15678 * For TextTrack objects corresponding to track elements, this is the ID of the track element.
15680 readonly id: string;
15682 * Returns the text track in-band metadata track dispatch type string.
15684 readonly inBandMetadataTrackDispatchType: string;
15686 * Returns the text track kind string.
15688 readonly kind: TextTrackKind;
15690 * 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).
15692 readonly label: string;
15694 * Returns the text track language string.
15696 readonly language: string;
15698 * Returns the text track mode, represented by a string from the following list:
15700 * Can be set, to change the mode.
15702 mode: TextTrackMode;
15703 oncuechange: ((this: TextTrack, ev: Event) => any) | null;
15704 readonly sourceBuffer: SourceBuffer | null;
15706 * Adds the given cue to textTrack's text track list of cues.
15708 addCue(cue: TextTrackCue): void;
15710 * Removes the given cue from textTrack's text track list of cues.
15712 removeCue(cue: TextTrackCue): void;
15713 addEventListener<K extends keyof TextTrackEventMap>(type: K, listener: (this: TextTrack, ev: TextTrackEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
15714 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
15715 removeEventListener<K extends keyof TextTrackEventMap>(type: K, listener: (this: TextTrack, ev: TextTrackEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
15716 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
15719 declare var TextTrack: {
15720 prototype: TextTrack;
15724 interface TextTrackCueEventMap {
15729 /** 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. */
15730 interface TextTrackCue extends EventTarget {
15732 * Returns the text track cue end time, in seconds.
15738 * Returns the text track cue identifier.
15743 onenter: ((this: TextTrackCue, ev: Event) => any) | null;
15744 onexit: ((this: TextTrackCue, ev: Event) => any) | null;
15746 * Returns true if the text track cue pause-on-exit flag is set, false otherwise.
15750 pauseOnExit: boolean;
15752 * Returns the text track cue start time, in seconds.
15758 * Returns the TextTrack object to which this text track cue belongs, if any, or null otherwise.
15760 readonly track: TextTrack | null;
15761 addEventListener<K extends keyof TextTrackCueEventMap>(type: K, listener: (this: TextTrackCue, ev: TextTrackCueEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
15762 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
15763 removeEventListener<K extends keyof TextTrackCueEventMap>(type: K, listener: (this: TextTrackCue, ev: TextTrackCueEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
15764 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
15767 declare var TextTrackCue: {
15768 prototype: TextTrackCue;
15769 new(): TextTrackCue;
15772 interface TextTrackCueList {
15774 * Returns the number of cues in the list.
15776 readonly length: number;
15778 * Returns the first text track cue (in text track cue order) with text track cue identifier id.
15780 * Returns null if none of the cues have the given identifier or if the argument is the empty string.
15782 getCueById(id: string): TextTrackCue | null;
15783 [index: number]: TextTrackCue;
15786 declare var TextTrackCueList: {
15787 prototype: TextTrackCueList;
15788 new(): TextTrackCueList;
15791 interface TextTrackListEventMap {
15792 "addtrack": TrackEvent;
15794 "removetrack": TrackEvent;
15797 interface TextTrackList extends EventTarget {
15798 readonly length: number;
15799 onaddtrack: ((this: TextTrackList, ev: TrackEvent) => any) | null;
15800 onchange: ((this: TextTrackList, ev: Event) => any) | null;
15801 onremovetrack: ((this: TextTrackList, ev: TrackEvent) => any) | null;
15802 getTrackById(id: string): TextTrack | null;
15803 addEventListener<K extends keyof TextTrackListEventMap>(type: K, listener: (this: TextTrackList, ev: TextTrackListEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
15804 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
15805 removeEventListener<K extends keyof TextTrackListEventMap>(type: K, listener: (this: TextTrackList, ev: TextTrackListEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
15806 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
15807 [index: number]: TextTrack;
15810 declare var TextTrackList: {
15811 prototype: TextTrackList;
15812 new(): TextTrackList;
15815 /** 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. */
15816 interface TimeRanges {
15818 * Returns the number of ranges in the object.
15820 readonly length: number;
15822 * Returns the time for the end of the range with the given index.
15824 * Throws an "IndexSizeError" DOMException if the index is out of range.
15826 end(index: number): number;
15828 * Returns the time for the start of the range with the given index.
15830 * Throws an "IndexSizeError" DOMException if the index is out of range.
15832 start(index: number): number;
15835 declare var TimeRanges: {
15836 prototype: TimeRanges;
15840 /** 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. */
15842 readonly altitudeAngle: number;
15843 readonly azimuthAngle: number;
15844 readonly clientX: number;
15845 readonly clientY: number;
15846 readonly force: number;
15847 readonly identifier: number;
15848 readonly pageX: number;
15849 readonly pageY: number;
15850 readonly radiusX: number;
15851 readonly radiusY: number;
15852 readonly rotationAngle: number;
15853 readonly screenX: number;
15854 readonly screenY: number;
15855 readonly target: EventTarget;
15856 readonly touchType: TouchType;
15859 declare var Touch: {
15861 new(touchInitDict: TouchInit): Touch;
15864 /** 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. */
15865 interface TouchEvent extends UIEvent {
15866 readonly altKey: boolean;
15867 readonly changedTouches: TouchList;
15868 readonly ctrlKey: boolean;
15869 readonly metaKey: boolean;
15870 readonly shiftKey: boolean;
15871 readonly targetTouches: TouchList;
15872 readonly touches: TouchList;
15875 declare var TouchEvent: {
15876 prototype: TouchEvent;
15877 new(type: string, eventInitDict?: TouchEventInit): TouchEvent;
15880 /** 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. */
15881 interface TouchList {
15882 readonly length: number;
15883 item(index: number): Touch | null;
15884 [index: number]: Touch;
15887 declare var TouchList: {
15888 prototype: TouchList;
15892 /** 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. */
15893 interface TrackEvent extends Event {
15895 * Returns the track object (TextTrack, AudioTrack, or VideoTrack) to which the event relates.
15897 readonly track: TextTrack | null;
15900 declare var TrackEvent: {
15901 prototype: TrackEvent;
15902 new(type: string, eventInitDict?: TrackEventInit): TrackEvent;
15905 interface TransformStream<I = any, O = any> {
15906 readonly readable: ReadableStream<O>;
15907 readonly writable: WritableStream<I>;
15910 declare var TransformStream: {
15911 prototype: TransformStream;
15912 new<I = any, O = any>(transformer?: Transformer<I, O>, writableStrategy?: QueuingStrategy<I>, readableStrategy?: QueuingStrategy<O>): TransformStream<I, O>;
15915 interface TransformStreamDefaultController<O = any> {
15916 readonly desiredSize: number | null;
15917 enqueue(chunk: O): void;
15918 error(reason?: any): void;
15922 declare var TransformStreamDefaultController: {
15923 prototype: TransformStreamDefaultController;
15924 new(): TransformStreamDefaultController;
15927 /** Events providing information related to transitions. */
15928 interface TransitionEvent extends Event {
15929 readonly elapsedTime: number;
15930 readonly propertyName: string;
15931 readonly pseudoElement: string;
15934 declare var TransitionEvent: {
15935 prototype: TransitionEvent;
15936 new(type: string, transitionEventInitDict?: TransitionEventInit): TransitionEvent;
15939 /** The nodes of a document subtree and a position within them. */
15940 interface TreeWalker {
15942 readonly filter: NodeFilter | null;
15943 readonly root: Node;
15944 readonly whatToShow: number;
15945 firstChild(): Node | null;
15946 lastChild(): Node | null;
15947 nextNode(): Node | null;
15948 nextSibling(): Node | null;
15949 parentNode(): Node | null;
15950 previousNode(): Node | null;
15951 previousSibling(): Node | null;
15954 declare var TreeWalker: {
15955 prototype: TreeWalker;
15959 /** Simple user interface events. */
15960 interface UIEvent extends Event {
15961 readonly detail: number;
15962 readonly view: Window | null;
15964 readonly which: number;
15967 declare var UIEvent: {
15968 prototype: UIEvent;
15969 new(type: string, eventInitDict?: UIEventInit): UIEvent;
15972 /** The URLÂ interface represents an object providing static methods used for creating object URLs. */
15978 toString(): string;
15979 readonly origin: string;
15985 readonly searchParams: URLSearchParams;
15992 new(url: string, base?: string | URL): URL;
15993 createObjectURL(object: any): string;
15994 revokeObjectURL(url: string): void;
15997 type webkitURL = URL;
15998 declare var webkitURL: typeof URL;
16000 interface URLSearchParams {
16002 * Appends a specified key/value pair as a new search parameter.
16004 append(name: string, value: string): void;
16006 * Deletes the given search parameter, and its associated value, from the list of all search parameters.
16008 delete(name: string): void;
16010 * Returns the first value associated to the given search parameter.
16012 get(name: string): string | null;
16014 * Returns all the values association with a given search parameter.
16016 getAll(name: string): string[];
16018 * Returns a Boolean indicating if such a search parameter exists.
16020 has(name: string): boolean;
16022 * Sets the value associated to a given search parameter to the given value. If there were several values, delete the others.
16024 set(name: string, value: string): void;
16027 * Returns a string containing a query string suitable for use in a URL. Does not include the question mark.
16029 toString(): string;
16030 forEach(callbackfn: (value: string, key: string, parent: URLSearchParams) => void, thisArg?: any): void;
16033 declare var URLSearchParams: {
16034 prototype: URLSearchParams;
16035 new(init?: string[][] | Record<string, string> | string | URLSearchParams): URLSearchParams;
16036 toString(): string;
16039 /** 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. */
16040 interface VRDisplay extends EventTarget {
16041 readonly capabilities: VRDisplayCapabilities;
16044 readonly displayId: number;
16045 readonly displayName: string;
16046 readonly isConnected: boolean;
16047 readonly isPresenting: boolean;
16048 readonly stageParameters: VRStageParameters | null;
16049 cancelAnimationFrame(handle: number): void;
16050 exitPresent(): Promise<void>;
16051 getEyeParameters(whichEye: string): VREyeParameters;
16052 getFrameData(frameData: VRFrameData): boolean;
16053 getLayers(): VRLayer[];
16056 requestAnimationFrame(callback: FrameRequestCallback): number;
16057 requestPresent(layers: VRLayer[]): Promise<void>;
16059 submitFrame(pose?: VRPose): void;
16062 declare var VRDisplay: {
16063 prototype: VRDisplay;
16067 /** 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. */
16068 interface VRDisplayCapabilities {
16069 readonly canPresent: boolean;
16070 readonly hasExternalDisplay: boolean;
16071 readonly hasOrientation: boolean;
16072 readonly hasPosition: boolean;
16073 readonly maxLayers: number;
16076 declare var VRDisplayCapabilities: {
16077 prototype: VRDisplayCapabilities;
16078 new(): VRDisplayCapabilities;
16081 /** This WebVR API interface represents represents the event object of WebVR-related events (see the list of WebVR window extensions). */
16082 interface VRDisplayEvent extends Event {
16083 readonly display: VRDisplay;
16084 readonly reason: VRDisplayEventReason | null;
16087 declare var VRDisplayEvent: {
16088 prototype: VRDisplayEvent;
16089 new(type: string, eventInitDict: VRDisplayEventInit): VRDisplayEvent;
16092 /** This WebVR API interface represents all the information required to correctly render a scene for a given eye, including field of view information. */
16093 interface VREyeParameters {
16095 readonly fieldOfView: VRFieldOfView;
16096 readonly offset: Float32Array;
16097 readonly renderHeight: number;
16098 readonly renderWidth: number;
16101 declare var VREyeParameters: {
16102 prototype: VREyeParameters;
16103 new(): VREyeParameters;
16106 /** This WebVR API interface represents a field of view defined by 4 different degree values describing the view from a center point. */
16107 interface VRFieldOfView {
16108 readonly downDegrees: number;
16109 readonly leftDegrees: number;
16110 readonly rightDegrees: number;
16111 readonly upDegrees: number;
16114 declare var VRFieldOfView: {
16115 prototype: VRFieldOfView;
16116 new(): VRFieldOfView;
16119 /** This WebVR API interface represents all the information needed to render a single frame of a VR scene; constructed by VRDisplay.getFrameData(). */
16120 interface VRFrameData {
16121 readonly leftProjectionMatrix: Float32Array;
16122 readonly leftViewMatrix: Float32Array;
16123 readonly pose: VRPose;
16124 readonly rightProjectionMatrix: Float32Array;
16125 readonly rightViewMatrix: Float32Array;
16126 readonly timestamp: number;
16129 declare var VRFrameData: {
16130 prototype: VRFrameData;
16131 new(): VRFrameData;
16134 /** This WebVR API interface represents the state of a VR sensor at a given timestamp (which includes orientation, position, velocity, and acceleration information.) */
16136 readonly angularAcceleration: Float32Array | null;
16137 readonly angularVelocity: Float32Array | null;
16138 readonly linearAcceleration: Float32Array | null;
16139 readonly linearVelocity: Float32Array | null;
16140 readonly orientation: Float32Array | null;
16141 readonly position: Float32Array | null;
16142 readonly timestamp: number;
16145 declare var VRPose: {
16150 interface VTTCue extends TextTrackCue {
16151 align: AlignSetting;
16152 line: LineAndPositionSetting;
16153 lineAlign: LineAlignSetting;
16154 position: LineAndPositionSetting;
16155 positionAlign: PositionAlignSetting;
16156 region: VTTRegion | null;
16158 snapToLines: boolean;
16160 vertical: DirectionSetting;
16161 getCueAsHTML(): DocumentFragment;
16162 addEventListener<K extends keyof TextTrackCueEventMap>(type: K, listener: (this: VTTCue, ev: TextTrackCueEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
16163 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
16164 removeEventListener<K extends keyof TextTrackCueEventMap>(type: K, listener: (this: VTTCue, ev: TextTrackCueEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
16165 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
16168 declare var VTTCue: {
16170 new(startTime: number, endTime: number, text: string): VTTCue;
16173 interface VTTRegion {
16176 regionAnchorX: number;
16177 regionAnchorY: number;
16178 scroll: ScrollSetting;
16179 viewportAnchorX: number;
16180 viewportAnchorY: number;
16184 declare var VTTRegion: {
16185 prototype: VTTRegion;
16189 /** 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. */
16190 interface ValidityState {
16191 readonly badInput: boolean;
16192 readonly customError: boolean;
16193 readonly patternMismatch: boolean;
16194 readonly rangeOverflow: boolean;
16195 readonly rangeUnderflow: boolean;
16196 readonly stepMismatch: boolean;
16197 readonly tooLong: boolean;
16198 readonly tooShort: boolean;
16199 readonly typeMismatch: boolean;
16200 readonly valid: boolean;
16201 readonly valueMissing: boolean;
16204 declare var ValidityState: {
16205 prototype: ValidityState;
16206 new(): ValidityState;
16209 /** Returned by the HTMLVideoElement.getVideoPlaybackQuality() method and contains metrics that can be used to determine the playback quality of a video. */
16210 interface VideoPlaybackQuality {
16211 readonly creationTime: number;
16212 readonly droppedVideoFrames: number;
16213 readonly totalVideoFrames: number;
16216 declare var VideoPlaybackQuality: {
16217 prototype: VideoPlaybackQuality;
16218 new(): VideoPlaybackQuality;
16221 interface VisualViewportEventMap {
16226 interface VisualViewport extends EventTarget {
16227 readonly height: number;
16228 readonly offsetLeft: number;
16229 readonly offsetTop: number;
16230 onresize: ((this: VisualViewport, ev: UIEvent) => any) | null;
16231 onscroll: ((this: VisualViewport, ev: Event) => any) | null;
16232 readonly pageLeft: number;
16233 readonly pageTop: number;
16234 readonly scale: number;
16235 readonly width: number;
16236 addEventListener<K extends keyof VisualViewportEventMap>(type: K, listener: (this: VisualViewport, ev: VisualViewportEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
16237 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
16238 removeEventListener<K extends keyof VisualViewportEventMap>(type: K, listener: (this: VisualViewport, ev: VisualViewportEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
16239 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
16242 declare var VisualViewport: {
16243 prototype: VisualViewport;
16244 new(): VisualViewport;
16247 interface WEBGL_color_buffer_float {
16248 readonly FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE_EXT: GLenum;
16249 readonly RGBA32F_EXT: GLenum;
16250 readonly UNSIGNED_NORMALIZED_EXT: GLenum;
16253 interface WEBGL_compressed_texture_astc {
16254 getSupportedProfiles(): string[];
16255 readonly COMPRESSED_RGBA_ASTC_10x10_KHR: GLenum;
16256 readonly COMPRESSED_RGBA_ASTC_10x5_KHR: GLenum;
16257 readonly COMPRESSED_RGBA_ASTC_10x6_KHR: GLenum;
16258 readonly COMPRESSED_RGBA_ASTC_10x8_KHR: GLenum;
16259 readonly COMPRESSED_RGBA_ASTC_12x10_KHR: GLenum;
16260 readonly COMPRESSED_RGBA_ASTC_12x12_KHR: GLenum;
16261 readonly COMPRESSED_RGBA_ASTC_4x4_KHR: GLenum;
16262 readonly COMPRESSED_RGBA_ASTC_5x4_KHR: GLenum;
16263 readonly COMPRESSED_RGBA_ASTC_5x5_KHR: GLenum;
16264 readonly COMPRESSED_RGBA_ASTC_6x5_KHR: GLenum;
16265 readonly COMPRESSED_RGBA_ASTC_6x6_KHR: GLenum;
16266 readonly COMPRESSED_RGBA_ASTC_8x5_KHR: GLenum;
16267 readonly COMPRESSED_RGBA_ASTC_8x6_KHR: GLenum;
16268 readonly COMPRESSED_RGBA_ASTC_8x8_KHR: GLenum;
16269 readonly COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR: GLenum;
16270 readonly COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR: GLenum;
16271 readonly COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR: GLenum;
16272 readonly COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR: GLenum;
16273 readonly COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR: GLenum;
16274 readonly COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR: GLenum;
16275 readonly COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR: GLenum;
16276 readonly COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR: GLenum;
16277 readonly COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR: GLenum;
16278 readonly COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR: GLenum;
16279 readonly COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR: GLenum;
16280 readonly COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR: GLenum;
16281 readonly COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR: GLenum;
16282 readonly COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR: GLenum;
16285 /** The WEBGL_compressed_texture_s3tc extension is part of the WebGL API and exposes four S3TC compressed texture formats. */
16286 interface WEBGL_compressed_texture_s3tc {
16287 readonly COMPRESSED_RGBA_S3TC_DXT1_EXT: GLenum;
16288 readonly COMPRESSED_RGBA_S3TC_DXT3_EXT: GLenum;
16289 readonly COMPRESSED_RGBA_S3TC_DXT5_EXT: GLenum;
16290 readonly COMPRESSED_RGB_S3TC_DXT1_EXT: GLenum;
16293 interface WEBGL_compressed_texture_s3tc_srgb {
16294 readonly COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT: GLenum;
16295 readonly COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT: GLenum;
16296 readonly COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT: GLenum;
16297 readonly COMPRESSED_SRGB_S3TC_DXT1_EXT: GLenum;
16300 /** 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. */
16301 interface WEBGL_debug_renderer_info {
16302 readonly UNMASKED_RENDERER_WEBGL: GLenum;
16303 readonly UNMASKED_VENDOR_WEBGL: GLenum;
16306 interface WEBGL_debug_shaders {
16307 getTranslatedShaderSource(shader: WebGLShader): string;
16310 /** The WEBGL_depth_texture extension is part of the WebGL API and defines 2D depth and depth-stencil textures. */
16311 interface WEBGL_depth_texture {
16312 readonly UNSIGNED_INT_24_8_WEBGL: GLenum;
16315 interface WEBGL_draw_buffers {
16316 drawBuffersWEBGL(buffers: GLenum[]): void;
16317 readonly COLOR_ATTACHMENT0_WEBGL: GLenum;
16318 readonly COLOR_ATTACHMENT10_WEBGL: GLenum;
16319 readonly COLOR_ATTACHMENT11_WEBGL: GLenum;
16320 readonly COLOR_ATTACHMENT12_WEBGL: GLenum;
16321 readonly COLOR_ATTACHMENT13_WEBGL: GLenum;
16322 readonly COLOR_ATTACHMENT14_WEBGL: GLenum;
16323 readonly COLOR_ATTACHMENT15_WEBGL: GLenum;
16324 readonly COLOR_ATTACHMENT1_WEBGL: GLenum;
16325 readonly COLOR_ATTACHMENT2_WEBGL: GLenum;
16326 readonly COLOR_ATTACHMENT3_WEBGL: GLenum;
16327 readonly COLOR_ATTACHMENT4_WEBGL: GLenum;
16328 readonly COLOR_ATTACHMENT5_WEBGL: GLenum;
16329 readonly COLOR_ATTACHMENT6_WEBGL: GLenum;
16330 readonly COLOR_ATTACHMENT7_WEBGL: GLenum;
16331 readonly COLOR_ATTACHMENT8_WEBGL: GLenum;
16332 readonly COLOR_ATTACHMENT9_WEBGL: GLenum;
16333 readonly DRAW_BUFFER0_WEBGL: GLenum;
16334 readonly DRAW_BUFFER10_WEBGL: GLenum;
16335 readonly DRAW_BUFFER11_WEBGL: GLenum;
16336 readonly DRAW_BUFFER12_WEBGL: GLenum;
16337 readonly DRAW_BUFFER13_WEBGL: GLenum;
16338 readonly DRAW_BUFFER14_WEBGL: GLenum;
16339 readonly DRAW_BUFFER15_WEBGL: GLenum;
16340 readonly DRAW_BUFFER1_WEBGL: GLenum;
16341 readonly DRAW_BUFFER2_WEBGL: GLenum;
16342 readonly DRAW_BUFFER3_WEBGL: GLenum;
16343 readonly DRAW_BUFFER4_WEBGL: GLenum;
16344 readonly DRAW_BUFFER5_WEBGL: GLenum;
16345 readonly DRAW_BUFFER6_WEBGL: GLenum;
16346 readonly DRAW_BUFFER7_WEBGL: GLenum;
16347 readonly DRAW_BUFFER8_WEBGL: GLenum;
16348 readonly DRAW_BUFFER9_WEBGL: GLenum;
16349 readonly MAX_COLOR_ATTACHMENTS_WEBGL: GLenum;
16350 readonly MAX_DRAW_BUFFERS_WEBGL: GLenum;
16353 interface WEBGL_lose_context {
16354 loseContext(): void;
16355 restoreContext(): void;
16358 /** A WaveShaperNode always has exactly one input and one output. */
16359 interface WaveShaperNode extends AudioNode {
16360 curve: Float32Array | null;
16361 oversample: OverSampleType;
16364 declare var WaveShaperNode: {
16365 prototype: WaveShaperNode;
16366 new(context: BaseAudioContext, options?: WaveShaperOptions): WaveShaperNode;
16369 interface WebAuthentication {
16370 getAssertion(assertionChallenge: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer | null, options?: AssertionOptions): Promise<WebAuthnAssertion>;
16371 makeCredential(accountInformation: Account, cryptoParameters: ScopedCredentialParameters[], attestationChallenge: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer | null, options?: ScopedCredentialOptions): Promise<ScopedCredentialInfo>;
16374 declare var WebAuthentication: {
16375 prototype: WebAuthentication;
16376 new(): WebAuthentication;
16379 interface WebAuthnAssertion {
16380 readonly authenticatorData: ArrayBuffer;
16381 readonly clientData: ArrayBuffer;
16382 readonly credential: ScopedCredential;
16383 readonly signature: ArrayBuffer;
16386 declare var WebAuthnAssertion: {
16387 prototype: WebAuthnAssertion;
16388 new(): WebAuthnAssertion;
16391 interface WebGL2RenderingContext extends WebGL2RenderingContextBase, WebGL2RenderingContextOverloads, WebGLRenderingContextBase {
16394 declare var WebGL2RenderingContext: {
16395 prototype: WebGL2RenderingContext;
16396 new(): WebGL2RenderingContext;
16397 readonly ACTIVE_ATTRIBUTES: GLenum;
16398 readonly ACTIVE_TEXTURE: GLenum;
16399 readonly ACTIVE_UNIFORMS: GLenum;
16400 readonly ALIASED_LINE_WIDTH_RANGE: GLenum;
16401 readonly ALIASED_POINT_SIZE_RANGE: GLenum;
16402 readonly ALPHA: GLenum;
16403 readonly ALPHA_BITS: GLenum;
16404 readonly ALWAYS: GLenum;
16405 readonly ARRAY_BUFFER: GLenum;
16406 readonly ARRAY_BUFFER_BINDING: GLenum;
16407 readonly ATTACHED_SHADERS: GLenum;
16408 readonly BACK: GLenum;
16409 readonly BLEND: GLenum;
16410 readonly BLEND_COLOR: GLenum;
16411 readonly BLEND_DST_ALPHA: GLenum;
16412 readonly BLEND_DST_RGB: GLenum;
16413 readonly BLEND_EQUATION: GLenum;
16414 readonly BLEND_EQUATION_ALPHA: GLenum;
16415 readonly BLEND_EQUATION_RGB: GLenum;
16416 readonly BLEND_SRC_ALPHA: GLenum;
16417 readonly BLEND_SRC_RGB: GLenum;
16418 readonly BLUE_BITS: GLenum;
16419 readonly BOOL: GLenum;
16420 readonly BOOL_VEC2: GLenum;
16421 readonly BOOL_VEC3: GLenum;
16422 readonly BOOL_VEC4: GLenum;
16423 readonly BROWSER_DEFAULT_WEBGL: GLenum;
16424 readonly BUFFER_SIZE: GLenum;
16425 readonly BUFFER_USAGE: GLenum;
16426 readonly BYTE: GLenum;
16427 readonly CCW: GLenum;
16428 readonly CLAMP_TO_EDGE: GLenum;
16429 readonly COLOR_ATTACHMENT0: GLenum;
16430 readonly COLOR_BUFFER_BIT: GLenum;
16431 readonly COLOR_CLEAR_VALUE: GLenum;
16432 readonly COLOR_WRITEMASK: GLenum;
16433 readonly COMPILE_STATUS: GLenum;
16434 readonly COMPRESSED_TEXTURE_FORMATS: GLenum;
16435 readonly CONSTANT_ALPHA: GLenum;
16436 readonly CONSTANT_COLOR: GLenum;
16437 readonly CONTEXT_LOST_WEBGL: GLenum;
16438 readonly CULL_FACE: GLenum;
16439 readonly CULL_FACE_MODE: GLenum;
16440 readonly CURRENT_PROGRAM: GLenum;
16441 readonly CURRENT_VERTEX_ATTRIB: GLenum;
16442 readonly CW: GLenum;
16443 readonly DECR: GLenum;
16444 readonly DECR_WRAP: GLenum;
16445 readonly DELETE_STATUS: GLenum;
16446 readonly DEPTH_ATTACHMENT: GLenum;
16447 readonly DEPTH_BITS: GLenum;
16448 readonly DEPTH_BUFFER_BIT: GLenum;
16449 readonly DEPTH_CLEAR_VALUE: GLenum;
16450 readonly DEPTH_COMPONENT: GLenum;
16451 readonly DEPTH_COMPONENT16: GLenum;
16452 readonly DEPTH_FUNC: GLenum;
16453 readonly DEPTH_RANGE: GLenum;
16454 readonly DEPTH_STENCIL: GLenum;
16455 readonly DEPTH_STENCIL_ATTACHMENT: GLenum;
16456 readonly DEPTH_TEST: GLenum;
16457 readonly DEPTH_WRITEMASK: GLenum;
16458 readonly DITHER: GLenum;
16459 readonly DONT_CARE: GLenum;
16460 readonly DST_ALPHA: GLenum;
16461 readonly DST_COLOR: GLenum;
16462 readonly DYNAMIC_DRAW: GLenum;
16463 readonly ELEMENT_ARRAY_BUFFER: GLenum;
16464 readonly ELEMENT_ARRAY_BUFFER_BINDING: GLenum;
16465 readonly EQUAL: GLenum;
16466 readonly FASTEST: GLenum;
16467 readonly FLOAT: GLenum;
16468 readonly FLOAT_MAT2: GLenum;
16469 readonly FLOAT_MAT3: GLenum;
16470 readonly FLOAT_MAT4: GLenum;
16471 readonly FLOAT_VEC2: GLenum;
16472 readonly FLOAT_VEC3: GLenum;
16473 readonly FLOAT_VEC4: GLenum;
16474 readonly FRAGMENT_SHADER: GLenum;
16475 readonly FRAMEBUFFER: GLenum;
16476 readonly FRAMEBUFFER_ATTACHMENT_OBJECT_NAME: GLenum;
16477 readonly FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE: GLenum;
16478 readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE: GLenum;
16479 readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL: GLenum;
16480 readonly FRAMEBUFFER_BINDING: GLenum;
16481 readonly FRAMEBUFFER_COMPLETE: GLenum;
16482 readonly FRAMEBUFFER_INCOMPLETE_ATTACHMENT: GLenum;
16483 readonly FRAMEBUFFER_INCOMPLETE_DIMENSIONS: GLenum;
16484 readonly FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: GLenum;
16485 readonly FRAMEBUFFER_UNSUPPORTED: GLenum;
16486 readonly FRONT: GLenum;
16487 readonly FRONT_AND_BACK: GLenum;
16488 readonly FRONT_FACE: GLenum;
16489 readonly FUNC_ADD: GLenum;
16490 readonly FUNC_REVERSE_SUBTRACT: GLenum;
16491 readonly FUNC_SUBTRACT: GLenum;
16492 readonly GENERATE_MIPMAP_HINT: GLenum;
16493 readonly GEQUAL: GLenum;
16494 readonly GREATER: GLenum;
16495 readonly GREEN_BITS: GLenum;
16496 readonly HIGH_FLOAT: GLenum;
16497 readonly HIGH_INT: GLenum;
16498 readonly IMPLEMENTATION_COLOR_READ_FORMAT: GLenum;
16499 readonly IMPLEMENTATION_COLOR_READ_TYPE: GLenum;
16500 readonly INCR: GLenum;
16501 readonly INCR_WRAP: GLenum;
16502 readonly INT: GLenum;
16503 readonly INT_VEC2: GLenum;
16504 readonly INT_VEC3: GLenum;
16505 readonly INT_VEC4: GLenum;
16506 readonly INVALID_ENUM: GLenum;
16507 readonly INVALID_FRAMEBUFFER_OPERATION: GLenum;
16508 readonly INVALID_OPERATION: GLenum;
16509 readonly INVALID_VALUE: GLenum;
16510 readonly INVERT: GLenum;
16511 readonly KEEP: GLenum;
16512 readonly LEQUAL: GLenum;
16513 readonly LESS: GLenum;
16514 readonly LINEAR: GLenum;
16515 readonly LINEAR_MIPMAP_LINEAR: GLenum;
16516 readonly LINEAR_MIPMAP_NEAREST: GLenum;
16517 readonly LINES: GLenum;
16518 readonly LINE_LOOP: GLenum;
16519 readonly LINE_STRIP: GLenum;
16520 readonly LINE_WIDTH: GLenum;
16521 readonly LINK_STATUS: GLenum;
16522 readonly LOW_FLOAT: GLenum;
16523 readonly LOW_INT: GLenum;
16524 readonly LUMINANCE: GLenum;
16525 readonly LUMINANCE_ALPHA: GLenum;
16526 readonly MAX_COMBINED_TEXTURE_IMAGE_UNITS: GLenum;
16527 readonly MAX_CUBE_MAP_TEXTURE_SIZE: GLenum;
16528 readonly MAX_FRAGMENT_UNIFORM_VECTORS: GLenum;
16529 readonly MAX_RENDERBUFFER_SIZE: GLenum;
16530 readonly MAX_TEXTURE_IMAGE_UNITS: GLenum;
16531 readonly MAX_TEXTURE_SIZE: GLenum;
16532 readonly MAX_VARYING_VECTORS: GLenum;
16533 readonly MAX_VERTEX_ATTRIBS: GLenum;
16534 readonly MAX_VERTEX_TEXTURE_IMAGE_UNITS: GLenum;
16535 readonly MAX_VERTEX_UNIFORM_VECTORS: GLenum;
16536 readonly MAX_VIEWPORT_DIMS: GLenum;
16537 readonly MEDIUM_FLOAT: GLenum;
16538 readonly MEDIUM_INT: GLenum;
16539 readonly MIRRORED_REPEAT: GLenum;
16540 readonly NEAREST: GLenum;
16541 readonly NEAREST_MIPMAP_LINEAR: GLenum;
16542 readonly NEAREST_MIPMAP_NEAREST: GLenum;
16543 readonly NEVER: GLenum;
16544 readonly NICEST: GLenum;
16545 readonly NONE: GLenum;
16546 readonly NOTEQUAL: GLenum;
16547 readonly NO_ERROR: GLenum;
16548 readonly ONE: GLenum;
16549 readonly ONE_MINUS_CONSTANT_ALPHA: GLenum;
16550 readonly ONE_MINUS_CONSTANT_COLOR: GLenum;
16551 readonly ONE_MINUS_DST_ALPHA: GLenum;
16552 readonly ONE_MINUS_DST_COLOR: GLenum;
16553 readonly ONE_MINUS_SRC_ALPHA: GLenum;
16554 readonly ONE_MINUS_SRC_COLOR: GLenum;
16555 readonly OUT_OF_MEMORY: GLenum;
16556 readonly PACK_ALIGNMENT: GLenum;
16557 readonly POINTS: GLenum;
16558 readonly POLYGON_OFFSET_FACTOR: GLenum;
16559 readonly POLYGON_OFFSET_FILL: GLenum;
16560 readonly POLYGON_OFFSET_UNITS: GLenum;
16561 readonly RED_BITS: GLenum;
16562 readonly RENDERBUFFER: GLenum;
16563 readonly RENDERBUFFER_ALPHA_SIZE: GLenum;
16564 readonly RENDERBUFFER_BINDING: GLenum;
16565 readonly RENDERBUFFER_BLUE_SIZE: GLenum;
16566 readonly RENDERBUFFER_DEPTH_SIZE: GLenum;
16567 readonly RENDERBUFFER_GREEN_SIZE: GLenum;
16568 readonly RENDERBUFFER_HEIGHT: GLenum;
16569 readonly RENDERBUFFER_INTERNAL_FORMAT: GLenum;
16570 readonly RENDERBUFFER_RED_SIZE: GLenum;
16571 readonly RENDERBUFFER_STENCIL_SIZE: GLenum;
16572 readonly RENDERBUFFER_WIDTH: GLenum;
16573 readonly RENDERER: GLenum;
16574 readonly REPEAT: GLenum;
16575 readonly REPLACE: GLenum;
16576 readonly RGB: GLenum;
16577 readonly RGB565: GLenum;
16578 readonly RGB5_A1: GLenum;
16579 readonly RGBA: GLenum;
16580 readonly RGBA4: GLenum;
16581 readonly SAMPLER_2D: GLenum;
16582 readonly SAMPLER_CUBE: GLenum;
16583 readonly SAMPLES: GLenum;
16584 readonly SAMPLE_ALPHA_TO_COVERAGE: GLenum;
16585 readonly SAMPLE_BUFFERS: GLenum;
16586 readonly SAMPLE_COVERAGE: GLenum;
16587 readonly SAMPLE_COVERAGE_INVERT: GLenum;
16588 readonly SAMPLE_COVERAGE_VALUE: GLenum;
16589 readonly SCISSOR_BOX: GLenum;
16590 readonly SCISSOR_TEST: GLenum;
16591 readonly SHADER_TYPE: GLenum;
16592 readonly SHADING_LANGUAGE_VERSION: GLenum;
16593 readonly SHORT: GLenum;
16594 readonly SRC_ALPHA: GLenum;
16595 readonly SRC_ALPHA_SATURATE: GLenum;
16596 readonly SRC_COLOR: GLenum;
16597 readonly STATIC_DRAW: GLenum;
16598 readonly STENCIL_ATTACHMENT: GLenum;
16599 readonly STENCIL_BACK_FAIL: GLenum;
16600 readonly STENCIL_BACK_FUNC: GLenum;
16601 readonly STENCIL_BACK_PASS_DEPTH_FAIL: GLenum;
16602 readonly STENCIL_BACK_PASS_DEPTH_PASS: GLenum;
16603 readonly STENCIL_BACK_REF: GLenum;
16604 readonly STENCIL_BACK_VALUE_MASK: GLenum;
16605 readonly STENCIL_BACK_WRITEMASK: GLenum;
16606 readonly STENCIL_BITS: GLenum;
16607 readonly STENCIL_BUFFER_BIT: GLenum;
16608 readonly STENCIL_CLEAR_VALUE: GLenum;
16609 readonly STENCIL_FAIL: GLenum;
16610 readonly STENCIL_FUNC: GLenum;
16611 readonly STENCIL_INDEX8: GLenum;
16612 readonly STENCIL_PASS_DEPTH_FAIL: GLenum;
16613 readonly STENCIL_PASS_DEPTH_PASS: GLenum;
16614 readonly STENCIL_REF: GLenum;
16615 readonly STENCIL_TEST: GLenum;
16616 readonly STENCIL_VALUE_MASK: GLenum;
16617 readonly STENCIL_WRITEMASK: GLenum;
16618 readonly STREAM_DRAW: GLenum;
16619 readonly SUBPIXEL_BITS: GLenum;
16620 readonly TEXTURE: GLenum;
16621 readonly TEXTURE0: GLenum;
16622 readonly TEXTURE1: GLenum;
16623 readonly TEXTURE10: GLenum;
16624 readonly TEXTURE11: GLenum;
16625 readonly TEXTURE12: GLenum;
16626 readonly TEXTURE13: GLenum;
16627 readonly TEXTURE14: GLenum;
16628 readonly TEXTURE15: GLenum;
16629 readonly TEXTURE16: GLenum;
16630 readonly TEXTURE17: GLenum;
16631 readonly TEXTURE18: GLenum;
16632 readonly TEXTURE19: GLenum;
16633 readonly TEXTURE2: GLenum;
16634 readonly TEXTURE20: GLenum;
16635 readonly TEXTURE21: GLenum;
16636 readonly TEXTURE22: GLenum;
16637 readonly TEXTURE23: GLenum;
16638 readonly TEXTURE24: GLenum;
16639 readonly TEXTURE25: GLenum;
16640 readonly TEXTURE26: GLenum;
16641 readonly TEXTURE27: GLenum;
16642 readonly TEXTURE28: GLenum;
16643 readonly TEXTURE29: GLenum;
16644 readonly TEXTURE3: GLenum;
16645 readonly TEXTURE30: GLenum;
16646 readonly TEXTURE31: GLenum;
16647 readonly TEXTURE4: GLenum;
16648 readonly TEXTURE5: GLenum;
16649 readonly TEXTURE6: GLenum;
16650 readonly TEXTURE7: GLenum;
16651 readonly TEXTURE8: GLenum;
16652 readonly TEXTURE9: GLenum;
16653 readonly TEXTURE_2D: GLenum;
16654 readonly TEXTURE_BINDING_2D: GLenum;
16655 readonly TEXTURE_BINDING_CUBE_MAP: GLenum;
16656 readonly TEXTURE_CUBE_MAP: GLenum;
16657 readonly TEXTURE_CUBE_MAP_NEGATIVE_X: GLenum;
16658 readonly TEXTURE_CUBE_MAP_NEGATIVE_Y: GLenum;
16659 readonly TEXTURE_CUBE_MAP_NEGATIVE_Z: GLenum;
16660 readonly TEXTURE_CUBE_MAP_POSITIVE_X: GLenum;
16661 readonly TEXTURE_CUBE_MAP_POSITIVE_Y: GLenum;
16662 readonly TEXTURE_CUBE_MAP_POSITIVE_Z: GLenum;
16663 readonly TEXTURE_MAG_FILTER: GLenum;
16664 readonly TEXTURE_MIN_FILTER: GLenum;
16665 readonly TEXTURE_WRAP_S: GLenum;
16666 readonly TEXTURE_WRAP_T: GLenum;
16667 readonly TRIANGLES: GLenum;
16668 readonly TRIANGLE_FAN: GLenum;
16669 readonly TRIANGLE_STRIP: GLenum;
16670 readonly UNPACK_ALIGNMENT: GLenum;
16671 readonly UNPACK_COLORSPACE_CONVERSION_WEBGL: GLenum;
16672 readonly UNPACK_FLIP_Y_WEBGL: GLenum;
16673 readonly UNPACK_PREMULTIPLY_ALPHA_WEBGL: GLenum;
16674 readonly UNSIGNED_BYTE: GLenum;
16675 readonly UNSIGNED_INT: GLenum;
16676 readonly UNSIGNED_SHORT: GLenum;
16677 readonly UNSIGNED_SHORT_4_4_4_4: GLenum;
16678 readonly UNSIGNED_SHORT_5_5_5_1: GLenum;
16679 readonly UNSIGNED_SHORT_5_6_5: GLenum;
16680 readonly VALIDATE_STATUS: GLenum;
16681 readonly VENDOR: GLenum;
16682 readonly VERSION: GLenum;
16683 readonly VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: GLenum;
16684 readonly VERTEX_ATTRIB_ARRAY_ENABLED: GLenum;
16685 readonly VERTEX_ATTRIB_ARRAY_NORMALIZED: GLenum;
16686 readonly VERTEX_ATTRIB_ARRAY_POINTER: GLenum;
16687 readonly VERTEX_ATTRIB_ARRAY_SIZE: GLenum;
16688 readonly VERTEX_ATTRIB_ARRAY_STRIDE: GLenum;
16689 readonly VERTEX_ATTRIB_ARRAY_TYPE: GLenum;
16690 readonly VERTEX_SHADER: GLenum;
16691 readonly VIEWPORT: GLenum;
16692 readonly ZERO: GLenum;
16693 readonly ACTIVE_UNIFORM_BLOCKS: GLenum;
16694 readonly ALREADY_SIGNALED: GLenum;
16695 readonly ANY_SAMPLES_PASSED: GLenum;
16696 readonly ANY_SAMPLES_PASSED_CONSERVATIVE: GLenum;
16697 readonly COLOR: GLenum;
16698 readonly COLOR_ATTACHMENT1: GLenum;
16699 readonly COLOR_ATTACHMENT10: GLenum;
16700 readonly COLOR_ATTACHMENT11: GLenum;
16701 readonly COLOR_ATTACHMENT12: GLenum;
16702 readonly COLOR_ATTACHMENT13: GLenum;
16703 readonly COLOR_ATTACHMENT14: GLenum;
16704 readonly COLOR_ATTACHMENT15: GLenum;
16705 readonly COLOR_ATTACHMENT2: GLenum;
16706 readonly COLOR_ATTACHMENT3: GLenum;
16707 readonly COLOR_ATTACHMENT4: GLenum;
16708 readonly COLOR_ATTACHMENT5: GLenum;
16709 readonly COLOR_ATTACHMENT6: GLenum;
16710 readonly COLOR_ATTACHMENT7: GLenum;
16711 readonly COLOR_ATTACHMENT8: GLenum;
16712 readonly COLOR_ATTACHMENT9: GLenum;
16713 readonly COMPARE_REF_TO_TEXTURE: GLenum;
16714 readonly CONDITION_SATISFIED: GLenum;
16715 readonly COPY_READ_BUFFER: GLenum;
16716 readonly COPY_READ_BUFFER_BINDING: GLenum;
16717 readonly COPY_WRITE_BUFFER: GLenum;
16718 readonly COPY_WRITE_BUFFER_BINDING: GLenum;
16719 readonly CURRENT_QUERY: GLenum;
16720 readonly DEPTH: GLenum;
16721 readonly DEPTH24_STENCIL8: GLenum;
16722 readonly DEPTH32F_STENCIL8: GLenum;
16723 readonly DEPTH_COMPONENT24: GLenum;
16724 readonly DEPTH_COMPONENT32F: GLenum;
16725 readonly DRAW_BUFFER0: GLenum;
16726 readonly DRAW_BUFFER1: GLenum;
16727 readonly DRAW_BUFFER10: GLenum;
16728 readonly DRAW_BUFFER11: GLenum;
16729 readonly DRAW_BUFFER12: GLenum;
16730 readonly DRAW_BUFFER13: GLenum;
16731 readonly DRAW_BUFFER14: GLenum;
16732 readonly DRAW_BUFFER15: GLenum;
16733 readonly DRAW_BUFFER2: GLenum;
16734 readonly DRAW_BUFFER3: GLenum;
16735 readonly DRAW_BUFFER4: GLenum;
16736 readonly DRAW_BUFFER5: GLenum;
16737 readonly DRAW_BUFFER6: GLenum;
16738 readonly DRAW_BUFFER7: GLenum;
16739 readonly DRAW_BUFFER8: GLenum;
16740 readonly DRAW_BUFFER9: GLenum;
16741 readonly DRAW_FRAMEBUFFER: GLenum;
16742 readonly DRAW_FRAMEBUFFER_BINDING: GLenum;
16743 readonly DYNAMIC_COPY: GLenum;
16744 readonly DYNAMIC_READ: GLenum;
16745 readonly FLOAT_32_UNSIGNED_INT_24_8_REV: GLenum;
16746 readonly FLOAT_MAT2x3: GLenum;
16747 readonly FLOAT_MAT2x4: GLenum;
16748 readonly FLOAT_MAT3x2: GLenum;
16749 readonly FLOAT_MAT3x4: GLenum;
16750 readonly FLOAT_MAT4x2: GLenum;
16751 readonly FLOAT_MAT4x3: GLenum;
16752 readonly FRAGMENT_SHADER_DERIVATIVE_HINT: GLenum;
16753 readonly FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE: GLenum;
16754 readonly FRAMEBUFFER_ATTACHMENT_BLUE_SIZE: GLenum;
16755 readonly FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING: GLenum;
16756 readonly FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE: GLenum;
16757 readonly FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE: GLenum;
16758 readonly FRAMEBUFFER_ATTACHMENT_GREEN_SIZE: GLenum;
16759 readonly FRAMEBUFFER_ATTACHMENT_RED_SIZE: GLenum;
16760 readonly FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE: GLenum;
16761 readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER: GLenum;
16762 readonly FRAMEBUFFER_DEFAULT: GLenum;
16763 readonly FRAMEBUFFER_INCOMPLETE_MULTISAMPLE: GLenum;
16764 readonly HALF_FLOAT: GLenum;
16765 readonly INTERLEAVED_ATTRIBS: GLenum;
16766 readonly INT_2_10_10_10_REV: GLenum;
16767 readonly INT_SAMPLER_2D: GLenum;
16768 readonly INT_SAMPLER_2D_ARRAY: GLenum;
16769 readonly INT_SAMPLER_3D: GLenum;
16770 readonly INT_SAMPLER_CUBE: GLenum;
16771 readonly INVALID_INDEX: GLenum;
16772 readonly MAX: GLenum;
16773 readonly MAX_3D_TEXTURE_SIZE: GLenum;
16774 readonly MAX_ARRAY_TEXTURE_LAYERS: GLenum;
16775 readonly MAX_CLIENT_WAIT_TIMEOUT_WEBGL: GLenum;
16776 readonly MAX_COLOR_ATTACHMENTS: GLenum;
16777 readonly MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS: GLenum;
16778 readonly MAX_COMBINED_UNIFORM_BLOCKS: GLenum;
16779 readonly MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS: GLenum;
16780 readonly MAX_DRAW_BUFFERS: GLenum;
16781 readonly MAX_ELEMENTS_INDICES: GLenum;
16782 readonly MAX_ELEMENTS_VERTICES: GLenum;
16783 readonly MAX_ELEMENT_INDEX: GLenum;
16784 readonly MAX_FRAGMENT_INPUT_COMPONENTS: GLenum;
16785 readonly MAX_FRAGMENT_UNIFORM_BLOCKS: GLenum;
16786 readonly MAX_FRAGMENT_UNIFORM_COMPONENTS: GLenum;
16787 readonly MAX_PROGRAM_TEXEL_OFFSET: GLenum;
16788 readonly MAX_SAMPLES: GLenum;
16789 readonly MAX_SERVER_WAIT_TIMEOUT: GLenum;
16790 readonly MAX_TEXTURE_LOD_BIAS: GLenum;
16791 readonly MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS: GLenum;
16792 readonly MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS: GLenum;
16793 readonly MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS: GLenum;
16794 readonly MAX_UNIFORM_BLOCK_SIZE: GLenum;
16795 readonly MAX_UNIFORM_BUFFER_BINDINGS: GLenum;
16796 readonly MAX_VARYING_COMPONENTS: GLenum;
16797 readonly MAX_VERTEX_OUTPUT_COMPONENTS: GLenum;
16798 readonly MAX_VERTEX_UNIFORM_BLOCKS: GLenum;
16799 readonly MAX_VERTEX_UNIFORM_COMPONENTS: GLenum;
16800 readonly MIN: GLenum;
16801 readonly MIN_PROGRAM_TEXEL_OFFSET: GLenum;
16802 readonly OBJECT_TYPE: GLenum;
16803 readonly PACK_ROW_LENGTH: GLenum;
16804 readonly PACK_SKIP_PIXELS: GLenum;
16805 readonly PACK_SKIP_ROWS: GLenum;
16806 readonly PIXEL_PACK_BUFFER: GLenum;
16807 readonly PIXEL_PACK_BUFFER_BINDING: GLenum;
16808 readonly PIXEL_UNPACK_BUFFER: GLenum;
16809 readonly PIXEL_UNPACK_BUFFER_BINDING: GLenum;
16810 readonly QUERY_RESULT: GLenum;
16811 readonly QUERY_RESULT_AVAILABLE: GLenum;
16812 readonly R11F_G11F_B10F: GLenum;
16813 readonly R16F: GLenum;
16814 readonly R16I: GLenum;
16815 readonly R16UI: GLenum;
16816 readonly R32F: GLenum;
16817 readonly R32I: GLenum;
16818 readonly R32UI: GLenum;
16819 readonly R8: GLenum;
16820 readonly R8I: GLenum;
16821 readonly R8UI: GLenum;
16822 readonly R8_SNORM: GLenum;
16823 readonly RASTERIZER_DISCARD: GLenum;
16824 readonly READ_BUFFER: GLenum;
16825 readonly READ_FRAMEBUFFER: GLenum;
16826 readonly READ_FRAMEBUFFER_BINDING: GLenum;
16827 readonly RED: GLenum;
16828 readonly RED_INTEGER: GLenum;
16829 readonly RENDERBUFFER_SAMPLES: GLenum;
16830 readonly RG: GLenum;
16831 readonly RG16F: GLenum;
16832 readonly RG16I: GLenum;
16833 readonly RG16UI: GLenum;
16834 readonly RG32F: GLenum;
16835 readonly RG32I: GLenum;
16836 readonly RG32UI: GLenum;
16837 readonly RG8: GLenum;
16838 readonly RG8I: GLenum;
16839 readonly RG8UI: GLenum;
16840 readonly RG8_SNORM: GLenum;
16841 readonly RGB10_A2: GLenum;
16842 readonly RGB10_A2UI: GLenum;
16843 readonly RGB16F: GLenum;
16844 readonly RGB16I: GLenum;
16845 readonly RGB16UI: GLenum;
16846 readonly RGB32F: GLenum;
16847 readonly RGB32I: GLenum;
16848 readonly RGB32UI: GLenum;
16849 readonly RGB8: GLenum;
16850 readonly RGB8I: GLenum;
16851 readonly RGB8UI: GLenum;
16852 readonly RGB8_SNORM: GLenum;
16853 readonly RGB9_E5: GLenum;
16854 readonly RGBA16F: GLenum;
16855 readonly RGBA16I: GLenum;
16856 readonly RGBA16UI: GLenum;
16857 readonly RGBA32F: GLenum;
16858 readonly RGBA32I: GLenum;
16859 readonly RGBA32UI: GLenum;
16860 readonly RGBA8: GLenum;
16861 readonly RGBA8I: GLenum;
16862 readonly RGBA8UI: GLenum;
16863 readonly RGBA8_SNORM: GLenum;
16864 readonly RGBA_INTEGER: GLenum;
16865 readonly RGB_INTEGER: GLenum;
16866 readonly RG_INTEGER: GLenum;
16867 readonly SAMPLER_2D_ARRAY: GLenum;
16868 readonly SAMPLER_2D_ARRAY_SHADOW: GLenum;
16869 readonly SAMPLER_2D_SHADOW: GLenum;
16870 readonly SAMPLER_3D: GLenum;
16871 readonly SAMPLER_BINDING: GLenum;
16872 readonly SAMPLER_CUBE_SHADOW: GLenum;
16873 readonly SEPARATE_ATTRIBS: GLenum;
16874 readonly SIGNALED: GLenum;
16875 readonly SIGNED_NORMALIZED: GLenum;
16876 readonly SRGB: GLenum;
16877 readonly SRGB8: GLenum;
16878 readonly SRGB8_ALPHA8: GLenum;
16879 readonly STATIC_COPY: GLenum;
16880 readonly STATIC_READ: GLenum;
16881 readonly STENCIL: GLenum;
16882 readonly STREAM_COPY: GLenum;
16883 readonly STREAM_READ: GLenum;
16884 readonly SYNC_CONDITION: GLenum;
16885 readonly SYNC_FENCE: GLenum;
16886 readonly SYNC_FLAGS: GLenum;
16887 readonly SYNC_FLUSH_COMMANDS_BIT: GLenum;
16888 readonly SYNC_GPU_COMMANDS_COMPLETE: GLenum;
16889 readonly SYNC_STATUS: GLenum;
16890 readonly TEXTURE_2D_ARRAY: GLenum;
16891 readonly TEXTURE_3D: GLenum;
16892 readonly TEXTURE_BASE_LEVEL: GLenum;
16893 readonly TEXTURE_BINDING_2D_ARRAY: GLenum;
16894 readonly TEXTURE_BINDING_3D: GLenum;
16895 readonly TEXTURE_COMPARE_FUNC: GLenum;
16896 readonly TEXTURE_COMPARE_MODE: GLenum;
16897 readonly TEXTURE_IMMUTABLE_FORMAT: GLenum;
16898 readonly TEXTURE_IMMUTABLE_LEVELS: GLenum;
16899 readonly TEXTURE_MAX_LEVEL: GLenum;
16900 readonly TEXTURE_MAX_LOD: GLenum;
16901 readonly TEXTURE_MIN_LOD: GLenum;
16902 readonly TEXTURE_WRAP_R: GLenum;
16903 readonly TIMEOUT_EXPIRED: GLenum;
16904 readonly TIMEOUT_IGNORED: GLint64;
16905 readonly TRANSFORM_FEEDBACK: GLenum;
16906 readonly TRANSFORM_FEEDBACK_ACTIVE: GLenum;
16907 readonly TRANSFORM_FEEDBACK_BINDING: GLenum;
16908 readonly TRANSFORM_FEEDBACK_BUFFER: GLenum;
16909 readonly TRANSFORM_FEEDBACK_BUFFER_BINDING: GLenum;
16910 readonly TRANSFORM_FEEDBACK_BUFFER_MODE: GLenum;
16911 readonly TRANSFORM_FEEDBACK_BUFFER_SIZE: GLenum;
16912 readonly TRANSFORM_FEEDBACK_BUFFER_START: GLenum;
16913 readonly TRANSFORM_FEEDBACK_PAUSED: GLenum;
16914 readonly TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN: GLenum;
16915 readonly TRANSFORM_FEEDBACK_VARYINGS: GLenum;
16916 readonly UNIFORM_ARRAY_STRIDE: GLenum;
16917 readonly UNIFORM_BLOCK_ACTIVE_UNIFORMS: GLenum;
16918 readonly UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES: GLenum;
16919 readonly UNIFORM_BLOCK_BINDING: GLenum;
16920 readonly UNIFORM_BLOCK_DATA_SIZE: GLenum;
16921 readonly UNIFORM_BLOCK_INDEX: GLenum;
16922 readonly UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER: GLenum;
16923 readonly UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER: GLenum;
16924 readonly UNIFORM_BUFFER: GLenum;
16925 readonly UNIFORM_BUFFER_BINDING: GLenum;
16926 readonly UNIFORM_BUFFER_OFFSET_ALIGNMENT: GLenum;
16927 readonly UNIFORM_BUFFER_SIZE: GLenum;
16928 readonly UNIFORM_BUFFER_START: GLenum;
16929 readonly UNIFORM_IS_ROW_MAJOR: GLenum;
16930 readonly UNIFORM_MATRIX_STRIDE: GLenum;
16931 readonly UNIFORM_OFFSET: GLenum;
16932 readonly UNIFORM_SIZE: GLenum;
16933 readonly UNIFORM_TYPE: GLenum;
16934 readonly UNPACK_IMAGE_HEIGHT: GLenum;
16935 readonly UNPACK_ROW_LENGTH: GLenum;
16936 readonly UNPACK_SKIP_IMAGES: GLenum;
16937 readonly UNPACK_SKIP_PIXELS: GLenum;
16938 readonly UNPACK_SKIP_ROWS: GLenum;
16939 readonly UNSIGNALED: GLenum;
16940 readonly UNSIGNED_INT_10F_11F_11F_REV: GLenum;
16941 readonly UNSIGNED_INT_24_8: GLenum;
16942 readonly UNSIGNED_INT_2_10_10_10_REV: GLenum;
16943 readonly UNSIGNED_INT_5_9_9_9_REV: GLenum;
16944 readonly UNSIGNED_INT_SAMPLER_2D: GLenum;
16945 readonly UNSIGNED_INT_SAMPLER_2D_ARRAY: GLenum;
16946 readonly UNSIGNED_INT_SAMPLER_3D: GLenum;
16947 readonly UNSIGNED_INT_SAMPLER_CUBE: GLenum;
16948 readonly UNSIGNED_INT_VEC2: GLenum;
16949 readonly UNSIGNED_INT_VEC3: GLenum;
16950 readonly UNSIGNED_INT_VEC4: GLenum;
16951 readonly UNSIGNED_NORMALIZED: GLenum;
16952 readonly VERTEX_ARRAY_BINDING: GLenum;
16953 readonly VERTEX_ATTRIB_ARRAY_DIVISOR: GLenum;
16954 readonly VERTEX_ATTRIB_ARRAY_INTEGER: GLenum;
16955 readonly WAIT_FAILED: GLenum;
16958 interface WebGL2RenderingContextBase {
16959 beginQuery(target: GLenum, query: WebGLQuery): void;
16960 beginTransformFeedback(primitiveMode: GLenum): void;
16961 bindBufferBase(target: GLenum, index: GLuint, buffer: WebGLBuffer | null): void;
16962 bindBufferRange(target: GLenum, index: GLuint, buffer: WebGLBuffer | null, offset: GLintptr, size: GLsizeiptr): void;
16963 bindSampler(unit: GLuint, sampler: WebGLSampler | null): void;
16964 bindTransformFeedback(target: GLenum, tf: WebGLTransformFeedback | null): void;
16965 bindVertexArray(array: WebGLVertexArrayObject | null): void;
16966 blitFramebuffer(srcX0: GLint, srcY0: GLint, srcX1: GLint, srcY1: GLint, dstX0: GLint, dstY0: GLint, dstX1: GLint, dstY1: GLint, mask: GLbitfield, filter: GLenum): void;
16967 clearBufferfi(buffer: GLenum, drawbuffer: GLint, depth: GLfloat, stencil: GLint): void;
16968 clearBufferfv(buffer: GLenum, drawbuffer: GLint, values: Float32List, srcOffset?: GLuint): void;
16969 clearBufferiv(buffer: GLenum, drawbuffer: GLint, values: Int32List, srcOffset?: GLuint): void;
16970 clearBufferuiv(buffer: GLenum, drawbuffer: GLint, values: Uint32List, srcOffset?: GLuint): void;
16971 clientWaitSync(sync: WebGLSync, flags: GLbitfield, timeout: GLuint64): GLenum;
16972 compressedTexImage3D(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, imageSize: GLsizei, offset: GLintptr): void;
16973 compressedTexImage3D(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, srcData: ArrayBufferView, srcOffset?: GLuint, srcLengthOverride?: GLuint): void;
16974 compressedTexSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, imageSize: GLsizei, offset: GLintptr): void;
16975 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;
16976 copyBufferSubData(readTarget: GLenum, writeTarget: GLenum, readOffset: GLintptr, writeOffset: GLintptr, size: GLsizeiptr): void;
16977 copyTexSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, x: GLint, y: GLint, width: GLsizei, height: GLsizei): void;
16978 createQuery(): WebGLQuery | null;
16979 createSampler(): WebGLSampler | null;
16980 createTransformFeedback(): WebGLTransformFeedback | null;
16981 createVertexArray(): WebGLVertexArrayObject | null;
16982 deleteQuery(query: WebGLQuery | null): void;
16983 deleteSampler(sampler: WebGLSampler | null): void;
16984 deleteSync(sync: WebGLSync | null): void;
16985 deleteTransformFeedback(tf: WebGLTransformFeedback | null): void;
16986 deleteVertexArray(vertexArray: WebGLVertexArrayObject | null): void;
16987 drawArraysInstanced(mode: GLenum, first: GLint, count: GLsizei, instanceCount: GLsizei): void;
16988 drawBuffers(buffers: GLenum[]): void;
16989 drawElementsInstanced(mode: GLenum, count: GLsizei, type: GLenum, offset: GLintptr, instanceCount: GLsizei): void;
16990 drawRangeElements(mode: GLenum, start: GLuint, end: GLuint, count: GLsizei, type: GLenum, offset: GLintptr): void;
16991 endQuery(target: GLenum): void;
16992 endTransformFeedback(): void;
16993 fenceSync(condition: GLenum, flags: GLbitfield): WebGLSync | null;
16994 framebufferTextureLayer(target: GLenum, attachment: GLenum, texture: WebGLTexture | null, level: GLint, layer: GLint): void;
16995 getActiveUniformBlockName(program: WebGLProgram, uniformBlockIndex: GLuint): string | null;
16996 getActiveUniformBlockParameter(program: WebGLProgram, uniformBlockIndex: GLuint, pname: GLenum): any;
16997 getActiveUniforms(program: WebGLProgram, uniformIndices: GLuint[], pname: GLenum): any;
16998 getBufferSubData(target: GLenum, srcByteOffset: GLintptr, dstBuffer: ArrayBufferView, dstOffset?: GLuint, length?: GLuint): void;
16999 getFragDataLocation(program: WebGLProgram, name: string): GLint;
17000 getIndexedParameter(target: GLenum, index: GLuint): any;
17001 getInternalformatParameter(target: GLenum, internalformat: GLenum, pname: GLenum): any;
17002 getQuery(target: GLenum, pname: GLenum): WebGLQuery | null;
17003 getQueryParameter(query: WebGLQuery, pname: GLenum): any;
17004 getSamplerParameter(sampler: WebGLSampler, pname: GLenum): any;
17005 getSyncParameter(sync: WebGLSync, pname: GLenum): any;
17006 getTransformFeedbackVarying(program: WebGLProgram, index: GLuint): WebGLActiveInfo | null;
17007 getUniformBlockIndex(program: WebGLProgram, uniformBlockName: string): GLuint;
17008 getUniformIndices(program: WebGLProgram, uniformNames: string[]): GLuint[] | null;
17009 invalidateFramebuffer(target: GLenum, attachments: GLenum[]): void;
17010 invalidateSubFramebuffer(target: GLenum, attachments: GLenum[], x: GLint, y: GLint, width: GLsizei, height: GLsizei): void;
17011 isQuery(query: WebGLQuery | null): GLboolean;
17012 isSampler(sampler: WebGLSampler | null): GLboolean;
17013 isSync(sync: WebGLSync | null): GLboolean;
17014 isTransformFeedback(tf: WebGLTransformFeedback | null): GLboolean;
17015 isVertexArray(vertexArray: WebGLVertexArrayObject | null): GLboolean;
17016 pauseTransformFeedback(): void;
17017 readBuffer(src: GLenum): void;
17018 renderbufferStorageMultisample(target: GLenum, samples: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei): void;
17019 resumeTransformFeedback(): void;
17020 samplerParameterf(sampler: WebGLSampler, pname: GLenum, param: GLfloat): void;
17021 samplerParameteri(sampler: WebGLSampler, pname: GLenum, param: GLint): void;
17022 texImage3D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, format: GLenum, type: GLenum, pboOffset: GLintptr): void;
17023 texImage3D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, format: GLenum, type: GLenum, source: TexImageSource): void;
17024 texImage3D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, format: GLenum, type: GLenum, srcData: ArrayBufferView | null): void;
17025 texImage3D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, format: GLenum, type: GLenum, srcData: ArrayBufferView, srcOffset: GLuint): void;
17026 texStorage2D(target: GLenum, levels: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei): void;
17027 texStorage3D(target: GLenum, levels: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei): void;
17028 texSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, type: GLenum, pboOffset: GLintptr): void;
17029 texSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, type: GLenum, source: TexImageSource): void;
17030 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;
17031 transformFeedbackVaryings(program: WebGLProgram, varyings: string[], bufferMode: GLenum): void;
17032 uniform1ui(location: WebGLUniformLocation | null, v0: GLuint): void;
17033 uniform1uiv(location: WebGLUniformLocation | null, data: Uint32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17034 uniform2ui(location: WebGLUniformLocation | null, v0: GLuint, v1: GLuint): void;
17035 uniform2uiv(location: WebGLUniformLocation | null, data: Uint32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17036 uniform3ui(location: WebGLUniformLocation | null, v0: GLuint, v1: GLuint, v2: GLuint): void;
17037 uniform3uiv(location: WebGLUniformLocation | null, data: Uint32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17038 uniform4ui(location: WebGLUniformLocation | null, v0: GLuint, v1: GLuint, v2: GLuint, v3: GLuint): void;
17039 uniform4uiv(location: WebGLUniformLocation | null, data: Uint32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17040 uniformBlockBinding(program: WebGLProgram, uniformBlockIndex: GLuint, uniformBlockBinding: GLuint): void;
17041 uniformMatrix2x3fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17042 uniformMatrix2x4fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17043 uniformMatrix3x2fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17044 uniformMatrix3x4fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17045 uniformMatrix4x2fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17046 uniformMatrix4x3fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17047 vertexAttribDivisor(index: GLuint, divisor: GLuint): void;
17048 vertexAttribI4i(index: GLuint, x: GLint, y: GLint, z: GLint, w: GLint): void;
17049 vertexAttribI4iv(index: GLuint, values: Int32List): void;
17050 vertexAttribI4ui(index: GLuint, x: GLuint, y: GLuint, z: GLuint, w: GLuint): void;
17051 vertexAttribI4uiv(index: GLuint, values: Uint32List): void;
17052 vertexAttribIPointer(index: GLuint, size: GLint, type: GLenum, stride: GLsizei, offset: GLintptr): void;
17053 waitSync(sync: WebGLSync, flags: GLbitfield, timeout: GLint64): void;
17054 readonly ACTIVE_UNIFORM_BLOCKS: GLenum;
17055 readonly ALREADY_SIGNALED: GLenum;
17056 readonly ANY_SAMPLES_PASSED: GLenum;
17057 readonly ANY_SAMPLES_PASSED_CONSERVATIVE: GLenum;
17058 readonly COLOR: GLenum;
17059 readonly COLOR_ATTACHMENT1: GLenum;
17060 readonly COLOR_ATTACHMENT10: GLenum;
17061 readonly COLOR_ATTACHMENT11: GLenum;
17062 readonly COLOR_ATTACHMENT12: GLenum;
17063 readonly COLOR_ATTACHMENT13: GLenum;
17064 readonly COLOR_ATTACHMENT14: GLenum;
17065 readonly COLOR_ATTACHMENT15: GLenum;
17066 readonly COLOR_ATTACHMENT2: GLenum;
17067 readonly COLOR_ATTACHMENT3: GLenum;
17068 readonly COLOR_ATTACHMENT4: GLenum;
17069 readonly COLOR_ATTACHMENT5: GLenum;
17070 readonly COLOR_ATTACHMENT6: GLenum;
17071 readonly COLOR_ATTACHMENT7: GLenum;
17072 readonly COLOR_ATTACHMENT8: GLenum;
17073 readonly COLOR_ATTACHMENT9: GLenum;
17074 readonly COMPARE_REF_TO_TEXTURE: GLenum;
17075 readonly CONDITION_SATISFIED: GLenum;
17076 readonly COPY_READ_BUFFER: GLenum;
17077 readonly COPY_READ_BUFFER_BINDING: GLenum;
17078 readonly COPY_WRITE_BUFFER: GLenum;
17079 readonly COPY_WRITE_BUFFER_BINDING: GLenum;
17080 readonly CURRENT_QUERY: GLenum;
17081 readonly DEPTH: GLenum;
17082 readonly DEPTH24_STENCIL8: GLenum;
17083 readonly DEPTH32F_STENCIL8: GLenum;
17084 readonly DEPTH_COMPONENT24: GLenum;
17085 readonly DEPTH_COMPONENT32F: GLenum;
17086 readonly DRAW_BUFFER0: GLenum;
17087 readonly DRAW_BUFFER1: GLenum;
17088 readonly DRAW_BUFFER10: GLenum;
17089 readonly DRAW_BUFFER11: GLenum;
17090 readonly DRAW_BUFFER12: GLenum;
17091 readonly DRAW_BUFFER13: GLenum;
17092 readonly DRAW_BUFFER14: GLenum;
17093 readonly DRAW_BUFFER15: GLenum;
17094 readonly DRAW_BUFFER2: GLenum;
17095 readonly DRAW_BUFFER3: GLenum;
17096 readonly DRAW_BUFFER4: GLenum;
17097 readonly DRAW_BUFFER5: GLenum;
17098 readonly DRAW_BUFFER6: GLenum;
17099 readonly DRAW_BUFFER7: GLenum;
17100 readonly DRAW_BUFFER8: GLenum;
17101 readonly DRAW_BUFFER9: GLenum;
17102 readonly DRAW_FRAMEBUFFER: GLenum;
17103 readonly DRAW_FRAMEBUFFER_BINDING: GLenum;
17104 readonly DYNAMIC_COPY: GLenum;
17105 readonly DYNAMIC_READ: GLenum;
17106 readonly FLOAT_32_UNSIGNED_INT_24_8_REV: GLenum;
17107 readonly FLOAT_MAT2x3: GLenum;
17108 readonly FLOAT_MAT2x4: GLenum;
17109 readonly FLOAT_MAT3x2: GLenum;
17110 readonly FLOAT_MAT3x4: GLenum;
17111 readonly FLOAT_MAT4x2: GLenum;
17112 readonly FLOAT_MAT4x3: GLenum;
17113 readonly FRAGMENT_SHADER_DERIVATIVE_HINT: GLenum;
17114 readonly FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE: GLenum;
17115 readonly FRAMEBUFFER_ATTACHMENT_BLUE_SIZE: GLenum;
17116 readonly FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING: GLenum;
17117 readonly FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE: GLenum;
17118 readonly FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE: GLenum;
17119 readonly FRAMEBUFFER_ATTACHMENT_GREEN_SIZE: GLenum;
17120 readonly FRAMEBUFFER_ATTACHMENT_RED_SIZE: GLenum;
17121 readonly FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE: GLenum;
17122 readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER: GLenum;
17123 readonly FRAMEBUFFER_DEFAULT: GLenum;
17124 readonly FRAMEBUFFER_INCOMPLETE_MULTISAMPLE: GLenum;
17125 readonly HALF_FLOAT: GLenum;
17126 readonly INTERLEAVED_ATTRIBS: GLenum;
17127 readonly INT_2_10_10_10_REV: GLenum;
17128 readonly INT_SAMPLER_2D: GLenum;
17129 readonly INT_SAMPLER_2D_ARRAY: GLenum;
17130 readonly INT_SAMPLER_3D: GLenum;
17131 readonly INT_SAMPLER_CUBE: GLenum;
17132 readonly INVALID_INDEX: GLenum;
17133 readonly MAX: GLenum;
17134 readonly MAX_3D_TEXTURE_SIZE: GLenum;
17135 readonly MAX_ARRAY_TEXTURE_LAYERS: GLenum;
17136 readonly MAX_CLIENT_WAIT_TIMEOUT_WEBGL: GLenum;
17137 readonly MAX_COLOR_ATTACHMENTS: GLenum;
17138 readonly MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS: GLenum;
17139 readonly MAX_COMBINED_UNIFORM_BLOCKS: GLenum;
17140 readonly MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS: GLenum;
17141 readonly MAX_DRAW_BUFFERS: GLenum;
17142 readonly MAX_ELEMENTS_INDICES: GLenum;
17143 readonly MAX_ELEMENTS_VERTICES: GLenum;
17144 readonly MAX_ELEMENT_INDEX: GLenum;
17145 readonly MAX_FRAGMENT_INPUT_COMPONENTS: GLenum;
17146 readonly MAX_FRAGMENT_UNIFORM_BLOCKS: GLenum;
17147 readonly MAX_FRAGMENT_UNIFORM_COMPONENTS: GLenum;
17148 readonly MAX_PROGRAM_TEXEL_OFFSET: GLenum;
17149 readonly MAX_SAMPLES: GLenum;
17150 readonly MAX_SERVER_WAIT_TIMEOUT: GLenum;
17151 readonly MAX_TEXTURE_LOD_BIAS: GLenum;
17152 readonly MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS: GLenum;
17153 readonly MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS: GLenum;
17154 readonly MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS: GLenum;
17155 readonly MAX_UNIFORM_BLOCK_SIZE: GLenum;
17156 readonly MAX_UNIFORM_BUFFER_BINDINGS: GLenum;
17157 readonly MAX_VARYING_COMPONENTS: GLenum;
17158 readonly MAX_VERTEX_OUTPUT_COMPONENTS: GLenum;
17159 readonly MAX_VERTEX_UNIFORM_BLOCKS: GLenum;
17160 readonly MAX_VERTEX_UNIFORM_COMPONENTS: GLenum;
17161 readonly MIN: GLenum;
17162 readonly MIN_PROGRAM_TEXEL_OFFSET: GLenum;
17163 readonly OBJECT_TYPE: GLenum;
17164 readonly PACK_ROW_LENGTH: GLenum;
17165 readonly PACK_SKIP_PIXELS: GLenum;
17166 readonly PACK_SKIP_ROWS: GLenum;
17167 readonly PIXEL_PACK_BUFFER: GLenum;
17168 readonly PIXEL_PACK_BUFFER_BINDING: GLenum;
17169 readonly PIXEL_UNPACK_BUFFER: GLenum;
17170 readonly PIXEL_UNPACK_BUFFER_BINDING: GLenum;
17171 readonly QUERY_RESULT: GLenum;
17172 readonly QUERY_RESULT_AVAILABLE: GLenum;
17173 readonly R11F_G11F_B10F: GLenum;
17174 readonly R16F: GLenum;
17175 readonly R16I: GLenum;
17176 readonly R16UI: GLenum;
17177 readonly R32F: GLenum;
17178 readonly R32I: GLenum;
17179 readonly R32UI: GLenum;
17180 readonly R8: GLenum;
17181 readonly R8I: GLenum;
17182 readonly R8UI: GLenum;
17183 readonly R8_SNORM: GLenum;
17184 readonly RASTERIZER_DISCARD: GLenum;
17185 readonly READ_BUFFER: GLenum;
17186 readonly READ_FRAMEBUFFER: GLenum;
17187 readonly READ_FRAMEBUFFER_BINDING: GLenum;
17188 readonly RED: GLenum;
17189 readonly RED_INTEGER: GLenum;
17190 readonly RENDERBUFFER_SAMPLES: GLenum;
17191 readonly RG: GLenum;
17192 readonly RG16F: GLenum;
17193 readonly RG16I: GLenum;
17194 readonly RG16UI: GLenum;
17195 readonly RG32F: GLenum;
17196 readonly RG32I: GLenum;
17197 readonly RG32UI: GLenum;
17198 readonly RG8: GLenum;
17199 readonly RG8I: GLenum;
17200 readonly RG8UI: GLenum;
17201 readonly RG8_SNORM: GLenum;
17202 readonly RGB10_A2: GLenum;
17203 readonly RGB10_A2UI: GLenum;
17204 readonly RGB16F: GLenum;
17205 readonly RGB16I: GLenum;
17206 readonly RGB16UI: GLenum;
17207 readonly RGB32F: GLenum;
17208 readonly RGB32I: GLenum;
17209 readonly RGB32UI: GLenum;
17210 readonly RGB8: GLenum;
17211 readonly RGB8I: GLenum;
17212 readonly RGB8UI: GLenum;
17213 readonly RGB8_SNORM: GLenum;
17214 readonly RGB9_E5: GLenum;
17215 readonly RGBA16F: GLenum;
17216 readonly RGBA16I: GLenum;
17217 readonly RGBA16UI: GLenum;
17218 readonly RGBA32F: GLenum;
17219 readonly RGBA32I: GLenum;
17220 readonly RGBA32UI: GLenum;
17221 readonly RGBA8: GLenum;
17222 readonly RGBA8I: GLenum;
17223 readonly RGBA8UI: GLenum;
17224 readonly RGBA8_SNORM: GLenum;
17225 readonly RGBA_INTEGER: GLenum;
17226 readonly RGB_INTEGER: GLenum;
17227 readonly RG_INTEGER: GLenum;
17228 readonly SAMPLER_2D_ARRAY: GLenum;
17229 readonly SAMPLER_2D_ARRAY_SHADOW: GLenum;
17230 readonly SAMPLER_2D_SHADOW: GLenum;
17231 readonly SAMPLER_3D: GLenum;
17232 readonly SAMPLER_BINDING: GLenum;
17233 readonly SAMPLER_CUBE_SHADOW: GLenum;
17234 readonly SEPARATE_ATTRIBS: GLenum;
17235 readonly SIGNALED: GLenum;
17236 readonly SIGNED_NORMALIZED: GLenum;
17237 readonly SRGB: GLenum;
17238 readonly SRGB8: GLenum;
17239 readonly SRGB8_ALPHA8: GLenum;
17240 readonly STATIC_COPY: GLenum;
17241 readonly STATIC_READ: GLenum;
17242 readonly STENCIL: GLenum;
17243 readonly STREAM_COPY: GLenum;
17244 readonly STREAM_READ: GLenum;
17245 readonly SYNC_CONDITION: GLenum;
17246 readonly SYNC_FENCE: GLenum;
17247 readonly SYNC_FLAGS: GLenum;
17248 readonly SYNC_FLUSH_COMMANDS_BIT: GLenum;
17249 readonly SYNC_GPU_COMMANDS_COMPLETE: GLenum;
17250 readonly SYNC_STATUS: GLenum;
17251 readonly TEXTURE_2D_ARRAY: GLenum;
17252 readonly TEXTURE_3D: GLenum;
17253 readonly TEXTURE_BASE_LEVEL: GLenum;
17254 readonly TEXTURE_BINDING_2D_ARRAY: GLenum;
17255 readonly TEXTURE_BINDING_3D: GLenum;
17256 readonly TEXTURE_COMPARE_FUNC: GLenum;
17257 readonly TEXTURE_COMPARE_MODE: GLenum;
17258 readonly TEXTURE_IMMUTABLE_FORMAT: GLenum;
17259 readonly TEXTURE_IMMUTABLE_LEVELS: GLenum;
17260 readonly TEXTURE_MAX_LEVEL: GLenum;
17261 readonly TEXTURE_MAX_LOD: GLenum;
17262 readonly TEXTURE_MIN_LOD: GLenum;
17263 readonly TEXTURE_WRAP_R: GLenum;
17264 readonly TIMEOUT_EXPIRED: GLenum;
17265 readonly TIMEOUT_IGNORED: GLint64;
17266 readonly TRANSFORM_FEEDBACK: GLenum;
17267 readonly TRANSFORM_FEEDBACK_ACTIVE: GLenum;
17268 readonly TRANSFORM_FEEDBACK_BINDING: GLenum;
17269 readonly TRANSFORM_FEEDBACK_BUFFER: GLenum;
17270 readonly TRANSFORM_FEEDBACK_BUFFER_BINDING: GLenum;
17271 readonly TRANSFORM_FEEDBACK_BUFFER_MODE: GLenum;
17272 readonly TRANSFORM_FEEDBACK_BUFFER_SIZE: GLenum;
17273 readonly TRANSFORM_FEEDBACK_BUFFER_START: GLenum;
17274 readonly TRANSFORM_FEEDBACK_PAUSED: GLenum;
17275 readonly TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN: GLenum;
17276 readonly TRANSFORM_FEEDBACK_VARYINGS: GLenum;
17277 readonly UNIFORM_ARRAY_STRIDE: GLenum;
17278 readonly UNIFORM_BLOCK_ACTIVE_UNIFORMS: GLenum;
17279 readonly UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES: GLenum;
17280 readonly UNIFORM_BLOCK_BINDING: GLenum;
17281 readonly UNIFORM_BLOCK_DATA_SIZE: GLenum;
17282 readonly UNIFORM_BLOCK_INDEX: GLenum;
17283 readonly UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER: GLenum;
17284 readonly UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER: GLenum;
17285 readonly UNIFORM_BUFFER: GLenum;
17286 readonly UNIFORM_BUFFER_BINDING: GLenum;
17287 readonly UNIFORM_BUFFER_OFFSET_ALIGNMENT: GLenum;
17288 readonly UNIFORM_BUFFER_SIZE: GLenum;
17289 readonly UNIFORM_BUFFER_START: GLenum;
17290 readonly UNIFORM_IS_ROW_MAJOR: GLenum;
17291 readonly UNIFORM_MATRIX_STRIDE: GLenum;
17292 readonly UNIFORM_OFFSET: GLenum;
17293 readonly UNIFORM_SIZE: GLenum;
17294 readonly UNIFORM_TYPE: GLenum;
17295 readonly UNPACK_IMAGE_HEIGHT: GLenum;
17296 readonly UNPACK_ROW_LENGTH: GLenum;
17297 readonly UNPACK_SKIP_IMAGES: GLenum;
17298 readonly UNPACK_SKIP_PIXELS: GLenum;
17299 readonly UNPACK_SKIP_ROWS: GLenum;
17300 readonly UNSIGNALED: GLenum;
17301 readonly UNSIGNED_INT_10F_11F_11F_REV: GLenum;
17302 readonly UNSIGNED_INT_24_8: GLenum;
17303 readonly UNSIGNED_INT_2_10_10_10_REV: GLenum;
17304 readonly UNSIGNED_INT_5_9_9_9_REV: GLenum;
17305 readonly UNSIGNED_INT_SAMPLER_2D: GLenum;
17306 readonly UNSIGNED_INT_SAMPLER_2D_ARRAY: GLenum;
17307 readonly UNSIGNED_INT_SAMPLER_3D: GLenum;
17308 readonly UNSIGNED_INT_SAMPLER_CUBE: GLenum;
17309 readonly UNSIGNED_INT_VEC2: GLenum;
17310 readonly UNSIGNED_INT_VEC3: GLenum;
17311 readonly UNSIGNED_INT_VEC4: GLenum;
17312 readonly UNSIGNED_NORMALIZED: GLenum;
17313 readonly VERTEX_ARRAY_BINDING: GLenum;
17314 readonly VERTEX_ATTRIB_ARRAY_DIVISOR: GLenum;
17315 readonly VERTEX_ATTRIB_ARRAY_INTEGER: GLenum;
17316 readonly WAIT_FAILED: GLenum;
17319 interface WebGL2RenderingContextOverloads {
17320 bufferData(target: GLenum, size: GLsizeiptr, usage: GLenum): void;
17321 bufferData(target: GLenum, srcData: BufferSource | null, usage: GLenum): void;
17322 bufferData(target: GLenum, srcData: ArrayBufferView, usage: GLenum, srcOffset: GLuint, length?: GLuint): void;
17323 bufferSubData(target: GLenum, dstByteOffset: GLintptr, srcData: BufferSource): void;
17324 bufferSubData(target: GLenum, dstByteOffset: GLintptr, srcData: ArrayBufferView, srcOffset: GLuint, length?: GLuint): void;
17325 compressedTexImage2D(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, border: GLint, imageSize: GLsizei, offset: GLintptr): void;
17326 compressedTexImage2D(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, border: GLint, srcData: ArrayBufferView, srcOffset?: GLuint, srcLengthOverride?: GLuint): void;
17327 compressedTexSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, imageSize: GLsizei, offset: GLintptr): void;
17328 compressedTexSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, srcData: ArrayBufferView, srcOffset?: GLuint, srcLengthOverride?: GLuint): void;
17329 readPixels(x: GLint, y: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, dstData: ArrayBufferView | null): void;
17330 readPixels(x: GLint, y: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, offset: GLintptr): void;
17331 readPixels(x: GLint, y: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, dstData: ArrayBufferView, dstOffset: GLuint): void;
17332 texImage2D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, border: GLint, format: GLenum, type: GLenum, pixels: ArrayBufferView | null): void;
17333 texImage2D(target: GLenum, level: GLint, internalformat: GLint, format: GLenum, type: GLenum, source: TexImageSource): void;
17334 texImage2D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, border: GLint, format: GLenum, type: GLenum, pboOffset: GLintptr): void;
17335 texImage2D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, border: GLint, format: GLenum, type: GLenum, source: TexImageSource): void;
17336 texImage2D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, border: GLint, format: GLenum, type: GLenum, srcData: ArrayBufferView, srcOffset: GLuint): void;
17337 texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, pixels: ArrayBufferView | null): void;
17338 texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, format: GLenum, type: GLenum, source: TexImageSource): void;
17339 texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, pboOffset: GLintptr): void;
17340 texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, source: TexImageSource): void;
17341 texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, srcData: ArrayBufferView, srcOffset: GLuint): void;
17342 uniform1fv(location: WebGLUniformLocation | null, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17343 uniform1iv(location: WebGLUniformLocation | null, data: Int32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17344 uniform2fv(location: WebGLUniformLocation | null, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17345 uniform2iv(location: WebGLUniformLocation | null, data: Int32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17346 uniform3fv(location: WebGLUniformLocation | null, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17347 uniform3iv(location: WebGLUniformLocation | null, data: Int32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17348 uniform4fv(location: WebGLUniformLocation | null, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17349 uniform4iv(location: WebGLUniformLocation | null, data: Int32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17350 uniformMatrix2fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17351 uniformMatrix3fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17352 uniformMatrix4fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17355 /** Part of the WebGL API and represents the information returned by calling the WebGLRenderingContext.getActiveAttrib() and WebGLRenderingContext.getActiveUniform() methods. */
17356 interface WebGLActiveInfo {
17357 readonly name: string;
17358 readonly size: GLint;
17359 readonly type: GLenum;
17362 declare var WebGLActiveInfo: {
17363 prototype: WebGLActiveInfo;
17364 new(): WebGLActiveInfo;
17367 /** Part of the WebGL API and represents an opaque buffer object storing data such as vertices or colors. */
17368 interface WebGLBuffer extends WebGLObject {
17371 declare var WebGLBuffer: {
17372 prototype: WebGLBuffer;
17373 new(): WebGLBuffer;
17376 /** 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. */
17377 interface WebGLContextEvent extends Event {
17378 readonly statusMessage: string;
17381 declare var WebGLContextEvent: {
17382 prototype: WebGLContextEvent;
17383 new(type: string, eventInit?: WebGLContextEventInit): WebGLContextEvent;
17386 /** Part of the WebGL API and represents a collection of buffers that serve as a rendering destination. */
17387 interface WebGLFramebuffer extends WebGLObject {
17390 declare var WebGLFramebuffer: {
17391 prototype: WebGLFramebuffer;
17392 new(): WebGLFramebuffer;
17395 interface WebGLObject {
17398 declare var WebGLObject: {
17399 prototype: WebGLObject;
17400 new(): WebGLObject;
17403 /** 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). */
17404 interface WebGLProgram extends WebGLObject {
17407 declare var WebGLProgram: {
17408 prototype: WebGLProgram;
17409 new(): WebGLProgram;
17412 interface WebGLQuery extends WebGLObject {
17415 declare var WebGLQuery: {
17416 prototype: WebGLQuery;
17420 /** Part of the WebGL API and represents a buffer that can contain an image, or can be source or target of an rendering operation. */
17421 interface WebGLRenderbuffer extends WebGLObject {
17424 declare var WebGLRenderbuffer: {
17425 prototype: WebGLRenderbuffer;
17426 new(): WebGLRenderbuffer;
17429 /** Provides an interface to the OpenGL ES 2.0 graphics rendering context for the drawing surface of an HTML <canvas> element. */
17430 interface WebGLRenderingContext extends WebGLRenderingContextBase, WebGLRenderingContextOverloads {
17433 declare var WebGLRenderingContext: {
17434 prototype: WebGLRenderingContext;
17435 new(): WebGLRenderingContext;
17436 readonly ACTIVE_ATTRIBUTES: GLenum;
17437 readonly ACTIVE_TEXTURE: GLenum;
17438 readonly ACTIVE_UNIFORMS: GLenum;
17439 readonly ALIASED_LINE_WIDTH_RANGE: GLenum;
17440 readonly ALIASED_POINT_SIZE_RANGE: GLenum;
17441 readonly ALPHA: GLenum;
17442 readonly ALPHA_BITS: GLenum;
17443 readonly ALWAYS: GLenum;
17444 readonly ARRAY_BUFFER: GLenum;
17445 readonly ARRAY_BUFFER_BINDING: GLenum;
17446 readonly ATTACHED_SHADERS: GLenum;
17447 readonly BACK: GLenum;
17448 readonly BLEND: GLenum;
17449 readonly BLEND_COLOR: GLenum;
17450 readonly BLEND_DST_ALPHA: GLenum;
17451 readonly BLEND_DST_RGB: GLenum;
17452 readonly BLEND_EQUATION: GLenum;
17453 readonly BLEND_EQUATION_ALPHA: GLenum;
17454 readonly BLEND_EQUATION_RGB: GLenum;
17455 readonly BLEND_SRC_ALPHA: GLenum;
17456 readonly BLEND_SRC_RGB: GLenum;
17457 readonly BLUE_BITS: GLenum;
17458 readonly BOOL: GLenum;
17459 readonly BOOL_VEC2: GLenum;
17460 readonly BOOL_VEC3: GLenum;
17461 readonly BOOL_VEC4: GLenum;
17462 readonly BROWSER_DEFAULT_WEBGL: GLenum;
17463 readonly BUFFER_SIZE: GLenum;
17464 readonly BUFFER_USAGE: GLenum;
17465 readonly BYTE: GLenum;
17466 readonly CCW: GLenum;
17467 readonly CLAMP_TO_EDGE: GLenum;
17468 readonly COLOR_ATTACHMENT0: GLenum;
17469 readonly COLOR_BUFFER_BIT: GLenum;
17470 readonly COLOR_CLEAR_VALUE: GLenum;
17471 readonly COLOR_WRITEMASK: GLenum;
17472 readonly COMPILE_STATUS: GLenum;
17473 readonly COMPRESSED_TEXTURE_FORMATS: GLenum;
17474 readonly CONSTANT_ALPHA: GLenum;
17475 readonly CONSTANT_COLOR: GLenum;
17476 readonly CONTEXT_LOST_WEBGL: GLenum;
17477 readonly CULL_FACE: GLenum;
17478 readonly CULL_FACE_MODE: GLenum;
17479 readonly CURRENT_PROGRAM: GLenum;
17480 readonly CURRENT_VERTEX_ATTRIB: GLenum;
17481 readonly CW: GLenum;
17482 readonly DECR: GLenum;
17483 readonly DECR_WRAP: GLenum;
17484 readonly DELETE_STATUS: GLenum;
17485 readonly DEPTH_ATTACHMENT: GLenum;
17486 readonly DEPTH_BITS: GLenum;
17487 readonly DEPTH_BUFFER_BIT: GLenum;
17488 readonly DEPTH_CLEAR_VALUE: GLenum;
17489 readonly DEPTH_COMPONENT: GLenum;
17490 readonly DEPTH_COMPONENT16: GLenum;
17491 readonly DEPTH_FUNC: GLenum;
17492 readonly DEPTH_RANGE: GLenum;
17493 readonly DEPTH_STENCIL: GLenum;
17494 readonly DEPTH_STENCIL_ATTACHMENT: GLenum;
17495 readonly DEPTH_TEST: GLenum;
17496 readonly DEPTH_WRITEMASK: GLenum;
17497 readonly DITHER: GLenum;
17498 readonly DONT_CARE: GLenum;
17499 readonly DST_ALPHA: GLenum;
17500 readonly DST_COLOR: GLenum;
17501 readonly DYNAMIC_DRAW: GLenum;
17502 readonly ELEMENT_ARRAY_BUFFER: GLenum;
17503 readonly ELEMENT_ARRAY_BUFFER_BINDING: GLenum;
17504 readonly EQUAL: GLenum;
17505 readonly FASTEST: GLenum;
17506 readonly FLOAT: GLenum;
17507 readonly FLOAT_MAT2: GLenum;
17508 readonly FLOAT_MAT3: GLenum;
17509 readonly FLOAT_MAT4: GLenum;
17510 readonly FLOAT_VEC2: GLenum;
17511 readonly FLOAT_VEC3: GLenum;
17512 readonly FLOAT_VEC4: GLenum;
17513 readonly FRAGMENT_SHADER: GLenum;
17514 readonly FRAMEBUFFER: GLenum;
17515 readonly FRAMEBUFFER_ATTACHMENT_OBJECT_NAME: GLenum;
17516 readonly FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE: GLenum;
17517 readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE: GLenum;
17518 readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL: GLenum;
17519 readonly FRAMEBUFFER_BINDING: GLenum;
17520 readonly FRAMEBUFFER_COMPLETE: GLenum;
17521 readonly FRAMEBUFFER_INCOMPLETE_ATTACHMENT: GLenum;
17522 readonly FRAMEBUFFER_INCOMPLETE_DIMENSIONS: GLenum;
17523 readonly FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: GLenum;
17524 readonly FRAMEBUFFER_UNSUPPORTED: GLenum;
17525 readonly FRONT: GLenum;
17526 readonly FRONT_AND_BACK: GLenum;
17527 readonly FRONT_FACE: GLenum;
17528 readonly FUNC_ADD: GLenum;
17529 readonly FUNC_REVERSE_SUBTRACT: GLenum;
17530 readonly FUNC_SUBTRACT: GLenum;
17531 readonly GENERATE_MIPMAP_HINT: GLenum;
17532 readonly GEQUAL: GLenum;
17533 readonly GREATER: GLenum;
17534 readonly GREEN_BITS: GLenum;
17535 readonly HIGH_FLOAT: GLenum;
17536 readonly HIGH_INT: GLenum;
17537 readonly IMPLEMENTATION_COLOR_READ_FORMAT: GLenum;
17538 readonly IMPLEMENTATION_COLOR_READ_TYPE: GLenum;
17539 readonly INCR: GLenum;
17540 readonly INCR_WRAP: GLenum;
17541 readonly INT: GLenum;
17542 readonly INT_VEC2: GLenum;
17543 readonly INT_VEC3: GLenum;
17544 readonly INT_VEC4: GLenum;
17545 readonly INVALID_ENUM: GLenum;
17546 readonly INVALID_FRAMEBUFFER_OPERATION: GLenum;
17547 readonly INVALID_OPERATION: GLenum;
17548 readonly INVALID_VALUE: GLenum;
17549 readonly INVERT: GLenum;
17550 readonly KEEP: GLenum;
17551 readonly LEQUAL: GLenum;
17552 readonly LESS: GLenum;
17553 readonly LINEAR: GLenum;
17554 readonly LINEAR_MIPMAP_LINEAR: GLenum;
17555 readonly LINEAR_MIPMAP_NEAREST: GLenum;
17556 readonly LINES: GLenum;
17557 readonly LINE_LOOP: GLenum;
17558 readonly LINE_STRIP: GLenum;
17559 readonly LINE_WIDTH: GLenum;
17560 readonly LINK_STATUS: GLenum;
17561 readonly LOW_FLOAT: GLenum;
17562 readonly LOW_INT: GLenum;
17563 readonly LUMINANCE: GLenum;
17564 readonly LUMINANCE_ALPHA: GLenum;
17565 readonly MAX_COMBINED_TEXTURE_IMAGE_UNITS: GLenum;
17566 readonly MAX_CUBE_MAP_TEXTURE_SIZE: GLenum;
17567 readonly MAX_FRAGMENT_UNIFORM_VECTORS: GLenum;
17568 readonly MAX_RENDERBUFFER_SIZE: GLenum;
17569 readonly MAX_TEXTURE_IMAGE_UNITS: GLenum;
17570 readonly MAX_TEXTURE_SIZE: GLenum;
17571 readonly MAX_VARYING_VECTORS: GLenum;
17572 readonly MAX_VERTEX_ATTRIBS: GLenum;
17573 readonly MAX_VERTEX_TEXTURE_IMAGE_UNITS: GLenum;
17574 readonly MAX_VERTEX_UNIFORM_VECTORS: GLenum;
17575 readonly MAX_VIEWPORT_DIMS: GLenum;
17576 readonly MEDIUM_FLOAT: GLenum;
17577 readonly MEDIUM_INT: GLenum;
17578 readonly MIRRORED_REPEAT: GLenum;
17579 readonly NEAREST: GLenum;
17580 readonly NEAREST_MIPMAP_LINEAR: GLenum;
17581 readonly NEAREST_MIPMAP_NEAREST: GLenum;
17582 readonly NEVER: GLenum;
17583 readonly NICEST: GLenum;
17584 readonly NONE: GLenum;
17585 readonly NOTEQUAL: GLenum;
17586 readonly NO_ERROR: GLenum;
17587 readonly ONE: GLenum;
17588 readonly ONE_MINUS_CONSTANT_ALPHA: GLenum;
17589 readonly ONE_MINUS_CONSTANT_COLOR: GLenum;
17590 readonly ONE_MINUS_DST_ALPHA: GLenum;
17591 readonly ONE_MINUS_DST_COLOR: GLenum;
17592 readonly ONE_MINUS_SRC_ALPHA: GLenum;
17593 readonly ONE_MINUS_SRC_COLOR: GLenum;
17594 readonly OUT_OF_MEMORY: GLenum;
17595 readonly PACK_ALIGNMENT: GLenum;
17596 readonly POINTS: GLenum;
17597 readonly POLYGON_OFFSET_FACTOR: GLenum;
17598 readonly POLYGON_OFFSET_FILL: GLenum;
17599 readonly POLYGON_OFFSET_UNITS: GLenum;
17600 readonly RED_BITS: GLenum;
17601 readonly RENDERBUFFER: GLenum;
17602 readonly RENDERBUFFER_ALPHA_SIZE: GLenum;
17603 readonly RENDERBUFFER_BINDING: GLenum;
17604 readonly RENDERBUFFER_BLUE_SIZE: GLenum;
17605 readonly RENDERBUFFER_DEPTH_SIZE: GLenum;
17606 readonly RENDERBUFFER_GREEN_SIZE: GLenum;
17607 readonly RENDERBUFFER_HEIGHT: GLenum;
17608 readonly RENDERBUFFER_INTERNAL_FORMAT: GLenum;
17609 readonly RENDERBUFFER_RED_SIZE: GLenum;
17610 readonly RENDERBUFFER_STENCIL_SIZE: GLenum;
17611 readonly RENDERBUFFER_WIDTH: GLenum;
17612 readonly RENDERER: GLenum;
17613 readonly REPEAT: GLenum;
17614 readonly REPLACE: GLenum;
17615 readonly RGB: GLenum;
17616 readonly RGB565: GLenum;
17617 readonly RGB5_A1: GLenum;
17618 readonly RGBA: GLenum;
17619 readonly RGBA4: GLenum;
17620 readonly SAMPLER_2D: GLenum;
17621 readonly SAMPLER_CUBE: GLenum;
17622 readonly SAMPLES: GLenum;
17623 readonly SAMPLE_ALPHA_TO_COVERAGE: GLenum;
17624 readonly SAMPLE_BUFFERS: GLenum;
17625 readonly SAMPLE_COVERAGE: GLenum;
17626 readonly SAMPLE_COVERAGE_INVERT: GLenum;
17627 readonly SAMPLE_COVERAGE_VALUE: GLenum;
17628 readonly SCISSOR_BOX: GLenum;
17629 readonly SCISSOR_TEST: GLenum;
17630 readonly SHADER_TYPE: GLenum;
17631 readonly SHADING_LANGUAGE_VERSION: GLenum;
17632 readonly SHORT: GLenum;
17633 readonly SRC_ALPHA: GLenum;
17634 readonly SRC_ALPHA_SATURATE: GLenum;
17635 readonly SRC_COLOR: GLenum;
17636 readonly STATIC_DRAW: GLenum;
17637 readonly STENCIL_ATTACHMENT: GLenum;
17638 readonly STENCIL_BACK_FAIL: GLenum;
17639 readonly STENCIL_BACK_FUNC: GLenum;
17640 readonly STENCIL_BACK_PASS_DEPTH_FAIL: GLenum;
17641 readonly STENCIL_BACK_PASS_DEPTH_PASS: GLenum;
17642 readonly STENCIL_BACK_REF: GLenum;
17643 readonly STENCIL_BACK_VALUE_MASK: GLenum;
17644 readonly STENCIL_BACK_WRITEMASK: GLenum;
17645 readonly STENCIL_BITS: GLenum;
17646 readonly STENCIL_BUFFER_BIT: GLenum;
17647 readonly STENCIL_CLEAR_VALUE: GLenum;
17648 readonly STENCIL_FAIL: GLenum;
17649 readonly STENCIL_FUNC: GLenum;
17650 readonly STENCIL_INDEX8: GLenum;
17651 readonly STENCIL_PASS_DEPTH_FAIL: GLenum;
17652 readonly STENCIL_PASS_DEPTH_PASS: GLenum;
17653 readonly STENCIL_REF: GLenum;
17654 readonly STENCIL_TEST: GLenum;
17655 readonly STENCIL_VALUE_MASK: GLenum;
17656 readonly STENCIL_WRITEMASK: GLenum;
17657 readonly STREAM_DRAW: GLenum;
17658 readonly SUBPIXEL_BITS: GLenum;
17659 readonly TEXTURE: GLenum;
17660 readonly TEXTURE0: GLenum;
17661 readonly TEXTURE1: GLenum;
17662 readonly TEXTURE10: GLenum;
17663 readonly TEXTURE11: GLenum;
17664 readonly TEXTURE12: GLenum;
17665 readonly TEXTURE13: GLenum;
17666 readonly TEXTURE14: GLenum;
17667 readonly TEXTURE15: GLenum;
17668 readonly TEXTURE16: GLenum;
17669 readonly TEXTURE17: GLenum;
17670 readonly TEXTURE18: GLenum;
17671 readonly TEXTURE19: GLenum;
17672 readonly TEXTURE2: GLenum;
17673 readonly TEXTURE20: GLenum;
17674 readonly TEXTURE21: GLenum;
17675 readonly TEXTURE22: GLenum;
17676 readonly TEXTURE23: GLenum;
17677 readonly TEXTURE24: GLenum;
17678 readonly TEXTURE25: GLenum;
17679 readonly TEXTURE26: GLenum;
17680 readonly TEXTURE27: GLenum;
17681 readonly TEXTURE28: GLenum;
17682 readonly TEXTURE29: GLenum;
17683 readonly TEXTURE3: GLenum;
17684 readonly TEXTURE30: GLenum;
17685 readonly TEXTURE31: GLenum;
17686 readonly TEXTURE4: GLenum;
17687 readonly TEXTURE5: GLenum;
17688 readonly TEXTURE6: GLenum;
17689 readonly TEXTURE7: GLenum;
17690 readonly TEXTURE8: GLenum;
17691 readonly TEXTURE9: GLenum;
17692 readonly TEXTURE_2D: GLenum;
17693 readonly TEXTURE_BINDING_2D: GLenum;
17694 readonly TEXTURE_BINDING_CUBE_MAP: GLenum;
17695 readonly TEXTURE_CUBE_MAP: GLenum;
17696 readonly TEXTURE_CUBE_MAP_NEGATIVE_X: GLenum;
17697 readonly TEXTURE_CUBE_MAP_NEGATIVE_Y: GLenum;
17698 readonly TEXTURE_CUBE_MAP_NEGATIVE_Z: GLenum;
17699 readonly TEXTURE_CUBE_MAP_POSITIVE_X: GLenum;
17700 readonly TEXTURE_CUBE_MAP_POSITIVE_Y: GLenum;
17701 readonly TEXTURE_CUBE_MAP_POSITIVE_Z: GLenum;
17702 readonly TEXTURE_MAG_FILTER: GLenum;
17703 readonly TEXTURE_MIN_FILTER: GLenum;
17704 readonly TEXTURE_WRAP_S: GLenum;
17705 readonly TEXTURE_WRAP_T: GLenum;
17706 readonly TRIANGLES: GLenum;
17707 readonly TRIANGLE_FAN: GLenum;
17708 readonly TRIANGLE_STRIP: GLenum;
17709 readonly UNPACK_ALIGNMENT: GLenum;
17710 readonly UNPACK_COLORSPACE_CONVERSION_WEBGL: GLenum;
17711 readonly UNPACK_FLIP_Y_WEBGL: GLenum;
17712 readonly UNPACK_PREMULTIPLY_ALPHA_WEBGL: GLenum;
17713 readonly UNSIGNED_BYTE: GLenum;
17714 readonly UNSIGNED_INT: GLenum;
17715 readonly UNSIGNED_SHORT: GLenum;
17716 readonly UNSIGNED_SHORT_4_4_4_4: GLenum;
17717 readonly UNSIGNED_SHORT_5_5_5_1: GLenum;
17718 readonly UNSIGNED_SHORT_5_6_5: GLenum;
17719 readonly VALIDATE_STATUS: GLenum;
17720 readonly VENDOR: GLenum;
17721 readonly VERSION: GLenum;
17722 readonly VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: GLenum;
17723 readonly VERTEX_ATTRIB_ARRAY_ENABLED: GLenum;
17724 readonly VERTEX_ATTRIB_ARRAY_NORMALIZED: GLenum;
17725 readonly VERTEX_ATTRIB_ARRAY_POINTER: GLenum;
17726 readonly VERTEX_ATTRIB_ARRAY_SIZE: GLenum;
17727 readonly VERTEX_ATTRIB_ARRAY_STRIDE: GLenum;
17728 readonly VERTEX_ATTRIB_ARRAY_TYPE: GLenum;
17729 readonly VERTEX_SHADER: GLenum;
17730 readonly VIEWPORT: GLenum;
17731 readonly ZERO: GLenum;
17734 interface WebGLRenderingContextBase {
17735 readonly canvas: HTMLCanvasElement | OffscreenCanvas;
17736 readonly drawingBufferHeight: GLsizei;
17737 readonly drawingBufferWidth: GLsizei;
17738 activeTexture(texture: GLenum): void;
17739 attachShader(program: WebGLProgram, shader: WebGLShader): void;
17740 bindAttribLocation(program: WebGLProgram, index: GLuint, name: string): void;
17741 bindBuffer(target: GLenum, buffer: WebGLBuffer | null): void;
17742 bindFramebuffer(target: GLenum, framebuffer: WebGLFramebuffer | null): void;
17743 bindRenderbuffer(target: GLenum, renderbuffer: WebGLRenderbuffer | null): void;
17744 bindTexture(target: GLenum, texture: WebGLTexture | null): void;
17745 blendColor(red: GLclampf, green: GLclampf, blue: GLclampf, alpha: GLclampf): void;
17746 blendEquation(mode: GLenum): void;
17747 blendEquationSeparate(modeRGB: GLenum, modeAlpha: GLenum): void;
17748 blendFunc(sfactor: GLenum, dfactor: GLenum): void;
17749 blendFuncSeparate(srcRGB: GLenum, dstRGB: GLenum, srcAlpha: GLenum, dstAlpha: GLenum): void;
17750 checkFramebufferStatus(target: GLenum): GLenum;
17751 clear(mask: GLbitfield): void;
17752 clearColor(red: GLclampf, green: GLclampf, blue: GLclampf, alpha: GLclampf): void;
17753 clearDepth(depth: GLclampf): void;
17754 clearStencil(s: GLint): void;
17755 colorMask(red: GLboolean, green: GLboolean, blue: GLboolean, alpha: GLboolean): void;
17756 compileShader(shader: WebGLShader): void;
17757 copyTexImage2D(target: GLenum, level: GLint, internalformat: GLenum, x: GLint, y: GLint, width: GLsizei, height: GLsizei, border: GLint): void;
17758 copyTexSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, x: GLint, y: GLint, width: GLsizei, height: GLsizei): void;
17759 createBuffer(): WebGLBuffer | null;
17760 createFramebuffer(): WebGLFramebuffer | null;
17761 createProgram(): WebGLProgram | null;
17762 createRenderbuffer(): WebGLRenderbuffer | null;
17763 createShader(type: GLenum): WebGLShader | null;
17764 createTexture(): WebGLTexture | null;
17765 cullFace(mode: GLenum): void;
17766 deleteBuffer(buffer: WebGLBuffer | null): void;
17767 deleteFramebuffer(framebuffer: WebGLFramebuffer | null): void;
17768 deleteProgram(program: WebGLProgram | null): void;
17769 deleteRenderbuffer(renderbuffer: WebGLRenderbuffer | null): void;
17770 deleteShader(shader: WebGLShader | null): void;
17771 deleteTexture(texture: WebGLTexture | null): void;
17772 depthFunc(func: GLenum): void;
17773 depthMask(flag: GLboolean): void;
17774 depthRange(zNear: GLclampf, zFar: GLclampf): void;
17775 detachShader(program: WebGLProgram, shader: WebGLShader): void;
17776 disable(cap: GLenum): void;
17777 disableVertexAttribArray(index: GLuint): void;
17778 drawArrays(mode: GLenum, first: GLint, count: GLsizei): void;
17779 drawElements(mode: GLenum, count: GLsizei, type: GLenum, offset: GLintptr): void;
17780 enable(cap: GLenum): void;
17781 enableVertexAttribArray(index: GLuint): void;
17784 framebufferRenderbuffer(target: GLenum, attachment: GLenum, renderbuffertarget: GLenum, renderbuffer: WebGLRenderbuffer | null): void;
17785 framebufferTexture2D(target: GLenum, attachment: GLenum, textarget: GLenum, texture: WebGLTexture | null, level: GLint): void;
17786 frontFace(mode: GLenum): void;
17787 generateMipmap(target: GLenum): void;
17788 getActiveAttrib(program: WebGLProgram, index: GLuint): WebGLActiveInfo | null;
17789 getActiveUniform(program: WebGLProgram, index: GLuint): WebGLActiveInfo | null;
17790 getAttachedShaders(program: WebGLProgram): WebGLShader[] | null;
17791 getAttribLocation(program: WebGLProgram, name: string): GLint;
17792 getBufferParameter(target: GLenum, pname: GLenum): any;
17793 getContextAttributes(): WebGLContextAttributes | null;
17794 getError(): GLenum;
17795 getExtension(extensionName: "EXT_blend_minmax"): EXT_blend_minmax | null;
17796 getExtension(extensionName: "EXT_texture_filter_anisotropic"): EXT_texture_filter_anisotropic | null;
17797 getExtension(extensionName: "EXT_frag_depth"): EXT_frag_depth | null;
17798 getExtension(extensionName: "EXT_shader_texture_lod"): EXT_shader_texture_lod | null;
17799 getExtension(extensionName: "EXT_sRGB"): EXT_sRGB | null;
17800 getExtension(extensionName: "OES_vertex_array_object"): OES_vertex_array_object | null;
17801 getExtension(extensionName: "WEBGL_color_buffer_float"): WEBGL_color_buffer_float | null;
17802 getExtension(extensionName: "WEBGL_compressed_texture_astc"): WEBGL_compressed_texture_astc | null;
17803 getExtension(extensionName: "WEBGL_compressed_texture_s3tc_srgb"): WEBGL_compressed_texture_s3tc_srgb | null;
17804 getExtension(extensionName: "WEBGL_debug_shaders"): WEBGL_debug_shaders | null;
17805 getExtension(extensionName: "WEBGL_draw_buffers"): WEBGL_draw_buffers | null;
17806 getExtension(extensionName: "WEBGL_lose_context"): WEBGL_lose_context | null;
17807 getExtension(extensionName: "WEBGL_depth_texture"): WEBGL_depth_texture | null;
17808 getExtension(extensionName: "WEBGL_debug_renderer_info"): WEBGL_debug_renderer_info | null;
17809 getExtension(extensionName: "WEBGL_compressed_texture_s3tc"): WEBGL_compressed_texture_s3tc | null;
17810 getExtension(extensionName: "OES_texture_half_float_linear"): OES_texture_half_float_linear | null;
17811 getExtension(extensionName: "OES_texture_half_float"): OES_texture_half_float | null;
17812 getExtension(extensionName: "OES_texture_float_linear"): OES_texture_float_linear | null;
17813 getExtension(extensionName: "OES_texture_float"): OES_texture_float | null;
17814 getExtension(extensionName: "OES_standard_derivatives"): OES_standard_derivatives | null;
17815 getExtension(extensionName: "OES_element_index_uint"): OES_element_index_uint | null;
17816 getExtension(extensionName: "ANGLE_instanced_arrays"): ANGLE_instanced_arrays | null;
17817 getExtension(extensionName: string): any;
17818 getFramebufferAttachmentParameter(target: GLenum, attachment: GLenum, pname: GLenum): any;
17819 getParameter(pname: GLenum): any;
17820 getProgramInfoLog(program: WebGLProgram): string | null;
17821 getProgramParameter(program: WebGLProgram, pname: GLenum): any;
17822 getRenderbufferParameter(target: GLenum, pname: GLenum): any;
17823 getShaderInfoLog(shader: WebGLShader): string | null;
17824 getShaderParameter(shader: WebGLShader, pname: GLenum): any;
17825 getShaderPrecisionFormat(shadertype: GLenum, precisiontype: GLenum): WebGLShaderPrecisionFormat | null;
17826 getShaderSource(shader: WebGLShader): string | null;
17827 getSupportedExtensions(): string[] | null;
17828 getTexParameter(target: GLenum, pname: GLenum): any;
17829 getUniform(program: WebGLProgram, location: WebGLUniformLocation): any;
17830 getUniformLocation(program: WebGLProgram, name: string): WebGLUniformLocation | null;
17831 getVertexAttrib(index: GLuint, pname: GLenum): any;
17832 getVertexAttribOffset(index: GLuint, pname: GLenum): GLintptr;
17833 hint(target: GLenum, mode: GLenum): void;
17834 isBuffer(buffer: WebGLBuffer | null): GLboolean;
17835 isContextLost(): boolean;
17836 isEnabled(cap: GLenum): GLboolean;
17837 isFramebuffer(framebuffer: WebGLFramebuffer | null): GLboolean;
17838 isProgram(program: WebGLProgram | null): GLboolean;
17839 isRenderbuffer(renderbuffer: WebGLRenderbuffer | null): GLboolean;
17840 isShader(shader: WebGLShader | null): GLboolean;
17841 isTexture(texture: WebGLTexture | null): GLboolean;
17842 lineWidth(width: GLfloat): void;
17843 linkProgram(program: WebGLProgram): void;
17844 pixelStorei(pname: GLenum, param: GLint | GLboolean): void;
17845 polygonOffset(factor: GLfloat, units: GLfloat): void;
17846 renderbufferStorage(target: GLenum, internalformat: GLenum, width: GLsizei, height: GLsizei): void;
17847 sampleCoverage(value: GLclampf, invert: GLboolean): void;
17848 scissor(x: GLint, y: GLint, width: GLsizei, height: GLsizei): void;
17849 shaderSource(shader: WebGLShader, source: string): void;
17850 stencilFunc(func: GLenum, ref: GLint, mask: GLuint): void;
17851 stencilFuncSeparate(face: GLenum, func: GLenum, ref: GLint, mask: GLuint): void;
17852 stencilMask(mask: GLuint): void;
17853 stencilMaskSeparate(face: GLenum, mask: GLuint): void;
17854 stencilOp(fail: GLenum, zfail: GLenum, zpass: GLenum): void;
17855 stencilOpSeparate(face: GLenum, fail: GLenum, zfail: GLenum, zpass: GLenum): void;
17856 texParameterf(target: GLenum, pname: GLenum, param: GLfloat): void;
17857 texParameteri(target: GLenum, pname: GLenum, param: GLint): void;
17858 uniform1f(location: WebGLUniformLocation | null, x: GLfloat): void;
17859 uniform1i(location: WebGLUniformLocation | null, x: GLint): void;
17860 uniform2f(location: WebGLUniformLocation | null, x: GLfloat, y: GLfloat): void;
17861 uniform2i(location: WebGLUniformLocation | null, x: GLint, y: GLint): void;
17862 uniform3f(location: WebGLUniformLocation | null, x: GLfloat, y: GLfloat, z: GLfloat): void;
17863 uniform3i(location: WebGLUniformLocation | null, x: GLint, y: GLint, z: GLint): void;
17864 uniform4f(location: WebGLUniformLocation | null, x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat): void;
17865 uniform4i(location: WebGLUniformLocation | null, x: GLint, y: GLint, z: GLint, w: GLint): void;
17866 useProgram(program: WebGLProgram | null): void;
17867 validateProgram(program: WebGLProgram): void;
17868 vertexAttrib1f(index: GLuint, x: GLfloat): void;
17869 vertexAttrib1fv(index: GLuint, values: Float32List): void;
17870 vertexAttrib2f(index: GLuint, x: GLfloat, y: GLfloat): void;
17871 vertexAttrib2fv(index: GLuint, values: Float32List): void;
17872 vertexAttrib3f(index: GLuint, x: GLfloat, y: GLfloat, z: GLfloat): void;
17873 vertexAttrib3fv(index: GLuint, values: Float32List): void;
17874 vertexAttrib4f(index: GLuint, x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat): void;
17875 vertexAttrib4fv(index: GLuint, values: Float32List): void;
17876 vertexAttribPointer(index: GLuint, size: GLint, type: GLenum, normalized: GLboolean, stride: GLsizei, offset: GLintptr): void;
17877 viewport(x: GLint, y: GLint, width: GLsizei, height: GLsizei): void;
17878 readonly ACTIVE_ATTRIBUTES: GLenum;
17879 readonly ACTIVE_TEXTURE: GLenum;
17880 readonly ACTIVE_UNIFORMS: GLenum;
17881 readonly ALIASED_LINE_WIDTH_RANGE: GLenum;
17882 readonly ALIASED_POINT_SIZE_RANGE: GLenum;
17883 readonly ALPHA: GLenum;
17884 readonly ALPHA_BITS: GLenum;
17885 readonly ALWAYS: GLenum;
17886 readonly ARRAY_BUFFER: GLenum;
17887 readonly ARRAY_BUFFER_BINDING: GLenum;
17888 readonly ATTACHED_SHADERS: GLenum;
17889 readonly BACK: GLenum;
17890 readonly BLEND: GLenum;
17891 readonly BLEND_COLOR: GLenum;
17892 readonly BLEND_DST_ALPHA: GLenum;
17893 readonly BLEND_DST_RGB: GLenum;
17894 readonly BLEND_EQUATION: GLenum;
17895 readonly BLEND_EQUATION_ALPHA: GLenum;
17896 readonly BLEND_EQUATION_RGB: GLenum;
17897 readonly BLEND_SRC_ALPHA: GLenum;
17898 readonly BLEND_SRC_RGB: GLenum;
17899 readonly BLUE_BITS: GLenum;
17900 readonly BOOL: GLenum;
17901 readonly BOOL_VEC2: GLenum;
17902 readonly BOOL_VEC3: GLenum;
17903 readonly BOOL_VEC4: GLenum;
17904 readonly BROWSER_DEFAULT_WEBGL: GLenum;
17905 readonly BUFFER_SIZE: GLenum;
17906 readonly BUFFER_USAGE: GLenum;
17907 readonly BYTE: GLenum;
17908 readonly CCW: GLenum;
17909 readonly CLAMP_TO_EDGE: GLenum;
17910 readonly COLOR_ATTACHMENT0: GLenum;
17911 readonly COLOR_BUFFER_BIT: GLenum;
17912 readonly COLOR_CLEAR_VALUE: GLenum;
17913 readonly COLOR_WRITEMASK: GLenum;
17914 readonly COMPILE_STATUS: GLenum;
17915 readonly COMPRESSED_TEXTURE_FORMATS: GLenum;
17916 readonly CONSTANT_ALPHA: GLenum;
17917 readonly CONSTANT_COLOR: GLenum;
17918 readonly CONTEXT_LOST_WEBGL: GLenum;
17919 readonly CULL_FACE: GLenum;
17920 readonly CULL_FACE_MODE: GLenum;
17921 readonly CURRENT_PROGRAM: GLenum;
17922 readonly CURRENT_VERTEX_ATTRIB: GLenum;
17923 readonly CW: GLenum;
17924 readonly DECR: GLenum;
17925 readonly DECR_WRAP: GLenum;
17926 readonly DELETE_STATUS: GLenum;
17927 readonly DEPTH_ATTACHMENT: GLenum;
17928 readonly DEPTH_BITS: GLenum;
17929 readonly DEPTH_BUFFER_BIT: GLenum;
17930 readonly DEPTH_CLEAR_VALUE: GLenum;
17931 readonly DEPTH_COMPONENT: GLenum;
17932 readonly DEPTH_COMPONENT16: GLenum;
17933 readonly DEPTH_FUNC: GLenum;
17934 readonly DEPTH_RANGE: GLenum;
17935 readonly DEPTH_STENCIL: GLenum;
17936 readonly DEPTH_STENCIL_ATTACHMENT: GLenum;
17937 readonly DEPTH_TEST: GLenum;
17938 readonly DEPTH_WRITEMASK: GLenum;
17939 readonly DITHER: GLenum;
17940 readonly DONT_CARE: GLenum;
17941 readonly DST_ALPHA: GLenum;
17942 readonly DST_COLOR: GLenum;
17943 readonly DYNAMIC_DRAW: GLenum;
17944 readonly ELEMENT_ARRAY_BUFFER: GLenum;
17945 readonly ELEMENT_ARRAY_BUFFER_BINDING: GLenum;
17946 readonly EQUAL: GLenum;
17947 readonly FASTEST: GLenum;
17948 readonly FLOAT: GLenum;
17949 readonly FLOAT_MAT2: GLenum;
17950 readonly FLOAT_MAT3: GLenum;
17951 readonly FLOAT_MAT4: GLenum;
17952 readonly FLOAT_VEC2: GLenum;
17953 readonly FLOAT_VEC3: GLenum;
17954 readonly FLOAT_VEC4: GLenum;
17955 readonly FRAGMENT_SHADER: GLenum;
17956 readonly FRAMEBUFFER: GLenum;
17957 readonly FRAMEBUFFER_ATTACHMENT_OBJECT_NAME: GLenum;
17958 readonly FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE: GLenum;
17959 readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE: GLenum;
17960 readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL: GLenum;
17961 readonly FRAMEBUFFER_BINDING: GLenum;
17962 readonly FRAMEBUFFER_COMPLETE: GLenum;
17963 readonly FRAMEBUFFER_INCOMPLETE_ATTACHMENT: GLenum;
17964 readonly FRAMEBUFFER_INCOMPLETE_DIMENSIONS: GLenum;
17965 readonly FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: GLenum;
17966 readonly FRAMEBUFFER_UNSUPPORTED: GLenum;
17967 readonly FRONT: GLenum;
17968 readonly FRONT_AND_BACK: GLenum;
17969 readonly FRONT_FACE: GLenum;
17970 readonly FUNC_ADD: GLenum;
17971 readonly FUNC_REVERSE_SUBTRACT: GLenum;
17972 readonly FUNC_SUBTRACT: GLenum;
17973 readonly GENERATE_MIPMAP_HINT: GLenum;
17974 readonly GEQUAL: GLenum;
17975 readonly GREATER: GLenum;
17976 readonly GREEN_BITS: GLenum;
17977 readonly HIGH_FLOAT: GLenum;
17978 readonly HIGH_INT: GLenum;
17979 readonly IMPLEMENTATION_COLOR_READ_FORMAT: GLenum;
17980 readonly IMPLEMENTATION_COLOR_READ_TYPE: GLenum;
17981 readonly INCR: GLenum;
17982 readonly INCR_WRAP: GLenum;
17983 readonly INT: GLenum;
17984 readonly INT_VEC2: GLenum;
17985 readonly INT_VEC3: GLenum;
17986 readonly INT_VEC4: GLenum;
17987 readonly INVALID_ENUM: GLenum;
17988 readonly INVALID_FRAMEBUFFER_OPERATION: GLenum;
17989 readonly INVALID_OPERATION: GLenum;
17990 readonly INVALID_VALUE: GLenum;
17991 readonly INVERT: GLenum;
17992 readonly KEEP: GLenum;
17993 readonly LEQUAL: GLenum;
17994 readonly LESS: GLenum;
17995 readonly LINEAR: GLenum;
17996 readonly LINEAR_MIPMAP_LINEAR: GLenum;
17997 readonly LINEAR_MIPMAP_NEAREST: GLenum;
17998 readonly LINES: GLenum;
17999 readonly LINE_LOOP: GLenum;
18000 readonly LINE_STRIP: GLenum;
18001 readonly LINE_WIDTH: GLenum;
18002 readonly LINK_STATUS: GLenum;
18003 readonly LOW_FLOAT: GLenum;
18004 readonly LOW_INT: GLenum;
18005 readonly LUMINANCE: GLenum;
18006 readonly LUMINANCE_ALPHA: GLenum;
18007 readonly MAX_COMBINED_TEXTURE_IMAGE_UNITS: GLenum;
18008 readonly MAX_CUBE_MAP_TEXTURE_SIZE: GLenum;
18009 readonly MAX_FRAGMENT_UNIFORM_VECTORS: GLenum;
18010 readonly MAX_RENDERBUFFER_SIZE: GLenum;
18011 readonly MAX_TEXTURE_IMAGE_UNITS: GLenum;
18012 readonly MAX_TEXTURE_SIZE: GLenum;
18013 readonly MAX_VARYING_VECTORS: GLenum;
18014 readonly MAX_VERTEX_ATTRIBS: GLenum;
18015 readonly MAX_VERTEX_TEXTURE_IMAGE_UNITS: GLenum;
18016 readonly MAX_VERTEX_UNIFORM_VECTORS: GLenum;
18017 readonly MAX_VIEWPORT_DIMS: GLenum;
18018 readonly MEDIUM_FLOAT: GLenum;
18019 readonly MEDIUM_INT: GLenum;
18020 readonly MIRRORED_REPEAT: GLenum;
18021 readonly NEAREST: GLenum;
18022 readonly NEAREST_MIPMAP_LINEAR: GLenum;
18023 readonly NEAREST_MIPMAP_NEAREST: GLenum;
18024 readonly NEVER: GLenum;
18025 readonly NICEST: GLenum;
18026 readonly NONE: GLenum;
18027 readonly NOTEQUAL: GLenum;
18028 readonly NO_ERROR: GLenum;
18029 readonly ONE: GLenum;
18030 readonly ONE_MINUS_CONSTANT_ALPHA: GLenum;
18031 readonly ONE_MINUS_CONSTANT_COLOR: GLenum;
18032 readonly ONE_MINUS_DST_ALPHA: GLenum;
18033 readonly ONE_MINUS_DST_COLOR: GLenum;
18034 readonly ONE_MINUS_SRC_ALPHA: GLenum;
18035 readonly ONE_MINUS_SRC_COLOR: GLenum;
18036 readonly OUT_OF_MEMORY: GLenum;
18037 readonly PACK_ALIGNMENT: GLenum;
18038 readonly POINTS: GLenum;
18039 readonly POLYGON_OFFSET_FACTOR: GLenum;
18040 readonly POLYGON_OFFSET_FILL: GLenum;
18041 readonly POLYGON_OFFSET_UNITS: GLenum;
18042 readonly RED_BITS: GLenum;
18043 readonly RENDERBUFFER: GLenum;
18044 readonly RENDERBUFFER_ALPHA_SIZE: GLenum;
18045 readonly RENDERBUFFER_BINDING: GLenum;
18046 readonly RENDERBUFFER_BLUE_SIZE: GLenum;
18047 readonly RENDERBUFFER_DEPTH_SIZE: GLenum;
18048 readonly RENDERBUFFER_GREEN_SIZE: GLenum;
18049 readonly RENDERBUFFER_HEIGHT: GLenum;
18050 readonly RENDERBUFFER_INTERNAL_FORMAT: GLenum;
18051 readonly RENDERBUFFER_RED_SIZE: GLenum;
18052 readonly RENDERBUFFER_STENCIL_SIZE: GLenum;
18053 readonly RENDERBUFFER_WIDTH: GLenum;
18054 readonly RENDERER: GLenum;
18055 readonly REPEAT: GLenum;
18056 readonly REPLACE: GLenum;
18057 readonly RGB: GLenum;
18058 readonly RGB565: GLenum;
18059 readonly RGB5_A1: GLenum;
18060 readonly RGBA: GLenum;
18061 readonly RGBA4: GLenum;
18062 readonly SAMPLER_2D: GLenum;
18063 readonly SAMPLER_CUBE: GLenum;
18064 readonly SAMPLES: GLenum;
18065 readonly SAMPLE_ALPHA_TO_COVERAGE: GLenum;
18066 readonly SAMPLE_BUFFERS: GLenum;
18067 readonly SAMPLE_COVERAGE: GLenum;
18068 readonly SAMPLE_COVERAGE_INVERT: GLenum;
18069 readonly SAMPLE_COVERAGE_VALUE: GLenum;
18070 readonly SCISSOR_BOX: GLenum;
18071 readonly SCISSOR_TEST: GLenum;
18072 readonly SHADER_TYPE: GLenum;
18073 readonly SHADING_LANGUAGE_VERSION: GLenum;
18074 readonly SHORT: GLenum;
18075 readonly SRC_ALPHA: GLenum;
18076 readonly SRC_ALPHA_SATURATE: GLenum;
18077 readonly SRC_COLOR: GLenum;
18078 readonly STATIC_DRAW: GLenum;
18079 readonly STENCIL_ATTACHMENT: GLenum;
18080 readonly STENCIL_BACK_FAIL: GLenum;
18081 readonly STENCIL_BACK_FUNC: GLenum;
18082 readonly STENCIL_BACK_PASS_DEPTH_FAIL: GLenum;
18083 readonly STENCIL_BACK_PASS_DEPTH_PASS: GLenum;
18084 readonly STENCIL_BACK_REF: GLenum;
18085 readonly STENCIL_BACK_VALUE_MASK: GLenum;
18086 readonly STENCIL_BACK_WRITEMASK: GLenum;
18087 readonly STENCIL_BITS: GLenum;
18088 readonly STENCIL_BUFFER_BIT: GLenum;
18089 readonly STENCIL_CLEAR_VALUE: GLenum;
18090 readonly STENCIL_FAIL: GLenum;
18091 readonly STENCIL_FUNC: GLenum;
18092 readonly STENCIL_INDEX8: GLenum;
18093 readonly STENCIL_PASS_DEPTH_FAIL: GLenum;
18094 readonly STENCIL_PASS_DEPTH_PASS: GLenum;
18095 readonly STENCIL_REF: GLenum;
18096 readonly STENCIL_TEST: GLenum;
18097 readonly STENCIL_VALUE_MASK: GLenum;
18098 readonly STENCIL_WRITEMASK: GLenum;
18099 readonly STREAM_DRAW: GLenum;
18100 readonly SUBPIXEL_BITS: GLenum;
18101 readonly TEXTURE: GLenum;
18102 readonly TEXTURE0: GLenum;
18103 readonly TEXTURE1: GLenum;
18104 readonly TEXTURE10: GLenum;
18105 readonly TEXTURE11: GLenum;
18106 readonly TEXTURE12: GLenum;
18107 readonly TEXTURE13: GLenum;
18108 readonly TEXTURE14: GLenum;
18109 readonly TEXTURE15: GLenum;
18110 readonly TEXTURE16: GLenum;
18111 readonly TEXTURE17: GLenum;
18112 readonly TEXTURE18: GLenum;
18113 readonly TEXTURE19: GLenum;
18114 readonly TEXTURE2: GLenum;
18115 readonly TEXTURE20: GLenum;
18116 readonly TEXTURE21: GLenum;
18117 readonly TEXTURE22: GLenum;
18118 readonly TEXTURE23: GLenum;
18119 readonly TEXTURE24: GLenum;
18120 readonly TEXTURE25: GLenum;
18121 readonly TEXTURE26: GLenum;
18122 readonly TEXTURE27: GLenum;
18123 readonly TEXTURE28: GLenum;
18124 readonly TEXTURE29: GLenum;
18125 readonly TEXTURE3: GLenum;
18126 readonly TEXTURE30: GLenum;
18127 readonly TEXTURE31: GLenum;
18128 readonly TEXTURE4: GLenum;
18129 readonly TEXTURE5: GLenum;
18130 readonly TEXTURE6: GLenum;
18131 readonly TEXTURE7: GLenum;
18132 readonly TEXTURE8: GLenum;
18133 readonly TEXTURE9: GLenum;
18134 readonly TEXTURE_2D: GLenum;
18135 readonly TEXTURE_BINDING_2D: GLenum;
18136 readonly TEXTURE_BINDING_CUBE_MAP: GLenum;
18137 readonly TEXTURE_CUBE_MAP: GLenum;
18138 readonly TEXTURE_CUBE_MAP_NEGATIVE_X: GLenum;
18139 readonly TEXTURE_CUBE_MAP_NEGATIVE_Y: GLenum;
18140 readonly TEXTURE_CUBE_MAP_NEGATIVE_Z: GLenum;
18141 readonly TEXTURE_CUBE_MAP_POSITIVE_X: GLenum;
18142 readonly TEXTURE_CUBE_MAP_POSITIVE_Y: GLenum;
18143 readonly TEXTURE_CUBE_MAP_POSITIVE_Z: GLenum;
18144 readonly TEXTURE_MAG_FILTER: GLenum;
18145 readonly TEXTURE_MIN_FILTER: GLenum;
18146 readonly TEXTURE_WRAP_S: GLenum;
18147 readonly TEXTURE_WRAP_T: GLenum;
18148 readonly TRIANGLES: GLenum;
18149 readonly TRIANGLE_FAN: GLenum;
18150 readonly TRIANGLE_STRIP: GLenum;
18151 readonly UNPACK_ALIGNMENT: GLenum;
18152 readonly UNPACK_COLORSPACE_CONVERSION_WEBGL: GLenum;
18153 readonly UNPACK_FLIP_Y_WEBGL: GLenum;
18154 readonly UNPACK_PREMULTIPLY_ALPHA_WEBGL: GLenum;
18155 readonly UNSIGNED_BYTE: GLenum;
18156 readonly UNSIGNED_INT: GLenum;
18157 readonly UNSIGNED_SHORT: GLenum;
18158 readonly UNSIGNED_SHORT_4_4_4_4: GLenum;
18159 readonly UNSIGNED_SHORT_5_5_5_1: GLenum;
18160 readonly UNSIGNED_SHORT_5_6_5: GLenum;
18161 readonly VALIDATE_STATUS: GLenum;
18162 readonly VENDOR: GLenum;
18163 readonly VERSION: GLenum;
18164 readonly VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: GLenum;
18165 readonly VERTEX_ATTRIB_ARRAY_ENABLED: GLenum;
18166 readonly VERTEX_ATTRIB_ARRAY_NORMALIZED: GLenum;
18167 readonly VERTEX_ATTRIB_ARRAY_POINTER: GLenum;
18168 readonly VERTEX_ATTRIB_ARRAY_SIZE: GLenum;
18169 readonly VERTEX_ATTRIB_ARRAY_STRIDE: GLenum;
18170 readonly VERTEX_ATTRIB_ARRAY_TYPE: GLenum;
18171 readonly VERTEX_SHADER: GLenum;
18172 readonly VIEWPORT: GLenum;
18173 readonly ZERO: GLenum;
18176 interface WebGLRenderingContextOverloads {
18177 bufferData(target: GLenum, size: GLsizeiptr, usage: GLenum): void;
18178 bufferData(target: GLenum, data: BufferSource | null, usage: GLenum): void;
18179 bufferSubData(target: GLenum, offset: GLintptr, data: BufferSource): void;
18180 compressedTexImage2D(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, border: GLint, data: ArrayBufferView): void;
18181 compressedTexSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, data: ArrayBufferView): void;
18182 readPixels(x: GLint, y: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, pixels: ArrayBufferView | null): void;
18183 texImage2D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, border: GLint, format: GLenum, type: GLenum, pixels: ArrayBufferView | null): void;
18184 texImage2D(target: GLenum, level: GLint, internalformat: GLint, format: GLenum, type: GLenum, source: TexImageSource): void;
18185 texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, pixels: ArrayBufferView | null): void;
18186 texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, format: GLenum, type: GLenum, source: TexImageSource): void;
18187 uniform1fv(location: WebGLUniformLocation | null, v: Float32List): void;
18188 uniform1iv(location: WebGLUniformLocation | null, v: Int32List): void;
18189 uniform2fv(location: WebGLUniformLocation | null, v: Float32List): void;
18190 uniform2iv(location: WebGLUniformLocation | null, v: Int32List): void;
18191 uniform3fv(location: WebGLUniformLocation | null, v: Float32List): void;
18192 uniform3iv(location: WebGLUniformLocation | null, v: Int32List): void;
18193 uniform4fv(location: WebGLUniformLocation | null, v: Float32List): void;
18194 uniform4iv(location: WebGLUniformLocation | null, v: Int32List): void;
18195 uniformMatrix2fv(location: WebGLUniformLocation | null, transpose: GLboolean, value: Float32List): void;
18196 uniformMatrix3fv(location: WebGLUniformLocation | null, transpose: GLboolean, value: Float32List): void;
18197 uniformMatrix4fv(location: WebGLUniformLocation | null, transpose: GLboolean, value: Float32List): void;
18200 interface WebGLSampler extends WebGLObject {
18203 declare var WebGLSampler: {
18204 prototype: WebGLSampler;
18205 new(): WebGLSampler;
18208 /** 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. */
18209 interface WebGLShader extends WebGLObject {
18212 declare var WebGLShader: {
18213 prototype: WebGLShader;
18214 new(): WebGLShader;
18217 /** Part of the WebGL API and represents the information returned by calling the WebGLRenderingContext.getShaderPrecisionFormat() method. */
18218 interface WebGLShaderPrecisionFormat {
18219 readonly precision: GLint;
18220 readonly rangeMax: GLint;
18221 readonly rangeMin: GLint;
18224 declare var WebGLShaderPrecisionFormat: {
18225 prototype: WebGLShaderPrecisionFormat;
18226 new(): WebGLShaderPrecisionFormat;
18229 interface WebGLSync extends WebGLObject {
18232 declare var WebGLSync: {
18233 prototype: WebGLSync;
18237 /** Part of the WebGL API and represents an opaque texture object providing storage and state for texturing operations. */
18238 interface WebGLTexture extends WebGLObject {
18241 declare var WebGLTexture: {
18242 prototype: WebGLTexture;
18243 new(): WebGLTexture;
18246 interface WebGLTransformFeedback extends WebGLObject {
18249 declare var WebGLTransformFeedback: {
18250 prototype: WebGLTransformFeedback;
18251 new(): WebGLTransformFeedback;
18254 /** Part of the WebGL API and represents the location of a uniform variable in a shader program. */
18255 interface WebGLUniformLocation {
18258 declare var WebGLUniformLocation: {
18259 prototype: WebGLUniformLocation;
18260 new(): WebGLUniformLocation;
18263 interface WebGLVertexArrayObject extends WebGLObject {
18266 declare var WebGLVertexArrayObject: {
18267 prototype: WebGLVertexArrayObject;
18268 new(): WebGLVertexArrayObject;
18271 interface WebGLVertexArrayObjectOES extends WebGLObject {
18274 interface WebKitPoint {
18279 declare var WebKitPoint: {
18280 prototype: WebKitPoint;
18281 new(x?: number, y?: number): WebKitPoint;
18284 interface WebSocketEventMap {
18285 "close": CloseEvent;
18287 "message": MessageEvent;
18291 /** Provides the API for creating and managing a WebSocket connection to a server, as well as for sending and receiving data on the connection. */
18292 interface WebSocket extends EventTarget {
18294 * Returns a string that indicates how binary data from the WebSocket object is exposed to scripts:
18296 * Can be set, to change how binary data is returned. The default is "blob".
18298 binaryType: BinaryType;
18300 * 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.
18302 * 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.)
18304 readonly bufferedAmount: number;
18306 * Returns the extensions selected by the server, if any.
18308 readonly extensions: string;
18309 onclose: ((this: WebSocket, ev: CloseEvent) => any) | null;
18310 onerror: ((this: WebSocket, ev: Event) => any) | null;
18311 onmessage: ((this: WebSocket, ev: MessageEvent) => any) | null;
18312 onopen: ((this: WebSocket, ev: Event) => any) | null;
18314 * 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.
18316 readonly protocol: string;
18318 * Returns the state of the WebSocket object's connection. It can have the values described below.
18320 readonly readyState: number;
18322 * Returns the URL that was used to establish the WebSocket connection.
18324 readonly url: string;
18326 * Closes the WebSocket connection, optionally using code as the the WebSocket connection close code and reason as the the WebSocket connection close reason.
18328 close(code?: number, reason?: string): void;
18330 * Transmits data using the WebSocket connection. data can be a string, a Blob, an ArrayBuffer, or an ArrayBufferView.
18332 send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void;
18333 readonly CLOSED: number;
18334 readonly CLOSING: number;
18335 readonly CONNECTING: number;
18336 readonly OPEN: number;
18337 addEventListener<K extends keyof WebSocketEventMap>(type: K, listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
18338 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
18339 removeEventListener<K extends keyof WebSocketEventMap>(type: K, listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
18340 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
18343 declare var WebSocket: {
18344 prototype: WebSocket;
18345 new(url: string, protocols?: string | string[]): WebSocket;
18346 readonly CLOSED: number;
18347 readonly CLOSING: number;
18348 readonly CONNECTING: number;
18349 readonly OPEN: number;
18352 /** Events that occur due to the user moving a mouse wheel or similar input device. */
18353 interface WheelEvent extends MouseEvent {
18354 readonly deltaMode: number;
18355 readonly deltaX: number;
18356 readonly deltaY: number;
18357 readonly deltaZ: number;
18358 readonly DOM_DELTA_LINE: number;
18359 readonly DOM_DELTA_PAGE: number;
18360 readonly DOM_DELTA_PIXEL: number;
18363 declare var WheelEvent: {
18364 prototype: WheelEvent;
18365 new(type: string, eventInitDict?: WheelEventInit): WheelEvent;
18366 readonly DOM_DELTA_LINE: number;
18367 readonly DOM_DELTA_PAGE: number;
18368 readonly DOM_DELTA_PIXEL: number;
18371 interface WindowEventMap extends GlobalEventHandlersEventMap, WindowEventHandlersEventMap {
18373 "afterprint": Event;
18374 "beforeprint": Event;
18375 "beforeunload": BeforeUnloadEvent;
18376 "blur": FocusEvent;
18378 "canplaythrough": Event;
18380 "click": MouseEvent;
18381 "compassneedscalibration": Event;
18382 "contextmenu": MouseEvent;
18383 "dblclick": MouseEvent;
18384 "devicelight": DeviceLightEvent;
18385 "devicemotion": DeviceMotionEvent;
18386 "deviceorientation": DeviceOrientationEvent;
18387 "deviceorientationabsolute": DeviceOrientationEvent;
18389 "dragend": DragEvent;
18390 "dragenter": DragEvent;
18391 "dragleave": DragEvent;
18392 "dragover": DragEvent;
18393 "dragstart": DragEvent;
18395 "durationchange": Event;
18398 "error": ErrorEvent;
18399 "focus": FocusEvent;
18400 "hashchange": HashChangeEvent;
18403 "keydown": KeyboardEvent;
18404 "keypress": KeyboardEvent;
18405 "keyup": KeyboardEvent;
18407 "loadeddata": Event;
18408 "loadedmetadata": Event;
18409 "loadstart": Event;
18410 "message": MessageEvent;
18411 "mousedown": MouseEvent;
18412 "mouseenter": MouseEvent;
18413 "mouseleave": MouseEvent;
18414 "mousemove": MouseEvent;
18415 "mouseout": MouseEvent;
18416 "mouseover": MouseEvent;
18417 "mouseup": MouseEvent;
18418 "mousewheel": Event;
18419 "MSGestureChange": Event;
18420 "MSGestureDoubleTap": Event;
18421 "MSGestureEnd": Event;
18422 "MSGestureHold": Event;
18423 "MSGestureStart": Event;
18424 "MSGestureTap": Event;
18425 "MSInertiaStart": Event;
18426 "MSPointerCancel": Event;
18427 "MSPointerDown": Event;
18428 "MSPointerEnter": Event;
18429 "MSPointerLeave": Event;
18430 "MSPointerMove": Event;
18431 "MSPointerOut": Event;
18432 "MSPointerOver": Event;
18433 "MSPointerUp": Event;
18436 "orientationchange": Event;
18437 "pagehide": PageTransitionEvent;
18438 "pageshow": PageTransitionEvent;
18442 "popstate": PopStateEvent;
18443 "progress": ProgressEvent<Window>;
18444 "ratechange": Event;
18445 "readystatechange": ProgressEvent<Window>;
18453 "storage": StorageEvent;
18456 "timeupdate": Event;
18458 "volumechange": Event;
18459 "vrdisplayactivate": Event;
18460 "vrdisplayblur": Event;
18461 "vrdisplayconnect": Event;
18462 "vrdisplaydeactivate": Event;
18463 "vrdisplaydisconnect": Event;
18464 "vrdisplayfocus": Event;
18465 "vrdisplaypointerrestricted": Event;
18466 "vrdisplaypointerunrestricted": Event;
18467 "vrdisplaypresentchange": Event;
18471 /** A window containing a DOM document; the document property points to the DOM document loaded in that window. */
18472 interface Window extends EventTarget, AnimationFrameProvider, GlobalEventHandlers, WindowEventHandlers, WindowLocalStorage, WindowOrWorkerGlobalScope, WindowSessionStorage {
18473 readonly applicationCache: ApplicationCache;
18474 readonly clientInformation: Navigator;
18475 readonly closed: boolean;
18476 customElements: CustomElementRegistry;
18477 defaultStatus: string;
18478 readonly devicePixelRatio: number;
18479 readonly doNotTrack: string;
18480 readonly document: Document;
18482 readonly event: Event | undefined;
18484 readonly external: External;
18485 readonly frameElement: Element;
18486 readonly frames: Window;
18487 readonly history: History;
18488 readonly innerHeight: number;
18489 readonly innerWidth: number;
18490 readonly length: number;
18491 location: Location;
18492 readonly locationbar: BarProp;
18493 readonly menubar: BarProp;
18494 readonly msContentScript: ExtensionScriptApis;
18496 readonly navigator: Navigator;
18497 offscreenBuffering: string | boolean;
18498 oncompassneedscalibration: ((this: Window, ev: Event) => any) | null;
18499 ondevicelight: ((this: Window, ev: DeviceLightEvent) => any) | null;
18500 ondevicemotion: ((this: Window, ev: DeviceMotionEvent) => any) | null;
18501 ondeviceorientation: ((this: Window, ev: DeviceOrientationEvent) => any) | null;
18502 ondeviceorientationabsolute: ((this: Window, ev: DeviceOrientationEvent) => any) | null;
18503 onmousewheel: ((this: Window, ev: Event) => any) | null;
18504 onmsgesturechange: ((this: Window, ev: Event) => any) | null;
18505 onmsgesturedoubletap: ((this: Window, ev: Event) => any) | null;
18506 onmsgestureend: ((this: Window, ev: Event) => any) | null;
18507 onmsgesturehold: ((this: Window, ev: Event) => any) | null;
18508 onmsgesturestart: ((this: Window, ev: Event) => any) | null;
18509 onmsgesturetap: ((this: Window, ev: Event) => any) | null;
18510 onmsinertiastart: ((this: Window, ev: Event) => any) | null;
18511 onmspointercancel: ((this: Window, ev: Event) => any) | null;
18512 onmspointerdown: ((this: Window, ev: Event) => any) | null;
18513 onmspointerenter: ((this: Window, ev: Event) => any) | null;
18514 onmspointerleave: ((this: Window, ev: Event) => any) | null;
18515 onmspointermove: ((this: Window, ev: Event) => any) | null;
18516 onmspointerout: ((this: Window, ev: Event) => any) | null;
18517 onmspointerover: ((this: Window, ev: Event) => any) | null;
18518 onmspointerup: ((this: Window, ev: Event) => any) | null;
18520 onorientationchange: ((this: Window, ev: Event) => any) | null;
18521 onreadystatechange: ((this: Window, ev: ProgressEvent<Window>) => any) | null;
18522 onvrdisplayactivate: ((this: Window, ev: Event) => any) | null;
18523 onvrdisplayblur: ((this: Window, ev: Event) => any) | null;
18524 onvrdisplayconnect: ((this: Window, ev: Event) => any) | null;
18525 onvrdisplaydeactivate: ((this: Window, ev: Event) => any) | null;
18526 onvrdisplaydisconnect: ((this: Window, ev: Event) => any) | null;
18527 onvrdisplayfocus: ((this: Window, ev: Event) => any) | null;
18528 onvrdisplaypointerrestricted: ((this: Window, ev: Event) => any) | null;
18529 onvrdisplaypointerunrestricted: ((this: Window, ev: Event) => any) | null;
18530 onvrdisplaypresentchange: ((this: Window, ev: Event) => any) | null;
18533 readonly orientation: string | number;
18534 readonly outerHeight: number;
18535 readonly outerWidth: number;
18536 readonly pageXOffset: number;
18537 readonly pageYOffset: number;
18538 readonly parent: Window;
18539 readonly personalbar: BarProp;
18540 readonly screen: Screen;
18541 readonly screenLeft: number;
18542 readonly screenTop: number;
18543 readonly screenX: number;
18544 readonly screenY: number;
18545 readonly scrollX: number;
18546 readonly scrollY: number;
18547 readonly scrollbars: BarProp;
18548 readonly self: Window & typeof globalThis;
18549 readonly speechSynthesis: SpeechSynthesis;
18551 readonly statusbar: BarProp;
18552 readonly styleMedia: StyleMedia;
18553 readonly toolbar: BarProp;
18554 readonly top: Window;
18555 readonly visualViewport: VisualViewport;
18556 readonly window: Window & typeof globalThis;
18557 alert(message?: any): void;
18560 captureEvents(): void;
18562 confirm(message?: string): boolean;
18563 departFocus(navigationReason: NavigationReason, origin: FocusNavigationOrigin): void;
18565 getComputedStyle(elt: Element, pseudoElt?: string | null): CSSStyleDeclaration;
18566 getMatchedCSSRules(elt: Element, pseudoElt?: string | null): CSSRuleList;
18567 getSelection(): Selection | null;
18568 matchMedia(query: string): MediaQueryList;
18569 moveBy(x: number, y: number): void;
18570 moveTo(x: number, y: number): void;
18571 msWriteProfilerMark(profilerMarkName: string): void;
18572 open(url?: string, target?: string, features?: string, replace?: boolean): Window | null;
18573 postMessage(message: any, targetOrigin: string, transfer?: Transferable[]): void;
18575 prompt(message?: string, _default?: string): string | null;
18577 releaseEvents(): void;
18578 resizeBy(x: number, y: number): void;
18579 resizeTo(width: number, height: number): void;
18580 scroll(options?: ScrollToOptions): void;
18581 scroll(x: number, y: number): void;
18582 scrollBy(options?: ScrollToOptions): void;
18583 scrollBy(x: number, y: number): void;
18584 scrollTo(options?: ScrollToOptions): void;
18585 scrollTo(x: number, y: number): void;
18587 webkitCancelAnimationFrame(handle: number): void;
18588 webkitConvertPointFromNodeToPage(node: Node, pt: WebKitPoint): WebKitPoint;
18589 webkitConvertPointFromPageToNode(node: Node, pt: WebKitPoint): WebKitPoint;
18590 webkitRequestAnimationFrame(callback: FrameRequestCallback): number;
18591 addEventListener<K extends keyof WindowEventMap>(type: K, listener: (this: Window, ev: WindowEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
18592 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
18593 removeEventListener<K extends keyof WindowEventMap>(type: K, listener: (this: Window, ev: WindowEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
18594 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
18595 [index: number]: Window;
18598 declare var Window: {
18603 interface WindowEventHandlersEventMap {
18604 "afterprint": Event;
18605 "beforeprint": Event;
18606 "beforeunload": BeforeUnloadEvent;
18607 "hashchange": HashChangeEvent;
18608 "languagechange": Event;
18609 "message": MessageEvent;
18610 "messageerror": MessageEvent;
18613 "pagehide": PageTransitionEvent;
18614 "pageshow": PageTransitionEvent;
18615 "popstate": PopStateEvent;
18616 "rejectionhandled": PromiseRejectionEvent;
18617 "storage": StorageEvent;
18618 "unhandledrejection": PromiseRejectionEvent;
18622 interface WindowEventHandlers {
18623 onafterprint: ((this: WindowEventHandlers, ev: Event) => any) | null;
18624 onbeforeprint: ((this: WindowEventHandlers, ev: Event) => any) | null;
18625 onbeforeunload: ((this: WindowEventHandlers, ev: BeforeUnloadEvent) => any) | null;
18626 onhashchange: ((this: WindowEventHandlers, ev: HashChangeEvent) => any) | null;
18627 onlanguagechange: ((this: WindowEventHandlers, ev: Event) => any) | null;
18628 onmessage: ((this: WindowEventHandlers, ev: MessageEvent) => any) | null;
18629 onmessageerror: ((this: WindowEventHandlers, ev: MessageEvent) => any) | null;
18630 onoffline: ((this: WindowEventHandlers, ev: Event) => any) | null;
18631 ononline: ((this: WindowEventHandlers, ev: Event) => any) | null;
18632 onpagehide: ((this: WindowEventHandlers, ev: PageTransitionEvent) => any) | null;
18633 onpageshow: ((this: WindowEventHandlers, ev: PageTransitionEvent) => any) | null;
18634 onpopstate: ((this: WindowEventHandlers, ev: PopStateEvent) => any) | null;
18635 onrejectionhandled: ((this: WindowEventHandlers, ev: PromiseRejectionEvent) => any) | null;
18636 onstorage: ((this: WindowEventHandlers, ev: StorageEvent) => any) | null;
18637 onunhandledrejection: ((this: WindowEventHandlers, ev: PromiseRejectionEvent) => any) | null;
18638 onunload: ((this: WindowEventHandlers, ev: Event) => any) | null;
18639 addEventListener<K extends keyof WindowEventHandlersEventMap>(type: K, listener: (this: WindowEventHandlers, ev: WindowEventHandlersEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
18640 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
18641 removeEventListener<K extends keyof WindowEventHandlersEventMap>(type: K, listener: (this: WindowEventHandlers, ev: WindowEventHandlersEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
18642 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
18645 interface WindowLocalStorage {
18646 readonly localStorage: Storage;
18649 interface WindowOrWorkerGlobalScope {
18650 readonly caches: CacheStorage;
18651 readonly crypto: Crypto;
18652 readonly indexedDB: IDBFactory;
18653 readonly isSecureContext: boolean;
18654 readonly origin: string;
18655 readonly performance: Performance;
18656 atob(data: string): string;
18657 btoa(data: string): string;
18658 clearInterval(handle?: number): void;
18659 clearTimeout(handle?: number): void;
18660 createImageBitmap(image: ImageBitmapSource, options?: ImageBitmapOptions): Promise<ImageBitmap>;
18661 createImageBitmap(image: ImageBitmapSource, sx: number, sy: number, sw: number, sh: number, options?: ImageBitmapOptions): Promise<ImageBitmap>;
18662 fetch(input: RequestInfo, init?: RequestInit): Promise<Response>;
18663 queueMicrotask(callback: VoidFunction): void;
18664 setInterval(handler: TimerHandler, timeout?: number, ...arguments: any[]): number;
18665 setTimeout(handler: TimerHandler, timeout?: number, ...arguments: any[]): number;
18668 interface WindowSessionStorage {
18669 readonly sessionStorage: Storage;
18672 interface WorkerEventMap extends AbstractWorkerEventMap {
18673 "message": MessageEvent;
18674 "messageerror": MessageEvent;
18677 /** 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. */
18678 interface Worker extends EventTarget, AbstractWorker {
18679 onmessage: ((this: Worker, ev: MessageEvent) => any) | null;
18680 onmessageerror: ((this: Worker, ev: MessageEvent) => any) | null;
18682 * 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.
18684 postMessage(message: any, transfer: Transferable[]): void;
18685 postMessage(message: any, options?: PostMessageOptions): void;
18687 * Aborts worker's associated global environment.
18690 addEventListener<K extends keyof WorkerEventMap>(type: K, listener: (this: Worker, ev: WorkerEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
18691 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
18692 removeEventListener<K extends keyof WorkerEventMap>(type: K, listener: (this: Worker, ev: WorkerEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
18693 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
18696 declare var Worker: {
18698 new(stringUrl: string | URL, options?: WorkerOptions): Worker;
18701 interface Worklet {
18702 addModule(moduleURL: string, options?: WorkletOptions): Promise<void>;
18705 declare var Worklet: {
18706 prototype: Worklet;
18710 /** 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. */
18711 interface WritableStream<W = any> {
18712 readonly locked: boolean;
18713 abort(reason?: any): Promise<void>;
18714 getWriter(): WritableStreamDefaultWriter<W>;
18717 declare var WritableStream: {
18718 prototype: WritableStream;
18719 new<W = any>(underlyingSink?: UnderlyingSink<W>, strategy?: QueuingStrategy<W>): WritableStream<W>;
18722 /** 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. */
18723 interface WritableStreamDefaultController {
18724 error(error?: any): void;
18727 declare var WritableStreamDefaultController: {
18728 prototype: WritableStreamDefaultController;
18729 new(): WritableStreamDefaultController;
18732 /** 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. */
18733 interface WritableStreamDefaultWriter<W = any> {
18734 readonly closed: Promise<void>;
18735 readonly desiredSize: number | null;
18736 readonly ready: Promise<void>;
18737 abort(reason?: any): Promise<void>;
18738 close(): Promise<void>;
18739 releaseLock(): void;
18740 write(chunk: W): Promise<void>;
18743 declare var WritableStreamDefaultWriter: {
18744 prototype: WritableStreamDefaultWriter;
18745 new(): WritableStreamDefaultWriter;
18748 /** 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. */
18749 interface XMLDocument extends Document {
18750 addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: XMLDocument, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
18751 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
18752 removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: XMLDocument, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
18753 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
18756 declare var XMLDocument: {
18757 prototype: XMLDocument;
18758 new(): XMLDocument;
18761 interface XMLHttpRequestEventMap extends XMLHttpRequestEventTargetEventMap {
18762 "readystatechange": Event;
18765 /** 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. */
18766 interface XMLHttpRequest extends XMLHttpRequestEventTarget {
18767 onreadystatechange: ((this: XMLHttpRequest, ev: Event) => any) | null;
18769 * Returns client's state.
18771 readonly readyState: number;
18773 * Returns the response's body.
18775 readonly response: any;
18777 * Returns the text response.
18779 * Throws an "InvalidStateError" DOMException if responseType is not the empty string or "text".
18781 readonly responseText: string;
18783 * Returns the response type.
18785 * Can be set to change the response type. Values are: the empty string (default), "arraybuffer", "blob", "document", "json", and "text".
18787 * When set: setting to "document" is ignored if current global object is not a Window object.
18789 * When set: throws an "InvalidStateError" DOMException if state is loading or done.
18791 * When set: throws an "InvalidAccessError" DOMException if the synchronous flag is set and current global object is a Window object.
18793 responseType: XMLHttpRequestResponseType;
18794 readonly responseURL: string;
18796 * Returns the document response.
18798 * Throws an "InvalidStateError" DOMException if responseType is not the empty string or "document".
18800 readonly responseXML: Document | null;
18801 readonly status: number;
18802 readonly statusText: string;
18804 * 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).
18806 * When set: throws an "InvalidAccessError" DOMException if the synchronous flag is set and current global object is a Window object.
18810 * Returns the associated XMLHttpRequestUpload object. It can be used to gather transmission information when data is transferred to a server.
18812 readonly upload: XMLHttpRequestUpload;
18814 * 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.
18816 * When set: throws an "InvalidStateError" DOMException if state is not unsent or opened, or if the send() flag is set.
18818 withCredentials: boolean;
18820 * Cancels any network activity.
18823 getAllResponseHeaders(): string;
18824 getResponseHeader(name: string): string | null;
18826 * Sets the request method, request URL, and synchronous flag.
18828 * Throws a "SyntaxError" DOMException if either method is not a valid HTTP method or url cannot be parsed.
18830 * Throws a "SecurityError" DOMException if method is a case-insensitive match for `CONNECT`, `TRACE`, or `TRACK`.
18832 * 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.
18834 open(method: string, url: string): void;
18835 open(method: string, url: string, async: boolean, username?: string | null, password?: string | null): void;
18837 * Acts as if the `Content-Type` header value for response is mime. (It does not actually change the header though.)
18839 * Throws an "InvalidStateError" DOMException if state is loading or done.
18841 overrideMimeType(mime: string): void;
18843 * Initiates the request. The body argument provides the request body, if any, and is ignored if the request method is GET or HEAD.
18845 * Throws an "InvalidStateError" DOMException if either state is not opened or the send() flag is set.
18847 send(body?: Document | BodyInit | null): void;
18849 * Combines a header in author request headers.
18851 * Throws an "InvalidStateError" DOMException if either state is not opened or the send() flag is set.
18853 * Throws a "SyntaxError" DOMException if name is not a header name or if value is not a header value.
18855 setRequestHeader(name: string, value: string): void;
18856 readonly DONE: number;
18857 readonly HEADERS_RECEIVED: number;
18858 readonly LOADING: number;
18859 readonly OPENED: number;
18860 readonly UNSENT: number;
18861 addEventListener<K extends keyof XMLHttpRequestEventMap>(type: K, listener: (this: XMLHttpRequest, ev: XMLHttpRequestEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
18862 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
18863 removeEventListener<K extends keyof XMLHttpRequestEventMap>(type: K, listener: (this: XMLHttpRequest, ev: XMLHttpRequestEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
18864 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
18867 declare var XMLHttpRequest: {
18868 prototype: XMLHttpRequest;
18869 new(): XMLHttpRequest;
18870 readonly DONE: number;
18871 readonly HEADERS_RECEIVED: number;
18872 readonly LOADING: number;
18873 readonly OPENED: number;
18874 readonly UNSENT: number;
18877 interface XMLHttpRequestEventTargetEventMap {
18878 "abort": ProgressEvent<XMLHttpRequestEventTarget>;
18879 "error": ProgressEvent<XMLHttpRequestEventTarget>;
18880 "load": ProgressEvent<XMLHttpRequestEventTarget>;
18881 "loadend": ProgressEvent<XMLHttpRequestEventTarget>;
18882 "loadstart": ProgressEvent<XMLHttpRequestEventTarget>;
18883 "progress": ProgressEvent<XMLHttpRequestEventTarget>;
18884 "timeout": ProgressEvent<XMLHttpRequestEventTarget>;
18887 interface XMLHttpRequestEventTarget extends EventTarget {
18888 onabort: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
18889 onerror: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
18890 onload: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
18891 onloadend: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
18892 onloadstart: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
18893 onprogress: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
18894 ontimeout: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
18895 addEventListener<K extends keyof XMLHttpRequestEventTargetEventMap>(type: K, listener: (this: XMLHttpRequestEventTarget, ev: XMLHttpRequestEventTargetEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
18896 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
18897 removeEventListener<K extends keyof XMLHttpRequestEventTargetEventMap>(type: K, listener: (this: XMLHttpRequestEventTarget, ev: XMLHttpRequestEventTargetEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
18898 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
18901 declare var XMLHttpRequestEventTarget: {
18902 prototype: XMLHttpRequestEventTarget;
18903 new(): XMLHttpRequestEventTarget;
18906 interface XMLHttpRequestUpload extends XMLHttpRequestEventTarget {
18907 addEventListener<K extends keyof XMLHttpRequestEventTargetEventMap>(type: K, listener: (this: XMLHttpRequestUpload, ev: XMLHttpRequestEventTargetEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
18908 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
18909 removeEventListener<K extends keyof XMLHttpRequestEventTargetEventMap>(type: K, listener: (this: XMLHttpRequestUpload, ev: XMLHttpRequestEventTargetEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
18910 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
18913 declare var XMLHttpRequestUpload: {
18914 prototype: XMLHttpRequestUpload;
18915 new(): XMLHttpRequestUpload;
18918 /** Provides the serializeToString() method to construct an XML string representing a DOM tree. */
18919 interface XMLSerializer {
18920 serializeToString(root: Node): string;
18923 declare var XMLSerializer: {
18924 prototype: XMLSerializer;
18925 new(): XMLSerializer;
18928 /** The XPathEvaluator interface allows to compile and evaluate XPath expressions. */
18929 interface XPathEvaluator extends XPathEvaluatorBase {
18932 declare var XPathEvaluator: {
18933 prototype: XPathEvaluator;
18934 new(): XPathEvaluator;
18937 interface XPathEvaluatorBase {
18938 createExpression(expression: string, resolver?: XPathNSResolver | null): XPathExpression;
18939 createNSResolver(nodeResolver: Node): XPathNSResolver;
18940 evaluate(expression: string, contextNode: Node, resolver?: XPathNSResolver | null, type?: number, result?: XPathResult | null): XPathResult;
18943 /** This interface is a compiled XPath expression that can be evaluated on a document or specific node to return information its DOM tree. */
18944 interface XPathExpression {
18945 evaluate(contextNode: Node, type?: number, result?: XPathResult | null): XPathResult;
18948 declare var XPathExpression: {
18949 prototype: XPathExpression;
18950 new(): XPathExpression;
18953 /** The results generated by evaluating an XPath expression within the context of a given node. */
18954 interface XPathResult {
18955 readonly booleanValue: boolean;
18956 readonly invalidIteratorState: boolean;
18957 readonly numberValue: number;
18958 readonly resultType: number;
18959 readonly singleNodeValue: Node | null;
18960 readonly snapshotLength: number;
18961 readonly stringValue: string;
18962 iterateNext(): Node | null;
18963 snapshotItem(index: number): Node | null;
18964 readonly ANY_TYPE: number;
18965 readonly ANY_UNORDERED_NODE_TYPE: number;
18966 readonly BOOLEAN_TYPE: number;
18967 readonly FIRST_ORDERED_NODE_TYPE: number;
18968 readonly NUMBER_TYPE: number;
18969 readonly ORDERED_NODE_ITERATOR_TYPE: number;
18970 readonly ORDERED_NODE_SNAPSHOT_TYPE: number;
18971 readonly STRING_TYPE: number;
18972 readonly UNORDERED_NODE_ITERATOR_TYPE: number;
18973 readonly UNORDERED_NODE_SNAPSHOT_TYPE: number;
18976 declare var XPathResult: {
18977 prototype: XPathResult;
18978 new(): XPathResult;
18979 readonly ANY_TYPE: number;
18980 readonly ANY_UNORDERED_NODE_TYPE: number;
18981 readonly BOOLEAN_TYPE: number;
18982 readonly FIRST_ORDERED_NODE_TYPE: number;
18983 readonly NUMBER_TYPE: number;
18984 readonly ORDERED_NODE_ITERATOR_TYPE: number;
18985 readonly ORDERED_NODE_SNAPSHOT_TYPE: number;
18986 readonly STRING_TYPE: number;
18987 readonly UNORDERED_NODE_ITERATOR_TYPE: number;
18988 readonly UNORDERED_NODE_SNAPSHOT_TYPE: number;
18991 /** 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. */
18992 interface XSLTProcessor {
18993 clearParameters(): void;
18994 getParameter(namespaceURI: string, localName: string): any;
18995 importStylesheet(style: Node): void;
18996 removeParameter(namespaceURI: string, localName: string): void;
18998 setParameter(namespaceURI: string, localName: string, value: any): void;
18999 transformToDocument(source: Node): Document;
19000 transformToFragment(source: Node, document: Document): DocumentFragment;
19003 declare var XSLTProcessor: {
19004 prototype: XSLTProcessor;
19005 new(): XSLTProcessor;
19008 interface webkitRTCPeerConnection extends RTCPeerConnection {
19009 addEventListener<K extends keyof RTCPeerConnectionEventMap>(type: K, listener: (this: webkitRTCPeerConnection, ev: RTCPeerConnectionEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
19010 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
19011 removeEventListener<K extends keyof RTCPeerConnectionEventMap>(type: K, listener: (this: webkitRTCPeerConnection, ev: RTCPeerConnectionEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
19012 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
19015 declare var webkitRTCPeerConnection: {
19016 prototype: webkitRTCPeerConnection;
19017 new(configuration: RTCConfiguration): webkitRTCPeerConnection;
19020 declare type EventListenerOrEventListenerObject = EventListener | EventListenerObject;
19022 interface Console {
19024 assert(condition?: boolean, ...data: any[]): void;
19026 count(label?: string): void;
19027 countReset(label?: string): void;
19028 debug(...data: any[]): void;
19029 dir(item?: any, options?: any): void;
19030 dirxml(...data: any[]): void;
19031 error(...data: any[]): void;
19032 exception(message?: string, ...optionalParams: any[]): void;
19033 group(...data: any[]): void;
19034 groupCollapsed(...data: any[]): void;
19036 info(...data: any[]): void;
19037 log(...data: any[]): void;
19038 table(tabularData?: any, properties?: string[]): void;
19039 time(label?: string): void;
19040 timeEnd(label?: string): void;
19041 timeLog(label?: string, ...data: any[]): void;
19042 timeStamp(label?: string): void;
19043 trace(...data: any[]): void;
19044 warn(...data: any[]): void;
19047 declare var console: Console;
19049 /** Holds useful CSS-related methods. No object with this interface are implemented: it contains only static methods and therefore is a utilitarian interface. */
19050 declare namespace CSS {
19051 function escape(ident: string): string;
19052 function supports(property: string, value: string): boolean;
19053 function supports(conditionText: string): boolean;
19056 declare namespace WebAssembly {
19057 interface CompileError {
19060 var CompileError: {
19061 prototype: CompileError;
19062 new(): CompileError;
19072 new(descriptor: GlobalDescriptor, v?: any): Global;
19075 interface Instance {
19076 readonly exports: Exports;
19080 prototype: Instance;
19081 new(module: Module, importObject?: Imports): Instance;
19084 interface LinkError {
19088 prototype: LinkError;
19093 readonly buffer: ArrayBuffer;
19094 grow(delta: number): number;
19099 new(descriptor: MemoryDescriptor): Memory;
19107 new(bytes: BufferSource): Module;
19108 customSections(moduleObject: Module, sectionName: string): ArrayBuffer[];
19109 exports(moduleObject: Module): ModuleExportDescriptor[];
19110 imports(moduleObject: Module): ModuleImportDescriptor[];
19113 interface RuntimeError {
19116 var RuntimeError: {
19117 prototype: RuntimeError;
19118 new(): RuntimeError;
19122 readonly length: number;
19123 get(index: number): Function | null;
19124 grow(delta: number): number;
19125 set(index: number, value: Function | null): void;
19130 new(descriptor: TableDescriptor): Table;
19133 interface GlobalDescriptor {
19138 interface MemoryDescriptor {
19143 interface ModuleExportDescriptor {
19144 kind: ImportExportKind;
19148 interface ModuleImportDescriptor {
19149 kind: ImportExportKind;
19154 interface TableDescriptor {
19155 element: TableKind;
19160 interface WebAssemblyInstantiatedSource {
19161 instance: Instance;
19165 type ImportExportKind = "function" | "global" | "memory" | "table";
19166 type TableKind = "anyfunc";
19167 type ValueType = "f32" | "f64" | "i32" | "i64";
19168 type ExportValue = Function | Global | Memory | Table;
19169 type Exports = Record<string, ExportValue>;
19170 type ImportValue = ExportValue | number;
19171 type ModuleImports = Record<string, ImportValue>;
19172 type Imports = Record<string, ModuleImports>;
19173 function compile(bytes: BufferSource): Promise<Module>;
19174 function compileStreaming(source: Response | Promise<Response>): Promise<Module>;
19175 function instantiate(bytes: BufferSource, importObject?: Imports): Promise<WebAssemblyInstantiatedSource>;
19176 function instantiate(moduleObject: Module, importObject?: Imports): Promise<Instance>;
19177 function instantiateStreaming(response: Response | PromiseLike<Response>, importObject?: Imports): Promise<WebAssemblyInstantiatedSource>;
19178 function validate(bytes: BufferSource): boolean;
19181 interface BlobCallback {
19182 (blob: Blob | null): void;
19185 interface CustomElementConstructor {
19186 new (...params: any[]): HTMLElement;
19189 interface DecodeErrorCallback {
19190 (error: DOMException): void;
19193 interface DecodeSuccessCallback {
19194 (decodedData: AudioBuffer): void;
19197 interface EventHandlerNonNull {
19198 (event: Event): any;
19201 interface ForEachCallback {
19202 (keyId: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer | null, status: MediaKeyStatus): void;
19205 interface FrameRequestCallback {
19206 (time: number): void;
19209 interface FunctionStringCallback {
19210 (data: string): void;
19213 interface IntersectionObserverCallback {
19214 (entries: IntersectionObserverEntry[], observer: IntersectionObserver): void;
19217 interface MSLaunchUriCallback {
19221 interface MutationCallback {
19222 (mutations: MutationRecord[], observer: MutationObserver): void;
19225 interface NavigatorUserMediaErrorCallback {
19226 (error: MediaStreamError): void;
19229 interface NavigatorUserMediaSuccessCallback {
19230 (stream: MediaStream): void;
19233 interface NotificationPermissionCallback {
19234 (permission: NotificationPermission): void;
19237 interface OnBeforeUnloadEventHandlerNonNull {
19238 (event: Event): string | null;
19241 interface OnErrorEventHandlerNonNull {
19242 (event: Event | string, source?: string, lineno?: number, colno?: number, error?: Error): any;
19245 interface PerformanceObserverCallback {
19246 (entries: PerformanceObserverEntryList, observer: PerformanceObserver): void;
19249 interface PositionCallback {
19250 (position: GeolocationPosition): void;
19253 interface PositionErrorCallback {
19254 (positionError: GeolocationPositionError): void;
19257 interface QueuingStrategySizeCallback<T = any> {
19258 (chunk: T): number;
19261 interface RTCPeerConnectionErrorCallback {
19262 (error: DOMException): void;
19265 interface RTCSessionDescriptionCallback {
19266 (description: RTCSessionDescriptionInit): void;
19269 interface RTCStatsCallback {
19270 (report: RTCStatsReport): void;
19273 interface ReadableByteStreamControllerCallback {
19274 (controller: ReadableByteStreamController): void | PromiseLike<void>;
19277 interface ReadableStreamDefaultControllerCallback<R> {
19278 (controller: ReadableStreamDefaultController<R>): void | PromiseLike<void>;
19281 interface ReadableStreamErrorCallback {
19282 (reason: any): void | PromiseLike<void>;
19285 interface TransformStreamDefaultControllerCallback<O> {
19286 (controller: TransformStreamDefaultController<O>): void | PromiseLike<void>;
19289 interface TransformStreamDefaultControllerTransformCallback<I, O> {
19290 (chunk: I, controller: TransformStreamDefaultController<O>): void | PromiseLike<void>;
19293 interface VoidFunction {
19297 interface WritableStreamDefaultControllerCloseCallback {
19298 (): void | PromiseLike<void>;
19301 interface WritableStreamDefaultControllerStartCallback {
19302 (controller: WritableStreamDefaultController): void | PromiseLike<void>;
19305 interface WritableStreamDefaultControllerWriteCallback<W> {
19306 (chunk: W, controller: WritableStreamDefaultController): void | PromiseLike<void>;
19309 interface WritableStreamErrorCallback {
19310 (reason: any): void | PromiseLike<void>;
19313 interface HTMLElementTagNameMap {
19314 "a": HTMLAnchorElement;
19315 "abbr": HTMLElement;
19316 "address": HTMLElement;
19317 "applet": HTMLAppletElement;
19318 "area": HTMLAreaElement;
19319 "article": HTMLElement;
19320 "aside": HTMLElement;
19321 "audio": HTMLAudioElement;
19323 "base": HTMLBaseElement;
19324 "basefont": HTMLBaseFontElement;
19325 "bdi": HTMLElement;
19326 "bdo": HTMLElement;
19327 "blockquote": HTMLQuoteElement;
19328 "body": HTMLBodyElement;
19329 "br": HTMLBRElement;
19330 "button": HTMLButtonElement;
19331 "canvas": HTMLCanvasElement;
19332 "caption": HTMLTableCaptionElement;
19333 "cite": HTMLElement;
19334 "code": HTMLElement;
19335 "col": HTMLTableColElement;
19336 "colgroup": HTMLTableColElement;
19337 "data": HTMLDataElement;
19338 "datalist": HTMLDataListElement;
19340 "del": HTMLModElement;
19341 "details": HTMLDetailsElement;
19342 "dfn": HTMLElement;
19343 "dialog": HTMLDialogElement;
19344 "dir": HTMLDirectoryElement;
19345 "div": HTMLDivElement;
19346 "dl": HTMLDListElement;
19349 "embed": HTMLEmbedElement;
19350 "fieldset": HTMLFieldSetElement;
19351 "figcaption": HTMLElement;
19352 "figure": HTMLElement;
19353 "font": HTMLFontElement;
19354 "footer": HTMLElement;
19355 "form": HTMLFormElement;
19356 "frame": HTMLFrameElement;
19357 "frameset": HTMLFrameSetElement;
19358 "h1": HTMLHeadingElement;
19359 "h2": HTMLHeadingElement;
19360 "h3": HTMLHeadingElement;
19361 "h4": HTMLHeadingElement;
19362 "h5": HTMLHeadingElement;
19363 "h6": HTMLHeadingElement;
19364 "head": HTMLHeadElement;
19365 "header": HTMLElement;
19366 "hgroup": HTMLElement;
19367 "hr": HTMLHRElement;
19368 "html": HTMLHtmlElement;
19370 "iframe": HTMLIFrameElement;
19371 "img": HTMLImageElement;
19372 "input": HTMLInputElement;
19373 "ins": HTMLModElement;
19374 "kbd": HTMLElement;
19375 "label": HTMLLabelElement;
19376 "legend": HTMLLegendElement;
19377 "li": HTMLLIElement;
19378 "link": HTMLLinkElement;
19379 "main": HTMLElement;
19380 "map": HTMLMapElement;
19381 "mark": HTMLElement;
19382 "marquee": HTMLMarqueeElement;
19383 "menu": HTMLMenuElement;
19384 "meta": HTMLMetaElement;
19385 "meter": HTMLMeterElement;
19386 "nav": HTMLElement;
19387 "noscript": HTMLElement;
19388 "object": HTMLObjectElement;
19389 "ol": HTMLOListElement;
19390 "optgroup": HTMLOptGroupElement;
19391 "option": HTMLOptionElement;
19392 "output": HTMLOutputElement;
19393 "p": HTMLParagraphElement;
19394 "param": HTMLParamElement;
19395 "picture": HTMLPictureElement;
19396 "pre": HTMLPreElement;
19397 "progress": HTMLProgressElement;
19398 "q": HTMLQuoteElement;
19401 "ruby": HTMLElement;
19403 "samp": HTMLElement;
19404 "script": HTMLScriptElement;
19405 "section": HTMLElement;
19406 "select": HTMLSelectElement;
19407 "slot": HTMLSlotElement;
19408 "small": HTMLElement;
19409 "source": HTMLSourceElement;
19410 "span": HTMLSpanElement;
19411 "strong": HTMLElement;
19412 "style": HTMLStyleElement;
19413 "sub": HTMLElement;
19414 "summary": HTMLElement;
19415 "sup": HTMLElement;
19416 "table": HTMLTableElement;
19417 "tbody": HTMLTableSectionElement;
19418 "td": HTMLTableDataCellElement;
19419 "template": HTMLTemplateElement;
19420 "textarea": HTMLTextAreaElement;
19421 "tfoot": HTMLTableSectionElement;
19422 "th": HTMLTableHeaderCellElement;
19423 "thead": HTMLTableSectionElement;
19424 "time": HTMLTimeElement;
19425 "title": HTMLTitleElement;
19426 "tr": HTMLTableRowElement;
19427 "track": HTMLTrackElement;
19429 "ul": HTMLUListElement;
19430 "var": HTMLElement;
19431 "video": HTMLVideoElement;
19432 "wbr": HTMLElement;
19435 interface HTMLElementDeprecatedTagNameMap {
19436 "listing": HTMLPreElement;
19437 "xmp": HTMLPreElement;
19440 interface SVGElementTagNameMap {
19442 "circle": SVGCircleElement;
19443 "clipPath": SVGClipPathElement;
19444 "defs": SVGDefsElement;
19445 "desc": SVGDescElement;
19446 "ellipse": SVGEllipseElement;
19447 "feBlend": SVGFEBlendElement;
19448 "feColorMatrix": SVGFEColorMatrixElement;
19449 "feComponentTransfer": SVGFEComponentTransferElement;
19450 "feComposite": SVGFECompositeElement;
19451 "feConvolveMatrix": SVGFEConvolveMatrixElement;
19452 "feDiffuseLighting": SVGFEDiffuseLightingElement;
19453 "feDisplacementMap": SVGFEDisplacementMapElement;
19454 "feDistantLight": SVGFEDistantLightElement;
19455 "feFlood": SVGFEFloodElement;
19456 "feFuncA": SVGFEFuncAElement;
19457 "feFuncB": SVGFEFuncBElement;
19458 "feFuncG": SVGFEFuncGElement;
19459 "feFuncR": SVGFEFuncRElement;
19460 "feGaussianBlur": SVGFEGaussianBlurElement;
19461 "feImage": SVGFEImageElement;
19462 "feMerge": SVGFEMergeElement;
19463 "feMergeNode": SVGFEMergeNodeElement;
19464 "feMorphology": SVGFEMorphologyElement;
19465 "feOffset": SVGFEOffsetElement;
19466 "fePointLight": SVGFEPointLightElement;
19467 "feSpecularLighting": SVGFESpecularLightingElement;
19468 "feSpotLight": SVGFESpotLightElement;
19469 "feTile": SVGFETileElement;
19470 "feTurbulence": SVGFETurbulenceElement;
19471 "filter": SVGFilterElement;
19472 "foreignObject": SVGForeignObjectElement;
19474 "image": SVGImageElement;
19475 "line": SVGLineElement;
19476 "linearGradient": SVGLinearGradientElement;
19477 "marker": SVGMarkerElement;
19478 "mask": SVGMaskElement;
19479 "metadata": SVGMetadataElement;
19480 "path": SVGPathElement;
19481 "pattern": SVGPatternElement;
19482 "polygon": SVGPolygonElement;
19483 "polyline": SVGPolylineElement;
19484 "radialGradient": SVGRadialGradientElement;
19485 "rect": SVGRectElement;
19486 "script": SVGScriptElement;
19487 "stop": SVGStopElement;
19488 "style": SVGStyleElement;
19489 "svg": SVGSVGElement;
19490 "switch": SVGSwitchElement;
19491 "symbol": SVGSymbolElement;
19492 "text": SVGTextElement;
19493 "textPath": SVGTextPathElement;
19494 "title": SVGTitleElement;
19495 "tspan": SVGTSpanElement;
19496 "use": SVGUseElement;
19497 "view": SVGViewElement;
19500 /** @deprecated Directly use HTMLElementTagNameMap or SVGElementTagNameMap as appropriate, instead. */
19501 type ElementTagNameMap = HTMLElementTagNameMap & Pick<SVGElementTagNameMap, Exclude<keyof SVGElementTagNameMap, keyof HTMLElementTagNameMap>>;
19503 declare var Audio: {
19504 new(src?: string): HTMLAudioElement;
19506 declare var Image: {
19507 new(width?: number, height?: number): HTMLImageElement;
19509 declare var Option: {
19510 new(text?: string, value?: string, defaultSelected?: boolean, selected?: boolean): HTMLOptionElement;
19512 declare var applicationCache: ApplicationCache;
19513 declare var clientInformation: Navigator;
19514 declare var closed: boolean;
19515 declare var customElements: CustomElementRegistry;
19516 declare var defaultStatus: string;
19517 declare var devicePixelRatio: number;
19518 declare var doNotTrack: string;
19519 declare var document: Document;
19521 declare var event: Event | undefined;
19523 declare var external: External;
19524 declare var frameElement: Element;
19525 declare var frames: Window;
19526 declare var history: History;
19527 declare var innerHeight: number;
19528 declare var innerWidth: number;
19529 declare var length: number;
19530 declare var location: Location;
19531 declare var locationbar: BarProp;
19532 declare var menubar: BarProp;
19533 declare var msContentScript: ExtensionScriptApis;
19535 declare const name: void;
19536 declare var navigator: Navigator;
19537 declare var offscreenBuffering: string | boolean;
19538 declare var oncompassneedscalibration: ((this: Window, ev: Event) => any) | null;
19539 declare var ondevicelight: ((this: Window, ev: DeviceLightEvent) => any) | null;
19540 declare var ondevicemotion: ((this: Window, ev: DeviceMotionEvent) => any) | null;
19541 declare var ondeviceorientation: ((this: Window, ev: DeviceOrientationEvent) => any) | null;
19542 declare var ondeviceorientationabsolute: ((this: Window, ev: DeviceOrientationEvent) => any) | null;
19543 declare var onmousewheel: ((this: Window, ev: Event) => any) | null;
19544 declare var onmsgesturechange: ((this: Window, ev: Event) => any) | null;
19545 declare var onmsgesturedoubletap: ((this: Window, ev: Event) => any) | null;
19546 declare var onmsgestureend: ((this: Window, ev: Event) => any) | null;
19547 declare var onmsgesturehold: ((this: Window, ev: Event) => any) | null;
19548 declare var onmsgesturestart: ((this: Window, ev: Event) => any) | null;
19549 declare var onmsgesturetap: ((this: Window, ev: Event) => any) | null;
19550 declare var onmsinertiastart: ((this: Window, ev: Event) => any) | null;
19551 declare var onmspointercancel: ((this: Window, ev: Event) => any) | null;
19552 declare var onmspointerdown: ((this: Window, ev: Event) => any) | null;
19553 declare var onmspointerenter: ((this: Window, ev: Event) => any) | null;
19554 declare var onmspointerleave: ((this: Window, ev: Event) => any) | null;
19555 declare var onmspointermove: ((this: Window, ev: Event) => any) | null;
19556 declare var onmspointerout: ((this: Window, ev: Event) => any) | null;
19557 declare var onmspointerover: ((this: Window, ev: Event) => any) | null;
19558 declare var onmspointerup: ((this: Window, ev: Event) => any) | null;
19560 declare var onorientationchange: ((this: Window, ev: Event) => any) | null;
19561 declare var onreadystatechange: ((this: Window, ev: ProgressEvent<Window>) => any) | null;
19562 declare var onvrdisplayactivate: ((this: Window, ev: Event) => any) | null;
19563 declare var onvrdisplayblur: ((this: Window, ev: Event) => any) | null;
19564 declare var onvrdisplayconnect: ((this: Window, ev: Event) => any) | null;
19565 declare var onvrdisplaydeactivate: ((this: Window, ev: Event) => any) | null;
19566 declare var onvrdisplaydisconnect: ((this: Window, ev: Event) => any) | null;
19567 declare var onvrdisplayfocus: ((this: Window, ev: Event) => any) | null;
19568 declare var onvrdisplaypointerrestricted: ((this: Window, ev: Event) => any) | null;
19569 declare var onvrdisplaypointerunrestricted: ((this: Window, ev: Event) => any) | null;
19570 declare var onvrdisplaypresentchange: ((this: Window, ev: Event) => any) | null;
19571 declare var opener: any;
19573 declare var orientation: string | number;
19574 declare var outerHeight: number;
19575 declare var outerWidth: number;
19576 declare var pageXOffset: number;
19577 declare var pageYOffset: number;
19578 declare var parent: Window;
19579 declare var personalbar: BarProp;
19580 declare var screen: Screen;
19581 declare var screenLeft: number;
19582 declare var screenTop: number;
19583 declare var screenX: number;
19584 declare var screenY: number;
19585 declare var scrollX: number;
19586 declare var scrollY: number;
19587 declare var scrollbars: BarProp;
19588 declare var self: Window & typeof globalThis;
19589 declare var speechSynthesis: SpeechSynthesis;
19590 declare var status: string;
19591 declare var statusbar: BarProp;
19592 declare var styleMedia: StyleMedia;
19593 declare var toolbar: BarProp;
19594 declare var top: Window;
19595 declare var visualViewport: VisualViewport;
19596 declare var window: Window & typeof globalThis;
19597 declare function alert(message?: any): void;
19598 declare function blur(): void;
19600 declare function captureEvents(): void;
19601 declare function close(): void;
19602 declare function confirm(message?: string): boolean;
19603 declare function departFocus(navigationReason: NavigationReason, origin: FocusNavigationOrigin): void;
19604 declare function focus(): void;
19605 declare function getComputedStyle(elt: Element, pseudoElt?: string | null): CSSStyleDeclaration;
19606 declare function getMatchedCSSRules(elt: Element, pseudoElt?: string | null): CSSRuleList;
19607 declare function getSelection(): Selection | null;
19608 declare function matchMedia(query: string): MediaQueryList;
19609 declare function moveBy(x: number, y: number): void;
19610 declare function moveTo(x: number, y: number): void;
19611 declare function msWriteProfilerMark(profilerMarkName: string): void;
19612 declare function open(url?: string, target?: string, features?: string, replace?: boolean): Window | null;
19613 declare function postMessage(message: any, targetOrigin: string, transfer?: Transferable[]): void;
19614 declare function print(): void;
19615 declare function prompt(message?: string, _default?: string): string | null;
19617 declare function releaseEvents(): void;
19618 declare function resizeBy(x: number, y: number): void;
19619 declare function resizeTo(width: number, height: number): void;
19620 declare function scroll(options?: ScrollToOptions): void;
19621 declare function scroll(x: number, y: number): void;
19622 declare function scrollBy(options?: ScrollToOptions): void;
19623 declare function scrollBy(x: number, y: number): void;
19624 declare function scrollTo(options?: ScrollToOptions): void;
19625 declare function scrollTo(x: number, y: number): void;
19626 declare function stop(): void;
19627 declare function webkitCancelAnimationFrame(handle: number): void;
19628 declare function webkitConvertPointFromNodeToPage(node: Node, pt: WebKitPoint): WebKitPoint;
19629 declare function webkitConvertPointFromPageToNode(node: Node, pt: WebKitPoint): WebKitPoint;
19630 declare function webkitRequestAnimationFrame(callback: FrameRequestCallback): number;
19631 declare function toString(): string;
19633 * 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.
19635 declare function dispatchEvent(event: Event): boolean;
19636 declare var sessionStorage: Storage;
19637 declare var localStorage: Storage;
19639 * Fires when the user aborts the download.
19640 * @param ev The event.
19642 declare var onabort: ((this: Window, ev: UIEvent) => any) | null;
19643 declare var onanimationcancel: ((this: Window, ev: AnimationEvent) => any) | null;
19644 declare var onanimationend: ((this: Window, ev: AnimationEvent) => any) | null;
19645 declare var onanimationiteration: ((this: Window, ev: AnimationEvent) => any) | null;
19646 declare var onanimationstart: ((this: Window, ev: AnimationEvent) => any) | null;
19647 declare var onauxclick: ((this: Window, ev: MouseEvent) => any) | null;
19649 * Fires when the object loses the input focus.
19650 * @param ev The focus event.
19652 declare var onblur: ((this: Window, ev: FocusEvent) => any) | null;
19653 declare var oncancel: ((this: Window, ev: Event) => any) | null;
19655 * Occurs when playback is possible, but would require further buffering.
19656 * @param ev The event.
19658 declare var oncanplay: ((this: Window, ev: Event) => any) | null;
19659 declare var oncanplaythrough: ((this: Window, ev: Event) => any) | null;
19661 * Fires when the contents of the object or selection have changed.
19662 * @param ev The event.
19664 declare var onchange: ((this: Window, ev: Event) => any) | null;
19666 * Fires when the user clicks the left mouse button on the object
19667 * @param ev The mouse event.
19669 declare var onclick: ((this: Window, ev: MouseEvent) => any) | null;
19670 declare var onclose: ((this: Window, ev: Event) => any) | null;
19672 * Fires when the user clicks the right mouse button in the client area, opening the context menu.
19673 * @param ev The mouse event.
19675 declare var oncontextmenu: ((this: Window, ev: MouseEvent) => any) | null;
19676 declare var oncuechange: ((this: Window, ev: Event) => any) | null;
19678 * Fires when the user double-clicks the object.
19679 * @param ev The mouse event.
19681 declare var ondblclick: ((this: Window, ev: MouseEvent) => any) | null;
19683 * Fires on the source object continuously during a drag operation.
19684 * @param ev The event.
19686 declare var ondrag: ((this: Window, ev: DragEvent) => any) | null;
19688 * Fires on the source object when the user releases the mouse at the close of a drag operation.
19689 * @param ev The event.
19691 declare var ondragend: ((this: Window, ev: DragEvent) => any) | null;
19693 * Fires on the target element when the user drags the object to a valid drop target.
19694 * @param ev The drag event.
19696 declare var ondragenter: ((this: Window, ev: DragEvent) => any) | null;
19697 declare var ondragexit: ((this: Window, ev: Event) => any) | null;
19699 * Fires on the target object when the user moves the mouse out of a valid drop target during a drag operation.
19700 * @param ev The drag event.
19702 declare var ondragleave: ((this: Window, ev: DragEvent) => any) | null;
19704 * Fires on the target element continuously while the user drags the object over a valid drop target.
19705 * @param ev The event.
19707 declare var ondragover: ((this: Window, ev: DragEvent) => any) | null;
19709 * Fires on the source object when the user starts to drag a text selection or selected object.
19710 * @param ev The event.
19712 declare var ondragstart: ((this: Window, ev: DragEvent) => any) | null;
19713 declare var ondrop: ((this: Window, ev: DragEvent) => any) | null;
19715 * Occurs when the duration attribute is updated.
19716 * @param ev The event.
19718 declare var ondurationchange: ((this: Window, ev: Event) => any) | null;
19720 * Occurs when the media element is reset to its initial state.
19721 * @param ev The event.
19723 declare var onemptied: ((this: Window, ev: Event) => any) | null;
19725 * Occurs when the end of playback is reached.
19726 * @param ev The event
19728 declare var onended: ((this: Window, ev: Event) => any) | null;
19730 * Fires when an error occurs during object loading.
19731 * @param ev The event.
19733 declare var onerror: OnErrorEventHandler;
19735 * Fires when the object receives focus.
19736 * @param ev The event.
19738 declare var onfocus: ((this: Window, ev: FocusEvent) => any) | null;
19739 declare var ongotpointercapture: ((this: Window, ev: PointerEvent) => any) | null;
19740 declare var oninput: ((this: Window, ev: Event) => any) | null;
19741 declare var oninvalid: ((this: Window, ev: Event) => any) | null;
19743 * Fires when the user presses a key.
19744 * @param ev The keyboard event
19746 declare var onkeydown: ((this: Window, ev: KeyboardEvent) => any) | null;
19748 * Fires when the user presses an alphanumeric key.
19749 * @param ev The event.
19751 declare var onkeypress: ((this: Window, ev: KeyboardEvent) => any) | null;
19753 * Fires when the user releases a key.
19754 * @param ev The keyboard event
19756 declare var onkeyup: ((this: Window, ev: KeyboardEvent) => any) | null;
19758 * Fires immediately after the browser loads the object.
19759 * @param ev The event.
19761 declare var onload: ((this: Window, ev: Event) => any) | null;
19763 * Occurs when media data is loaded at the current playback position.
19764 * @param ev The event.
19766 declare var onloadeddata: ((this: Window, ev: Event) => any) | null;
19768 * Occurs when the duration and dimensions of the media have been determined.
19769 * @param ev The event.
19771 declare var onloadedmetadata: ((this: Window, ev: Event) => any) | null;
19773 * Occurs when Internet Explorer begins looking for media data.
19774 * @param ev The event.
19776 declare var onloadstart: ((this: Window, ev: Event) => any) | null;
19777 declare var onlostpointercapture: ((this: Window, ev: PointerEvent) => any) | null;
19779 * Fires when the user clicks the object with either mouse button.
19780 * @param ev The mouse event.
19782 declare var onmousedown: ((this: Window, ev: MouseEvent) => any) | null;
19783 declare var onmouseenter: ((this: Window, ev: MouseEvent) => any) | null;
19784 declare var onmouseleave: ((this: Window, ev: MouseEvent) => any) | null;
19786 * Fires when the user moves the mouse over the object.
19787 * @param ev The mouse event.
19789 declare var onmousemove: ((this: Window, ev: MouseEvent) => any) | null;
19791 * Fires when the user moves the mouse pointer outside the boundaries of the object.
19792 * @param ev The mouse event.
19794 declare var onmouseout: ((this: Window, ev: MouseEvent) => any) | null;
19796 * Fires when the user moves the mouse pointer into the object.
19797 * @param ev The mouse event.
19799 declare var onmouseover: ((this: Window, ev: MouseEvent) => any) | null;
19801 * Fires when the user releases a mouse button while the mouse is over the object.
19802 * @param ev The mouse event.
19804 declare var onmouseup: ((this: Window, ev: MouseEvent) => any) | null;
19806 * Occurs when playback is paused.
19807 * @param ev The event.
19809 declare var onpause: ((this: Window, ev: Event) => any) | null;
19811 * Occurs when the play method is requested.
19812 * @param ev The event.
19814 declare var onplay: ((this: Window, ev: Event) => any) | null;
19816 * Occurs when the audio or video has started playing.
19817 * @param ev The event.
19819 declare var onplaying: ((this: Window, ev: Event) => any) | null;
19820 declare var onpointercancel: ((this: Window, ev: PointerEvent) => any) | null;
19821 declare var onpointerdown: ((this: Window, ev: PointerEvent) => any) | null;
19822 declare var onpointerenter: ((this: Window, ev: PointerEvent) => any) | null;
19823 declare var onpointerleave: ((this: Window, ev: PointerEvent) => any) | null;
19824 declare var onpointermove: ((this: Window, ev: PointerEvent) => any) | null;
19825 declare var onpointerout: ((this: Window, ev: PointerEvent) => any) | null;
19826 declare var onpointerover: ((this: Window, ev: PointerEvent) => any) | null;
19827 declare var onpointerup: ((this: Window, ev: PointerEvent) => any) | null;
19829 * Occurs to indicate progress while downloading media data.
19830 * @param ev The event.
19832 declare var onprogress: ((this: Window, ev: ProgressEvent) => any) | null;
19834 * Occurs when the playback rate is increased or decreased.
19835 * @param ev The event.
19837 declare var onratechange: ((this: Window, ev: Event) => any) | null;
19839 * Fires when the user resets a form.
19840 * @param ev The event.
19842 declare var onreset: ((this: Window, ev: Event) => any) | null;
19843 declare var onresize: ((this: Window, ev: UIEvent) => any) | null;
19845 * Fires when the user repositions the scroll box in the scroll bar on the object.
19846 * @param ev The event.
19848 declare var onscroll: ((this: Window, ev: Event) => any) | null;
19849 declare var onsecuritypolicyviolation: ((this: Window, ev: SecurityPolicyViolationEvent) => any) | null;
19851 * Occurs when the seek operation ends.
19852 * @param ev The event.
19854 declare var onseeked: ((this: Window, ev: Event) => any) | null;
19856 * Occurs when the current playback position is moved.
19857 * @param ev The event.
19859 declare var onseeking: ((this: Window, ev: Event) => any) | null;
19861 * Fires when the current selection changes.
19862 * @param ev The event.
19864 declare var onselect: ((this: Window, ev: Event) => any) | null;
19865 declare var onselectionchange: ((this: Window, ev: Event) => any) | null;
19866 declare var onselectstart: ((this: Window, ev: Event) => any) | null;
19868 * Occurs when the download has stopped.
19869 * @param ev The event.
19871 declare var onstalled: ((this: Window, ev: Event) => any) | null;
19872 declare var onsubmit: ((this: Window, ev: Event) => any) | null;
19874 * Occurs if the load operation has been intentionally halted.
19875 * @param ev The event.
19877 declare var onsuspend: ((this: Window, ev: Event) => any) | null;
19879 * Occurs to indicate the current playback position.
19880 * @param ev The event.
19882 declare var ontimeupdate: ((this: Window, ev: Event) => any) | null;
19883 declare var ontoggle: ((this: Window, ev: Event) => any) | null;
19884 declare var ontouchcancel: ((this: Window, ev: TouchEvent) => any) | null | undefined;
19885 declare var ontouchend: ((this: Window, ev: TouchEvent) => any) | null | undefined;
19886 declare var ontouchmove: ((this: Window, ev: TouchEvent) => any) | null | undefined;
19887 declare var ontouchstart: ((this: Window, ev: TouchEvent) => any) | null | undefined;
19888 declare var ontransitioncancel: ((this: Window, ev: TransitionEvent) => any) | null;
19889 declare var ontransitionend: ((this: Window, ev: TransitionEvent) => any) | null;
19890 declare var ontransitionrun: ((this: Window, ev: TransitionEvent) => any) | null;
19891 declare var ontransitionstart: ((this: Window, ev: TransitionEvent) => any) | null;
19893 * Occurs when the volume is changed, or playback is muted or unmuted.
19894 * @param ev The event.
19896 declare var onvolumechange: ((this: Window, ev: Event) => any) | null;
19898 * Occurs when playback stops because the next frame of a video resource is not available.
19899 * @param ev The event.
19901 declare var onwaiting: ((this: Window, ev: Event) => any) | null;
19902 declare var onwheel: ((this: Window, ev: WheelEvent) => any) | null;
19903 declare function cancelAnimationFrame(handle: number): void;
19904 declare function requestAnimationFrame(callback: FrameRequestCallback): number;
19905 declare var caches: CacheStorage;
19906 declare var crypto: Crypto;
19907 declare var indexedDB: IDBFactory;
19908 declare var isSecureContext: boolean;
19909 declare var origin: string;
19910 declare var performance: Performance;
19911 declare function atob(data: string): string;
19912 declare function btoa(data: string): string;
19913 declare function clearInterval(handle?: number): void;
19914 declare function clearTimeout(handle?: number): void;
19915 declare function createImageBitmap(image: ImageBitmapSource, options?: ImageBitmapOptions): Promise<ImageBitmap>;
19916 declare function createImageBitmap(image: ImageBitmapSource, sx: number, sy: number, sw: number, sh: number, options?: ImageBitmapOptions): Promise<ImageBitmap>;
19917 declare function fetch(input: RequestInfo, init?: RequestInit): Promise<Response>;
19918 declare function queueMicrotask(callback: VoidFunction): void;
19919 declare function setInterval(handler: TimerHandler, timeout?: number, ...arguments: any[]): number;
19920 declare function setTimeout(handler: TimerHandler, timeout?: number, ...arguments: any[]): number;
19921 declare var onafterprint: ((this: Window, ev: Event) => any) | null;
19922 declare var onbeforeprint: ((this: Window, ev: Event) => any) | null;
19923 declare var onbeforeunload: ((this: Window, ev: BeforeUnloadEvent) => any) | null;
19924 declare var onhashchange: ((this: Window, ev: HashChangeEvent) => any) | null;
19925 declare var onlanguagechange: ((this: Window, ev: Event) => any) | null;
19926 declare var onmessage: ((this: Window, ev: MessageEvent) => any) | null;
19927 declare var onmessageerror: ((this: Window, ev: MessageEvent) => any) | null;
19928 declare var onoffline: ((this: Window, ev: Event) => any) | null;
19929 declare var ononline: ((this: Window, ev: Event) => any) | null;
19930 declare var onpagehide: ((this: Window, ev: PageTransitionEvent) => any) | null;
19931 declare var onpageshow: ((this: Window, ev: PageTransitionEvent) => any) | null;
19932 declare var onpopstate: ((this: Window, ev: PopStateEvent) => any) | null;
19933 declare var onrejectionhandled: ((this: Window, ev: PromiseRejectionEvent) => any) | null;
19934 declare var onstorage: ((this: Window, ev: StorageEvent) => any) | null;
19935 declare var onunhandledrejection: ((this: Window, ev: PromiseRejectionEvent) => any) | null;
19936 declare var onunload: ((this: Window, ev: Event) => any) | null;
19937 declare function addEventListener<K extends keyof WindowEventMap>(type: K, listener: (this: Window, ev: WindowEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
19938 declare function addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
19939 declare function removeEventListener<K extends keyof WindowEventMap>(type: K, listener: (this: Window, ev: WindowEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
19940 declare function removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
19941 type HeadersInit = Headers | string[][] | Record<string, string>;
19942 type BodyInit = Blob | BufferSource | FormData | URLSearchParams | ReadableStream<Uint8Array> | string;
19943 type RequestInfo = Request | string;
19944 type BlobPart = BufferSource | Blob | string;
19945 type DOMHighResTimeStamp = number;
19946 type RenderingContext = CanvasRenderingContext2D | ImageBitmapRenderingContext | WebGLRenderingContext | WebGL2RenderingContext;
19947 type HTMLOrSVGImageElement = HTMLImageElement | SVGImageElement;
19948 type CanvasImageSource = HTMLOrSVGImageElement | HTMLVideoElement | HTMLCanvasElement | ImageBitmap | OffscreenCanvas;
19949 type OffscreenRenderingContext = OffscreenCanvasRenderingContext2D | ImageBitmapRenderingContext | WebGLRenderingContext | WebGL2RenderingContext;
19950 type MessageEventSource = WindowProxy | MessagePort | ServiceWorker;
19951 type HTMLOrSVGScriptElement = HTMLScriptElement | SVGScriptElement;
19952 type ImageBitmapSource = CanvasImageSource | Blob | ImageData;
19953 type MediaProvider = MediaStream | MediaSource | Blob;
19954 type OnErrorEventHandler = OnErrorEventHandlerNonNull | null;
19955 type OnBeforeUnloadEventHandler = OnBeforeUnloadEventHandlerNonNull | null;
19956 type TimerHandler = string | Function;
19957 type ConstrainULong = number | ConstrainULongRange;
19958 type ConstrainDouble = number | ConstrainDoubleRange;
19959 type ConstrainBoolean = boolean | ConstrainBooleanParameters;
19960 type ConstrainDOMString = string | string[] | ConstrainDOMStringParameters;
19961 type PerformanceEntryList = PerformanceEntry[];
19962 type ReadableStreamReadResult<T> = ReadableStreamReadValueResult<T> | ReadableStreamReadDoneResult<T>;
19963 type VibratePattern = number | number[];
19964 type COSEAlgorithmIdentifier = number;
19965 type UvmEntry = number[];
19966 type UvmEntries = UvmEntry[];
19967 type AlgorithmIdentifier = string | Algorithm;
19968 type HashAlgorithmIdentifier = AlgorithmIdentifier;
19969 type BigInteger = Uint8Array;
19970 type NamedCurve = string;
19971 type GLenum = number;
19972 type GLboolean = boolean;
19973 type GLbitfield = number;
19974 type GLint = number;
19975 type GLsizei = number;
19976 type GLintptr = number;
19977 type GLsizeiptr = number;
19978 type GLuint = number;
19979 type GLfloat = number;
19980 type GLclampf = number;
19981 type TexImageSource = ImageBitmap | ImageData | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement | OffscreenCanvas;
19982 type Float32List = Float32Array | GLfloat[];
19983 type Int32List = Int32Array | GLint[];
19984 type GLint64 = number;
19985 type GLuint64 = number;
19986 type Uint32List = Uint32Array | GLuint[];
19987 type BufferSource = ArrayBufferView | ArrayBuffer;
19988 type DOMTimeStamp = number;
19989 type LineAndPositionSetting = number | AutoKeyword;
19990 type FormDataEntryValue = File | string;
19991 type InsertPosition = "beforebegin" | "afterbegin" | "beforeend" | "afterend";
19992 type IDBValidKey = number | string | Date | BufferSource | IDBArrayKey;
19993 type MutationRecordType = "attributes" | "characterData" | "childList";
19994 type IDBKeyPath = string;
19995 type Transferable = ArrayBuffer | MessagePort | ImageBitmap | OffscreenCanvas;
19996 type RTCIceGatherCandidate = RTCIceCandidateDictionary | RTCIceCandidateComplete;
19997 type RTCTransport = RTCDtlsTransport | RTCSrtpSdesTransport;
19999 type MouseWheelEvent = WheelEvent;
20000 type WindowProxy = Window;
20001 type AlignSetting = "center" | "end" | "left" | "right" | "start";
20002 type AnimationPlayState = "finished" | "idle" | "paused" | "running";
20003 type AppendMode = "segments" | "sequence";
20004 type AttestationConveyancePreference = "direct" | "enterprise" | "indirect" | "none";
20005 type AudioContextLatencyCategory = "balanced" | "interactive" | "playback";
20006 type AudioContextState = "closed" | "running" | "suspended";
20007 type AuthenticatorAttachment = "cross-platform" | "platform";
20008 type AuthenticatorTransport = "ble" | "internal" | "nfc" | "usb";
20009 type AutoKeyword = "auto";
20010 type AutomationRate = "a-rate" | "k-rate";
20011 type BinaryType = "arraybuffer" | "blob";
20012 type BiquadFilterType = "allpass" | "bandpass" | "highpass" | "highshelf" | "lowpass" | "lowshelf" | "notch" | "peaking";
20013 type CanPlayTypeResult = "" | "maybe" | "probably";
20014 type CanvasDirection = "inherit" | "ltr" | "rtl";
20015 type CanvasFillRule = "evenodd" | "nonzero";
20016 type CanvasLineCap = "butt" | "round" | "square";
20017 type CanvasLineJoin = "bevel" | "miter" | "round";
20018 type CanvasTextAlign = "center" | "end" | "left" | "right" | "start";
20019 type CanvasTextBaseline = "alphabetic" | "bottom" | "hanging" | "ideographic" | "middle" | "top";
20020 type ChannelCountMode = "clamped-max" | "explicit" | "max";
20021 type ChannelInterpretation = "discrete" | "speakers";
20022 type ClientTypes = "all" | "sharedworker" | "window" | "worker";
20023 type ColorSpaceConversion = "default" | "none";
20024 type CompositeOperation = "accumulate" | "add" | "replace";
20025 type CompositeOperationOrAuto = "accumulate" | "add" | "auto" | "replace";
20026 type CredentialMediationRequirement = "optional" | "required" | "silent";
20027 type DOMParserSupportedType = "application/xhtml+xml" | "application/xml" | "image/svg+xml" | "text/html" | "text/xml";
20028 type DirectionSetting = "" | "lr" | "rl";
20029 type DisplayCaptureSurfaceType = "application" | "browser" | "monitor" | "window";
20030 type DistanceModelType = "exponential" | "inverse" | "linear";
20031 type DocumentReadyState = "complete" | "interactive" | "loading";
20032 type EndOfStreamError = "decode" | "network";
20033 type EndingType = "native" | "transparent";
20034 type FillMode = "auto" | "backwards" | "both" | "forwards" | "none";
20035 type FullscreenNavigationUI = "auto" | "hide" | "show";
20036 type GamepadHand = "" | "left" | "right";
20037 type GamepadHapticActuatorType = "vibration";
20038 type GamepadMappingType = "" | "standard";
20039 type IDBCursorDirection = "next" | "nextunique" | "prev" | "prevunique";
20040 type IDBRequestReadyState = "done" | "pending";
20041 type IDBTransactionMode = "readonly" | "readwrite" | "versionchange";
20042 type ImageOrientation = "flipY" | "none";
20043 type ImageSmoothingQuality = "high" | "low" | "medium";
20044 type IterationCompositeOperation = "accumulate" | "replace";
20045 type KeyFormat = "jwk" | "pkcs8" | "raw" | "spki";
20046 type KeyType = "private" | "public" | "secret";
20047 type KeyUsage = "decrypt" | "deriveBits" | "deriveKey" | "encrypt" | "sign" | "unwrapKey" | "verify" | "wrapKey";
20048 type LineAlignSetting = "center" | "end" | "start";
20049 type ListeningState = "active" | "disambiguation" | "inactive";
20050 type MSCredentialType = "FIDO_2_0";
20051 type MSTransportType = "BT" | "Embedded" | "NFC" | "USB";
20052 type MSWebViewPermissionState = "allow" | "defer" | "deny" | "unknown";
20053 type MSWebViewPermissionType = "geolocation" | "media" | "pointerlock" | "unlimitedIndexedDBQuota" | "webnotifications";
20054 type MediaDeviceKind = "audioinput" | "audiooutput" | "videoinput";
20055 type MediaKeyMessageType = "individualization-request" | "license-release" | "license-renewal" | "license-request";
20056 type MediaKeySessionType = "persistent-license" | "temporary";
20057 type MediaKeyStatus = "expired" | "internal-error" | "output-downscaled" | "output-restricted" | "released" | "status-pending" | "usable";
20058 type MediaKeysRequirement = "not-allowed" | "optional" | "required";
20059 type MediaStreamTrackState = "ended" | "live";
20060 type NavigationReason = "down" | "left" | "right" | "up";
20061 type NavigationType = "back_forward" | "navigate" | "prerender" | "reload";
20062 type NotificationDirection = "auto" | "ltr" | "rtl";
20063 type NotificationPermission = "default" | "denied" | "granted";
20064 type OffscreenRenderingContextId = "2d" | "bitmaprenderer" | "webgl" | "webgl2";
20065 type OrientationLockType = "any" | "landscape" | "landscape-primary" | "landscape-secondary" | "natural" | "portrait" | "portrait-primary" | "portrait-secondary";
20066 type OrientationType = "landscape-primary" | "landscape-secondary" | "portrait-primary" | "portrait-secondary";
20067 type OscillatorType = "custom" | "sawtooth" | "sine" | "square" | "triangle";
20068 type OverSampleType = "2x" | "4x" | "none";
20069 type PanningModelType = "HRTF" | "equalpower";
20070 type PaymentComplete = "fail" | "success" | "unknown";
20071 type PaymentShippingType = "delivery" | "pickup" | "shipping";
20072 type PermissionName = "accelerometer" | "ambient-light-sensor" | "background-sync" | "bluetooth" | "camera" | "clipboard" | "device-info" | "geolocation" | "gyroscope" | "magnetometer" | "microphone" | "midi" | "notifications" | "persistent-storage" | "push" | "speaker";
20073 type PermissionState = "denied" | "granted" | "prompt";
20074 type PlaybackDirection = "alternate" | "alternate-reverse" | "normal" | "reverse";
20075 type PositionAlignSetting = "auto" | "center" | "line-left" | "line-right";
20076 type PremultiplyAlpha = "default" | "none" | "premultiply";
20077 type PublicKeyCredentialType = "public-key";
20078 type PushEncryptionKeyName = "auth" | "p256dh";
20079 type PushPermissionState = "denied" | "granted" | "prompt";
20080 type RTCBundlePolicy = "balanced" | "max-bundle" | "max-compat";
20081 type RTCDataChannelState = "closed" | "closing" | "connecting" | "open";
20082 type RTCDegradationPreference = "balanced" | "maintain-framerate" | "maintain-resolution";
20083 type RTCDtlsRole = "auto" | "client" | "server";
20084 type RTCDtlsTransportState = "closed" | "connected" | "connecting" | "failed" | "new";
20085 type RTCDtxStatus = "disabled" | "enabled";
20086 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";
20087 type RTCIceCandidateType = "host" | "prflx" | "relay" | "srflx";
20088 type RTCIceComponent = "rtcp" | "rtp";
20089 type RTCIceConnectionState = "checking" | "closed" | "completed" | "connected" | "disconnected" | "failed" | "new";
20090 type RTCIceCredentialType = "oauth" | "password";
20091 type RTCIceGatherPolicy = "all" | "nohost" | "relay";
20092 type RTCIceGathererState = "complete" | "gathering" | "new";
20093 type RTCIceGatheringState = "complete" | "gathering" | "new";
20094 type RTCIceProtocol = "tcp" | "udp";
20095 type RTCIceRole = "controlled" | "controlling" | "unknown";
20096 type RTCIceTcpCandidateType = "active" | "passive" | "so";
20097 type RTCIceTransportPolicy = "all" | "relay";
20098 type RTCIceTransportState = "checking" | "closed" | "completed" | "connected" | "disconnected" | "failed" | "new";
20099 type RTCPeerConnectionState = "closed" | "connected" | "connecting" | "disconnected" | "failed" | "new";
20100 type RTCPriorityType = "high" | "low" | "medium" | "very-low";
20101 type RTCRtcpMuxPolicy = "negotiate" | "require";
20102 type RTCRtpTransceiverDirection = "inactive" | "recvonly" | "sendonly" | "sendrecv" | "stopped";
20103 type RTCSctpTransportState = "closed" | "connected" | "connecting";
20104 type RTCSdpType = "answer" | "offer" | "pranswer" | "rollback";
20105 type RTCSignalingState = "closed" | "have-local-offer" | "have-local-pranswer" | "have-remote-offer" | "have-remote-pranswer" | "stable";
20106 type RTCStatsIceCandidatePairState = "cancelled" | "failed" | "frozen" | "inprogress" | "succeeded" | "waiting";
20107 type RTCStatsIceCandidateType = "host" | "peerreflexive" | "relayed" | "serverreflexive";
20108 type RTCStatsType = "candidatepair" | "datachannel" | "inboundrtp" | "localcandidate" | "outboundrtp" | "remotecandidate" | "session" | "track" | "transport";
20109 type ReadyState = "closed" | "ended" | "open";
20110 type ReferrerPolicy = "" | "no-referrer" | "no-referrer-when-downgrade" | "origin" | "origin-when-cross-origin" | "same-origin" | "strict-origin" | "strict-origin-when-cross-origin" | "unsafe-url";
20111 type RequestCache = "default" | "force-cache" | "no-cache" | "no-store" | "only-if-cached" | "reload";
20112 type RequestCredentials = "include" | "omit" | "same-origin";
20113 type RequestDestination = "" | "audio" | "audioworklet" | "document" | "embed" | "font" | "image" | "manifest" | "object" | "paintworklet" | "report" | "script" | "sharedworker" | "style" | "track" | "video" | "worker" | "xslt";
20114 type RequestMode = "cors" | "navigate" | "no-cors" | "same-origin";
20115 type RequestRedirect = "error" | "follow" | "manual";
20116 type ResidentKeyRequirement = "discouraged" | "preferred" | "required";
20117 type ResizeQuality = "high" | "low" | "medium" | "pixelated";
20118 type ResponseType = "basic" | "cors" | "default" | "error" | "opaque" | "opaqueredirect";
20119 type ScopedCredentialType = "ScopedCred";
20120 type ScrollBehavior = "auto" | "smooth";
20121 type ScrollLogicalPosition = "center" | "end" | "nearest" | "start";
20122 type ScrollRestoration = "auto" | "manual";
20123 type ScrollSetting = "" | "up";
20124 type SelectionMode = "end" | "preserve" | "select" | "start";
20125 type ServiceWorkerState = "activated" | "activating" | "installed" | "installing" | "parsed" | "redundant";
20126 type ServiceWorkerUpdateViaCache = "all" | "imports" | "none";
20127 type ShadowRootMode = "closed" | "open";
20128 type SpeechSynthesisErrorCode = "audio-busy" | "audio-hardware" | "canceled" | "interrupted" | "invalid-argument" | "language-unavailable" | "network" | "not-allowed" | "synthesis-failed" | "synthesis-unavailable" | "text-too-long" | "voice-unavailable";
20129 type TextTrackKind = "captions" | "chapters" | "descriptions" | "metadata" | "subtitles";
20130 type TextTrackMode = "disabled" | "hidden" | "showing";
20131 type TouchType = "direct" | "stylus";
20132 type Transport = "ble" | "nfc" | "usb";
20133 type UserVerificationRequirement = "discouraged" | "preferred" | "required";
20134 type VRDisplayEventReason = "mounted" | "navigation" | "requested" | "unmounted";
20135 type VideoFacingModeEnum = "environment" | "left" | "right" | "user";
20136 type VisibilityState = "hidden" | "visible";
20137 type WebGLPowerPreference = "default" | "high-performance" | "low-power";
20138 type WorkerType = "classic" | "module";
20139 type XMLHttpRequestResponseType = "" | "arraybuffer" | "blob" | "document" | "json" | "text";