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 ImportMeta {
621 interface InputEventInit extends UIEventInit {
622 data?: string | null;
624 isComposing?: boolean;
627 interface IntersectionObserverEntryInit {
628 boundingClientRect: DOMRectInit;
629 intersectionRatio: number;
630 intersectionRect: DOMRectInit;
631 isIntersecting: boolean;
632 rootBounds: DOMRectInit | null;
637 interface IntersectionObserverInit {
638 root?: Element | Document | null;
640 threshold?: number | number[];
643 interface JsonWebKey {
655 oth?: RsaOtherPrimesInfo[];
664 interface KeyAlgorithm {
668 interface KeyboardEventInit extends EventModifierInit {
672 isComposing?: boolean;
681 composite?: CompositeOperationOrAuto;
683 offset?: number | null;
684 [property: string]: string | number | null | undefined;
687 interface KeyframeAnimationOptions extends KeyframeEffectOptions {
691 interface KeyframeEffectOptions extends EffectTiming {
692 composite?: CompositeOperation;
693 iterationComposite?: IterationCompositeOperation;
696 interface MediaElementAudioSourceOptions {
697 mediaElement: HTMLMediaElement;
700 interface MediaEncryptedEventInit extends EventInit {
701 initData?: ArrayBuffer | null;
702 initDataType?: string;
705 interface MediaKeyMessageEventInit extends EventInit {
706 message: ArrayBuffer;
707 messageType: MediaKeyMessageType;
710 interface MediaKeySystemConfiguration {
711 audioCapabilities?: MediaKeySystemMediaCapability[];
712 distinctiveIdentifier?: MediaKeysRequirement;
713 initDataTypes?: string[];
715 persistentState?: MediaKeysRequirement;
716 sessionTypes?: string[];
717 videoCapabilities?: MediaKeySystemMediaCapability[];
720 interface MediaKeySystemMediaCapability {
721 contentType?: string;
725 interface MediaQueryListEventInit extends EventInit {
730 interface MediaStreamAudioSourceOptions {
731 mediaStream: MediaStream;
734 interface MediaStreamConstraints {
735 audio?: boolean | MediaTrackConstraints;
736 peerIdentity?: string;
737 video?: boolean | MediaTrackConstraints;
740 interface MediaStreamErrorEventInit extends EventInit {
741 error?: MediaStreamError | null;
744 interface MediaStreamEventInit extends EventInit {
745 stream?: MediaStream;
748 interface MediaStreamTrackAudioSourceOptions {
749 mediaStreamTrack: MediaStreamTrack;
752 interface MediaStreamTrackEventInit extends EventInit {
753 track: MediaStreamTrack;
756 interface MediaTrackCapabilities {
757 aspectRatio?: DoubleRange;
758 autoGainControl?: boolean[];
759 channelCount?: ULongRange;
761 echoCancellation?: boolean[];
762 facingMode?: string[];
763 frameRate?: DoubleRange;
766 latency?: DoubleRange;
767 noiseSuppression?: boolean[];
768 resizeMode?: string[];
769 sampleRate?: ULongRange;
770 sampleSize?: ULongRange;
774 interface MediaTrackConstraintSet {
775 aspectRatio?: ConstrainDouble;
776 autoGainControl?: ConstrainBoolean;
777 channelCount?: ConstrainULong;
778 deviceId?: ConstrainDOMString;
779 echoCancellation?: ConstrainBoolean;
780 facingMode?: ConstrainDOMString;
781 frameRate?: ConstrainDouble;
782 groupId?: ConstrainDOMString;
783 height?: ConstrainULong;
784 latency?: ConstrainDouble;
785 noiseSuppression?: ConstrainBoolean;
786 resizeMode?: ConstrainDOMString;
787 sampleRate?: ConstrainULong;
788 sampleSize?: ConstrainULong;
789 width?: ConstrainULong;
792 interface MediaTrackConstraints extends MediaTrackConstraintSet {
793 advanced?: MediaTrackConstraintSet[];
796 interface MediaTrackSettings {
797 aspectRatio?: number;
798 autoGainControl?: boolean;
799 channelCount?: number;
801 echoCancellation?: boolean;
807 noiseSuppression?: boolean;
814 interface MediaTrackSupportedConstraints {
815 aspectRatio?: boolean;
816 autoGainControl?: boolean;
817 channelCount?: boolean;
819 echoCancellation?: boolean;
820 facingMode?: boolean;
825 noiseSuppression?: boolean;
826 resizeMode?: boolean;
827 sampleRate?: boolean;
828 sampleSize?: boolean;
832 interface MessageEventInit<T = any> extends EventInit {
834 lastEventId?: string;
836 ports?: MessagePort[];
837 source?: MessageEventSource | null;
840 interface MidiPermissionDescriptor extends PermissionDescriptor {
845 interface MouseEventInit extends EventModifierInit {
852 relatedTarget?: EventTarget | null;
857 interface MultiCacheQueryOptions extends CacheQueryOptions {
861 interface MutationObserverInit {
863 * Set to a list of attribute local names (without namespace) if not all attribute mutations need to be observed and attributes is true or omitted.
865 attributeFilter?: string[];
867 * Set to true if attributes is true or omitted and target's attribute value before the mutation needs to be recorded.
869 attributeOldValue?: boolean;
871 * Set to true if mutations to target's attributes are to be observed. Can be omitted if attributeOldValue or attributeFilter is specified.
873 attributes?: boolean;
875 * Set to true if mutations to target's data are to be observed. Can be omitted if characterDataOldValue is specified.
877 characterData?: boolean;
879 * Set to true if characterData is set to true or omitted and target's data before the mutation needs to be recorded.
881 characterDataOldValue?: boolean;
883 * Set to true if mutations to target's children are to be observed.
887 * Set to true if mutations to not just target, but also target's descendants are to be observed.
892 interface NavigationPreloadState {
894 headerValue?: string;
897 interface NotificationAction {
903 interface NotificationOptions {
904 actions?: NotificationAction[];
908 dir?: NotificationDirection;
913 requireInteraction?: boolean;
917 vibrate?: VibratePattern;
920 interface OfflineAudioCompletionEventInit extends EventInit {
921 renderedBuffer: AudioBuffer;
924 interface OfflineAudioContextOptions {
926 numberOfChannels?: number;
930 interface OptionalEffectTiming {
932 direction?: PlaybackDirection;
933 duration?: number | string;
937 iterationStart?: number;
941 interface OscillatorOptions extends AudioNodeOptions {
944 periodicWave?: PeriodicWave;
945 type?: OscillatorType;
948 interface PageTransitionEventInit extends EventInit {
952 interface PannerOptions extends AudioNodeOptions {
953 coneInnerAngle?: number;
954 coneOuterAngle?: number;
955 coneOuterGain?: number;
956 distanceModel?: DistanceModelType;
957 maxDistance?: number;
958 orientationX?: number;
959 orientationY?: number;
960 orientationZ?: number;
961 panningModel?: PanningModelType;
965 refDistance?: number;
966 rolloffFactor?: number;
969 interface PaymentCurrencyAmount {
971 currencySystem?: string;
975 interface PaymentDetailsBase {
976 displayItems?: PaymentItem[];
977 modifiers?: PaymentDetailsModifier[];
978 shippingOptions?: PaymentShippingOption[];
981 interface PaymentDetailsInit extends PaymentDetailsBase {
986 interface PaymentDetailsModifier {
987 additionalDisplayItems?: PaymentItem[];
989 supportedMethods: string | string[];
993 interface PaymentDetailsUpdate extends PaymentDetailsBase {
998 interface PaymentItem {
999 amount: PaymentCurrencyAmount;
1004 interface PaymentMethodData {
1006 supportedMethods: string | string[];
1009 interface PaymentOptions {
1010 requestPayerEmail?: boolean;
1011 requestPayerName?: boolean;
1012 requestPayerPhone?: boolean;
1013 requestShipping?: boolean;
1014 shippingType?: string;
1017 interface PaymentRequestUpdateEventInit extends EventInit {
1020 interface PaymentShippingOption {
1021 amount: PaymentCurrencyAmount;
1027 interface Pbkdf2Params extends Algorithm {
1028 hash: HashAlgorithmIdentifier;
1030 salt: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;
1033 interface PerformanceObserverInit {
1035 entryTypes?: string[];
1039 interface PeriodicWaveConstraints {
1040 disableNormalization?: boolean;
1043 interface PeriodicWaveOptions extends PeriodicWaveConstraints {
1044 imag?: number[] | Float32Array;
1045 real?: number[] | Float32Array;
1048 interface PermissionDescriptor {
1049 name: PermissionName;
1052 interface PointerEventInit extends MouseEventInit {
1053 coalescedEvents?: PointerEvent[];
1055 isPrimary?: boolean;
1057 pointerType?: string;
1058 predictedEvents?: PointerEvent[];
1060 tangentialPressure?: number;
1067 interface PopStateEventInit extends EventInit {
1071 interface PositionOptions {
1072 enableHighAccuracy?: boolean;
1073 maximumAge?: number;
1077 interface PostMessageOptions {
1081 interface ProgressEventInit extends EventInit {
1082 lengthComputable?: boolean;
1087 interface PromiseRejectionEventInit extends EventInit {
1088 promise: Promise<any>;
1092 interface PropertyIndexedKeyframes {
1093 composite?: CompositeOperationOrAuto | CompositeOperationOrAuto[];
1094 easing?: string | string[];
1095 offset?: number | (number | null)[];
1096 [property: string]: string | string[] | number | null | (number | null)[] | undefined;
1099 interface PublicKeyCredentialCreationOptions {
1100 attestation?: AttestationConveyancePreference;
1101 authenticatorSelection?: AuthenticatorSelectionCriteria;
1102 challenge: BufferSource;
1103 excludeCredentials?: PublicKeyCredentialDescriptor[];
1104 extensions?: AuthenticationExtensionsClientInputs;
1105 pubKeyCredParams: PublicKeyCredentialParameters[];
1106 rp: PublicKeyCredentialRpEntity;
1108 user: PublicKeyCredentialUserEntity;
1111 interface PublicKeyCredentialDescriptor {
1113 transports?: AuthenticatorTransport[];
1114 type: PublicKeyCredentialType;
1117 interface PublicKeyCredentialEntity {
1121 interface PublicKeyCredentialParameters {
1122 alg: COSEAlgorithmIdentifier;
1123 type: PublicKeyCredentialType;
1126 interface PublicKeyCredentialRequestOptions {
1127 allowCredentials?: PublicKeyCredentialDescriptor[];
1128 challenge: BufferSource;
1129 extensions?: AuthenticationExtensionsClientInputs;
1132 userVerification?: UserVerificationRequirement;
1135 interface PublicKeyCredentialRpEntity extends PublicKeyCredentialEntity {
1139 interface PublicKeyCredentialUserEntity extends PublicKeyCredentialEntity {
1140 displayName: string;
1144 interface PushPermissionDescriptor extends PermissionDescriptor {
1146 userVisibleOnly?: boolean;
1149 interface PushSubscriptionJSON {
1151 expirationTime?: number | null;
1152 keys?: Record<string, string>;
1155 interface PushSubscriptionOptionsInit {
1156 applicationServerKey?: BufferSource | string | null;
1157 userVisibleOnly?: boolean;
1160 interface QueuingStrategy<T = any> {
1161 highWaterMark?: number;
1162 size?: QueuingStrategySize<T>;
1165 interface QueuingStrategyInit {
1167 * Creates a new ByteLengthQueuingStrategy with the provided high water mark.
1169 * Note that the provided high water mark will not be validated ahead of time. Instead, if it is negative, NaN, or not a number, the resulting ByteLengthQueuingStrategy will cause the corresponding stream constructor to throw.
1171 highWaterMark: number;
1174 interface RTCAnswerOptions extends RTCOfferAnswerOptions {
1177 interface RTCCertificateExpiration {
1181 interface RTCConfiguration {
1182 bundlePolicy?: RTCBundlePolicy;
1183 certificates?: RTCCertificate[];
1184 iceCandidatePoolSize?: number;
1185 iceServers?: RTCIceServer[];
1186 iceTransportPolicy?: RTCIceTransportPolicy;
1187 peerIdentity?: string;
1188 rtcpMuxPolicy?: RTCRtcpMuxPolicy;
1191 interface RTCDTMFToneChangeEventInit extends EventInit {
1195 interface RTCDataChannelEventInit extends EventInit {
1196 channel: RTCDataChannel;
1199 interface RTCDataChannelInit {
1201 maxPacketLifeTime?: number;
1202 maxRetransmits?: number;
1203 negotiated?: boolean;
1205 priority?: RTCPriorityType;
1209 interface RTCDtlsFingerprint {
1214 interface RTCDtlsParameters {
1215 fingerprints?: RTCDtlsFingerprint[];
1219 interface RTCErrorEventInit extends EventInit {
1223 interface RTCErrorInit {
1224 errorDetail: RTCErrorDetailType;
1225 httpRequestStatusCode?: number;
1226 receivedAlert?: number;
1227 sctpCauseCode?: number;
1228 sdpLineNumber?: number;
1232 interface RTCIceCandidateAttributes extends RTCStats {
1233 addressSourceUrl?: string;
1234 candidateType?: RTCStatsIceCandidateType;
1236 portNumber?: number;
1241 interface RTCIceCandidateComplete {
1244 interface RTCIceCandidateDictionary {
1245 foundation?: string;
1247 msMTurnSessionId?: string;
1250 protocol?: RTCIceProtocol;
1251 relatedAddress?: string;
1252 relatedPort?: number;
1253 tcpType?: RTCIceTcpCandidateType;
1254 type?: RTCIceCandidateType;
1257 interface RTCIceCandidateInit {
1259 sdpMLineIndex?: number | null;
1260 sdpMid?: string | null;
1261 usernameFragment?: string | null;
1264 interface RTCIceCandidatePair {
1265 local?: RTCIceCandidate;
1266 remote?: RTCIceCandidate;
1269 interface RTCIceCandidatePairStats extends RTCStats {
1270 availableIncomingBitrate?: number;
1271 availableOutgoingBitrate?: number;
1272 bytesDiscardedOnSend?: number;
1273 bytesReceived?: number;
1275 circuitBreakerTriggerCount?: number;
1276 consentExpiredTimestamp?: number;
1277 consentRequestsSent?: number;
1278 currentRoundTripTime?: number;
1279 currentRtt?: number;
1280 firstRequestTimestamp?: number;
1281 lastPacketReceivedTimestamp?: number;
1282 lastPacketSentTimestamp?: number;
1283 lastRequestTimestamp?: number;
1284 lastResponseTimestamp?: number;
1285 localCandidateId?: string;
1286 nominated?: boolean;
1287 packetsDiscardedOnSend?: number;
1288 packetsReceived?: number;
1289 packetsSent?: number;
1291 remoteCandidateId?: string;
1292 requestsReceived?: number;
1293 requestsSent?: number;
1294 responsesReceived?: number;
1295 responsesSent?: number;
1296 retransmissionsReceived?: number;
1297 retransmissionsSent?: number;
1298 state?: RTCStatsIceCandidatePairState;
1299 totalRoundTripTime?: number;
1301 transportId?: string;
1304 interface RTCIceGatherOptions {
1305 gatherPolicy?: RTCIceGatherPolicy;
1306 iceservers?: RTCIceServer[];
1309 interface RTCIceParameters {
1311 usernameFragment?: string;
1314 interface RTCIceServer {
1315 credential?: string | RTCOAuthCredential;
1316 credentialType?: RTCIceCredentialType;
1317 urls: string | string[];
1321 interface RTCIdentityProviderOptions {
1322 peerIdentity?: string;
1324 usernameHint?: string;
1327 interface RTCInboundRTPStreamStats extends RTCRTPStreamStats {
1328 bytesReceived?: number;
1329 fractionLost?: number;
1331 packetsLost?: number;
1332 packetsReceived?: number;
1335 interface RTCMediaStreamTrackStats extends RTCStats {
1336 audioLevel?: number;
1337 echoReturnLoss?: number;
1338 echoReturnLossEnhancement?: number;
1339 frameHeight?: number;
1340 frameWidth?: number;
1341 framesCorrupted?: number;
1342 framesDecoded?: number;
1343 framesDropped?: number;
1344 framesPerSecond?: number;
1345 framesReceived?: number;
1346 framesSent?: number;
1347 remoteSource?: boolean;
1349 trackIdentifier?: string;
1352 interface RTCOAuthCredential {
1353 accessToken: string;
1357 interface RTCOfferAnswerOptions {
1358 voiceActivityDetection?: boolean;
1361 interface RTCOfferOptions extends RTCOfferAnswerOptions {
1362 iceRestart?: boolean;
1363 offerToReceiveAudio?: boolean;
1364 offerToReceiveVideo?: boolean;
1367 interface RTCOutboundRTPStreamStats extends RTCRTPStreamStats {
1369 packetsSent?: number;
1370 roundTripTime?: number;
1371 targetBitrate?: number;
1374 interface RTCPeerConnectionIceErrorEventInit extends EventInit {
1376 hostCandidate?: string;
1377 statusText?: string;
1381 interface RTCPeerConnectionIceEventInit extends EventInit {
1382 candidate?: RTCIceCandidate | null;
1383 url?: string | null;
1386 interface RTCRTPStreamStats extends RTCStats {
1387 associateStatsId?: string;
1391 mediaTrackId?: string;
1397 transportId?: string;
1400 interface RTCRtcpFeedback {
1405 interface RTCRtcpParameters {
1407 reducedSize?: boolean;
1410 interface RTCRtpCapabilities {
1411 codecs: RTCRtpCodecCapability[];
1412 headerExtensions: RTCRtpHeaderExtensionCapability[];
1415 interface RTCRtpCodecCapability {
1419 sdpFmtpLine?: string;
1422 interface RTCRtpCodecParameters {
1426 payloadType: number;
1427 sdpFmtpLine?: string;
1430 interface RTCRtpCodingParameters {
1434 interface RTCRtpContributingSource {
1435 audioLevel?: number;
1436 rtpTimestamp: number;
1441 interface RTCRtpDecodingParameters extends RTCRtpCodingParameters {
1444 interface RTCRtpEncodingParameters extends RTCRtpCodingParameters {
1446 codecPayloadType?: number;
1448 maxBitrate?: number;
1449 maxFramerate?: number;
1451 scaleResolutionDownBy?: number;
1454 interface RTCRtpFecParameters {
1459 interface RTCRtpHeaderExtension {
1461 preferredEncrypt?: boolean;
1462 preferredId?: number;
1466 interface RTCRtpHeaderExtensionCapability {
1470 interface RTCRtpHeaderExtensionParameters {
1471 encrypted?: boolean;
1476 interface RTCRtpParameters {
1477 codecs: RTCRtpCodecParameters[];
1478 headerExtensions: RTCRtpHeaderExtensionParameters[];
1479 rtcp: RTCRtcpParameters;
1482 interface RTCRtpReceiveParameters extends RTCRtpParameters {
1483 encodings: RTCRtpDecodingParameters[];
1486 interface RTCRtpRtxParameters {
1490 interface RTCRtpSendParameters extends RTCRtpParameters {
1491 degradationPreference?: RTCDegradationPreference;
1492 encodings: RTCRtpEncodingParameters[];
1493 priority?: RTCPriorityType;
1494 transactionId: string;
1497 interface RTCRtpSynchronizationSource extends RTCRtpContributingSource {
1498 voiceActivityFlag?: boolean;
1501 interface RTCRtpTransceiverInit {
1502 direction?: RTCRtpTransceiverDirection;
1503 sendEncodings?: RTCRtpEncodingParameters[];
1504 streams?: MediaStream[];
1507 interface RTCRtpUnhandled {
1509 payloadType?: number;
1513 interface RTCSessionDescriptionInit {
1518 interface RTCSrtpKeyParam {
1526 interface RTCSrtpSdesParameters {
1527 cryptoSuite?: string;
1528 keyParams?: RTCSrtpKeyParam[];
1529 sessionParams?: string[];
1533 interface RTCSsrcRange {
1538 interface RTCStats {
1541 type?: RTCStatsType;
1544 interface RTCStatsEventInit extends EventInit {
1545 report: RTCStatsReport;
1548 interface RTCStatsReport {
1551 interface RTCTrackEventInit extends EventInit {
1552 receiver: RTCRtpReceiver;
1553 streams?: MediaStream[];
1554 track: MediaStreamTrack;
1555 transceiver: RTCRtpTransceiver;
1558 interface RTCTransportStats extends RTCStats {
1559 bytesReceived?: number;
1561 dtlsCipher?: string;
1562 dtlsState?: RTCDtlsTransportState;
1563 iceRole?: RTCIceRole;
1564 localCertificateId?: string;
1565 packetsReceived?: number;
1566 packetsSent?: number;
1567 remoteCertificateId?: string;
1568 rtcpTransportStatsId?: string;
1569 selectedCandidatePairChanges?: number;
1570 selectedCandidatePairId?: string;
1571 srtpCipher?: string;
1573 tlsVersion?: string;
1576 interface ReadableStreamDefaultReadDoneResult {
1581 interface ReadableStreamDefaultReadValueResult<T> {
1586 interface ReadableWritablePair<R = any, W = any> {
1587 readable: ReadableStream<R>;
1589 * Provides a convenient, chainable way of piping this readable stream through a transform stream (or any other { writable, readable } pair). It simply pipes the stream into the writable side of the supplied pair, and returns the readable side for further use.
1591 * Piping a stream will lock it for the duration of the pipe, preventing any other consumer from acquiring a reader.
1593 writable: WritableStream<W>;
1596 interface RegistrationOptions {
1599 updateViaCache?: ServiceWorkerUpdateViaCache;
1602 interface RequestInit {
1604 * A BodyInit object or null to set request's body.
1606 body?: BodyInit | null;
1608 * A string indicating how the request will interact with the browser's cache to set request's cache.
1610 cache?: RequestCache;
1612 * A string indicating whether credentials will be sent with the request always, never, or only when sent to a same-origin URL. Sets request's credentials.
1614 credentials?: RequestCredentials;
1616 * A Headers object, an object literal, or an array of two-item arrays to set request's headers.
1618 headers?: HeadersInit;
1620 * A cryptographic hash of the resource to be fetched by request. Sets request's integrity.
1624 * A boolean to set request's keepalive.
1626 keepalive?: boolean;
1628 * A string to set request's method.
1632 * A string to indicate whether the request will use CORS, or will be restricted to same-origin URLs. Sets request's mode.
1636 * A string indicating whether request follows redirects, results in an error upon encountering a redirect, or returns the redirect (in an opaque fashion). Sets request's redirect.
1638 redirect?: RequestRedirect;
1640 * A string whose value is a same-origin URL, "about:client", or the empty string, to set request's referrer.
1644 * A referrer policy to set request's referrerPolicy.
1646 referrerPolicy?: ReferrerPolicy;
1648 * An AbortSignal to set request's signal.
1650 signal?: AbortSignal | null;
1652 * Can only be null. Used to disassociate request from any Window.
1657 interface ResizeObserverOptions {
1658 box?: ResizeObserverBoxOptions;
1661 interface ResponseInit {
1662 headers?: HeadersInit;
1664 statusText?: string;
1667 interface RsaHashedImportParams extends Algorithm {
1668 hash: HashAlgorithmIdentifier;
1671 interface RsaHashedKeyAlgorithm extends RsaKeyAlgorithm {
1675 interface RsaHashedKeyGenParams extends RsaKeyGenParams {
1676 hash: HashAlgorithmIdentifier;
1679 interface RsaKeyAlgorithm extends KeyAlgorithm {
1680 modulusLength: number;
1681 publicExponent: BigInteger;
1684 interface RsaKeyGenParams extends Algorithm {
1685 modulusLength: number;
1686 publicExponent: BigInteger;
1689 interface RsaOaepParams extends Algorithm {
1690 label?: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;
1693 interface RsaOtherPrimesInfo {
1699 interface RsaPssParams extends Algorithm {
1703 interface SVGBoundingBoxOptions {
1710 interface ScopedCredentialDescriptor {
1711 id: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer | null;
1712 transports?: Transport[];
1713 type: ScopedCredentialType;
1716 interface ScopedCredentialOptions {
1717 excludeList?: ScopedCredentialDescriptor[];
1718 extensions?: WebAuthnExtensions;
1720 timeoutSeconds?: number;
1723 interface ScopedCredentialParameters {
1724 algorithm: string | Algorithm;
1725 type: ScopedCredentialType;
1728 interface ScrollIntoViewOptions extends ScrollOptions {
1729 block?: ScrollLogicalPosition;
1730 inline?: ScrollLogicalPosition;
1733 interface ScrollOptions {
1734 behavior?: ScrollBehavior;
1737 interface ScrollToOptions extends ScrollOptions {
1742 interface SecurityPolicyViolationEventInit extends EventInit {
1743 blockedURI?: string;
1744 columnNumber?: number;
1745 documentURI?: string;
1746 effectiveDirective?: string;
1747 lineNumber?: number;
1748 originalPolicy?: string;
1750 sourceFile?: string;
1751 statusCode?: number;
1752 violatedDirective?: string;
1755 interface ServiceWorkerMessageEventInit extends EventInit {
1757 lastEventId?: string;
1759 ports?: MessagePort[] | null;
1760 source?: ServiceWorker | MessagePort | null;
1763 interface ShadowRootInit {
1764 delegatesFocus?: boolean;
1765 mode: ShadowRootMode;
1768 interface ShareData {
1774 interface SpeechRecognitionErrorEventInit extends EventInit {
1775 error: SpeechRecognitionErrorCode;
1779 interface SpeechRecognitionEventInit extends EventInit {
1780 resultIndex?: number;
1781 results: SpeechRecognitionResultList;
1784 interface SpeechSynthesisErrorEventInit extends SpeechSynthesisEventInit {
1785 error: SpeechSynthesisErrorCode;
1788 interface SpeechSynthesisEventInit extends EventInit {
1790 charLength?: number;
1791 elapsedTime?: number;
1793 utterance: SpeechSynthesisUtterance;
1796 interface StaticRangeInit {
1799 startContainer: Node;
1800 startOffset: number;
1803 interface StereoPannerOptions extends AudioNodeOptions {
1807 interface StorageEstimate {
1812 interface StorageEventInit extends EventInit {
1813 key?: string | null;
1814 newValue?: string | null;
1815 oldValue?: string | null;
1816 storageArea?: Storage | null;
1820 interface StoreExceptionsInformation extends ExceptionInformation {
1821 detailURI?: string | null;
1822 explanationString?: string | null;
1823 siteName?: string | null;
1826 interface StoreSiteSpecificExceptionsInformation extends StoreExceptionsInformation {
1827 arrayOfDomainStrings?: string[];
1830 interface StreamPipeOptions {
1831 preventAbort?: boolean;
1832 preventCancel?: boolean;
1834 * Pipes this readable stream to a given writable stream destination. The way in which the piping process behaves under various error conditions can be customized with a number of passed options. It returns a promise that fulfills when the piping process completes successfully, or rejects if any errors were encountered.
1836 * Piping a stream will lock it for the duration of the pipe, preventing any other consumer from acquiring a reader.
1838 * Errors and closures of the source and destination streams propagate as follows:
1840 * An error in this source readable stream will abort destination, unless preventAbort is truthy. The returned promise will be rejected with the source's error, or with any error that occurs during aborting the destination.
1842 * An error in destination will cancel this source readable stream, unless preventCancel is truthy. The returned promise will be rejected with the destination's error, or with any error that occurs during canceling the source.
1844 * When this source readable stream closes, destination will be closed, unless preventClose is truthy. The returned promise will be fulfilled once this process completes, unless an error is encountered while closing the destination, in which case it will be rejected with that error.
1846 * If destination starts out closed or closing, this source readable stream will be canceled, unless preventCancel is true. The returned promise will be rejected with an error indicating piping to a closed stream failed, or with any error that occurs during canceling the source.
1848 * The signal option can be set to an AbortSignal to allow aborting an ongoing pipe operation via the corresponding AbortController. In this case, this source readable stream will be canceled, and destination aborted, unless the respective options preventCancel or preventAbort are set.
1850 preventClose?: boolean;
1851 signal?: AbortSignal;
1854 interface TextDecodeOptions {
1858 interface TextDecoderOptions {
1860 ignoreBOM?: boolean;
1863 interface TextEncoderEncodeIntoResult {
1868 interface TouchEventInit extends EventModifierInit {
1869 changedTouches?: Touch[];
1870 targetTouches?: Touch[];
1874 interface TouchInit {
1875 altitudeAngle?: number;
1876 azimuthAngle?: number;
1885 rotationAngle?: number;
1888 target: EventTarget;
1889 touchType?: TouchType;
1892 interface TrackEventInit extends EventInit {
1893 track?: TextTrack | null;
1896 interface Transformer<I = any, O = any> {
1897 flush?: TransformerFlushCallback<O>;
1898 readableType?: undefined;
1899 start?: TransformerStartCallback<O>;
1900 transform?: TransformerTransformCallback<I, O>;
1901 writableType?: undefined;
1904 interface TransitionEventInit extends EventInit {
1905 elapsedTime?: number;
1906 propertyName?: string;
1907 pseudoElement?: string;
1910 interface UIEventInit extends EventInit {
1912 view?: Window | null;
1915 interface ULongRange {
1920 interface UnderlyingSink<W = any> {
1921 abort?: UnderlyingSinkAbortCallback;
1922 close?: UnderlyingSinkCloseCallback;
1923 start?: UnderlyingSinkStartCallback;
1925 write?: UnderlyingSinkWriteCallback<W>;
1928 interface UnderlyingSource<R = any> {
1929 cancel?: UnderlyingSourceCancelCallback;
1930 pull?: UnderlyingSourcePullCallback<R>;
1931 start?: UnderlyingSourceStartCallback<R>;
1935 interface VRDisplayEventInit extends EventInit {
1937 reason?: VRDisplayEventReason;
1941 leftBounds?: number[] | Float32Array | null;
1942 rightBounds?: number[] | Float32Array | null;
1943 source?: HTMLCanvasElement | null;
1946 interface VRStageParameters {
1947 sittingToStandingTransform?: Float32Array;
1952 interface WaveShaperOptions extends AudioNodeOptions {
1953 curve?: number[] | Float32Array;
1954 oversample?: OverSampleType;
1957 interface WebAuthnExtensions {
1960 interface WebGLContextAttributes {
1962 antialias?: boolean;
1964 desynchronized?: boolean;
1965 failIfMajorPerformanceCaveat?: boolean;
1966 powerPreference?: WebGLPowerPreference;
1967 premultipliedAlpha?: boolean;
1968 preserveDrawingBuffer?: boolean;
1972 interface WebGLContextEventInit extends EventInit {
1973 statusMessage?: string;
1976 interface WheelEventInit extends MouseEventInit {
1983 interface WorkerOptions {
1984 credentials?: RequestCredentials;
1989 interface WorkletOptions {
1990 credentials?: RequestCredentials;
1993 interface EventListener {
1997 type XPathNSResolver = ((prefix: string | null) => string | null) | { lookupNamespaceURI(prefix: string | null): string | null; };
1999 /** The ANGLE_instanced_arrays extension is part of the WebGL API and allows to draw the same object, or groups of similar objects multiple times, if they share the same vertex data, primitive count and type. */
2000 interface ANGLE_instanced_arrays {
2001 drawArraysInstancedANGLE(mode: GLenum, first: GLint, count: GLsizei, primcount: GLsizei): void;
2002 drawElementsInstancedANGLE(mode: GLenum, count: GLsizei, type: GLenum, offset: GLintptr, primcount: GLsizei): void;
2003 vertexAttribDivisorANGLE(index: GLuint, divisor: GLuint): void;
2004 readonly VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE: GLenum;
2007 /** A controller object that allows you to abort one or more DOM requests as and when desired. */
2008 interface AbortController {
2010 * Returns the AbortSignal object associated with this object.
2012 readonly signal: AbortSignal;
2014 * Invoking this method will set this object's AbortSignal's aborted flag and signal to any observers that the associated activity is to be aborted.
2019 declare var AbortController: {
2020 prototype: AbortController;
2021 new(): AbortController;
2024 interface AbortSignalEventMap {
2028 /** A signal object that allows you to communicate with a DOM request (such as a Fetch) and abort it if required via an AbortController object. */
2029 interface AbortSignal extends EventTarget {
2031 * Returns true if this AbortSignal's AbortController has signaled to abort, and false otherwise.
2033 readonly aborted: boolean;
2034 onabort: ((this: AbortSignal, ev: Event) => any) | null;
2035 addEventListener<K extends keyof AbortSignalEventMap>(type: K, listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
2036 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
2037 removeEventListener<K extends keyof AbortSignalEventMap>(type: K, listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
2038 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
2041 declare var AbortSignal: {
2042 prototype: AbortSignal;
2046 interface AbstractRange {
2048 * Returns true if range is collapsed, and false otherwise.
2050 readonly collapsed: boolean;
2052 * Returns range's end node.
2054 readonly endContainer: Node;
2056 * Returns range's end offset.
2058 readonly endOffset: number;
2060 * Returns range's start node.
2062 readonly startContainer: Node;
2064 * Returns range's start offset.
2066 readonly startOffset: number;
2069 declare var AbstractRange: {
2070 prototype: AbstractRange;
2071 new(): AbstractRange;
2074 interface AbstractWorkerEventMap {
2075 "error": ErrorEvent;
2078 interface AbstractWorker {
2079 onerror: ((this: AbstractWorker, ev: ErrorEvent) => any) | null;
2080 addEventListener<K extends keyof AbstractWorkerEventMap>(type: K, listener: (this: AbstractWorker, ev: AbstractWorkerEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
2081 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
2082 removeEventListener<K extends keyof AbstractWorkerEventMap>(type: K, listener: (this: AbstractWorker, ev: AbstractWorkerEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
2083 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
2086 interface AesCfbParams extends Algorithm {
2087 iv: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;
2090 interface AesCmacParams extends Algorithm {
2094 /** A node able to provide real-time frequency and time-domain analysis information. It is an AudioNode that passes the audio stream unchanged from the input to the output, but allows you to take the generated data, process it, and create audio visualizations. */
2095 interface AnalyserNode extends AudioNode {
2097 readonly frequencyBinCount: number;
2098 maxDecibels: number;
2099 minDecibels: number;
2100 smoothingTimeConstant: number;
2101 getByteFrequencyData(array: Uint8Array): void;
2102 getByteTimeDomainData(array: Uint8Array): void;
2103 getFloatFrequencyData(array: Float32Array): void;
2104 getFloatTimeDomainData(array: Float32Array): void;
2107 declare var AnalyserNode: {
2108 prototype: AnalyserNode;
2109 new(context: BaseAudioContext, options?: AnalyserOptions): AnalyserNode;
2112 interface Animatable {
2113 animate(keyframes: Keyframe[] | PropertyIndexedKeyframes | null, options?: number | KeyframeAnimationOptions): Animation;
2114 getAnimations(): Animation[];
2117 interface AnimationEventMap {
2118 "cancel": AnimationPlaybackEvent;
2119 "finish": AnimationPlaybackEvent;
2122 interface Animation extends EventTarget {
2123 currentTime: number | null;
2124 effect: AnimationEffect | null;
2125 readonly finished: Promise<Animation>;
2127 oncancel: ((this: Animation, ev: AnimationPlaybackEvent) => any) | null;
2128 onfinish: ((this: Animation, ev: AnimationPlaybackEvent) => any) | null;
2129 readonly pending: boolean;
2130 readonly playState: AnimationPlayState;
2131 playbackRate: number;
2132 readonly ready: Promise<Animation>;
2133 startTime: number | null;
2134 timeline: AnimationTimeline | null;
2140 updatePlaybackRate(playbackRate: number): void;
2141 addEventListener<K extends keyof AnimationEventMap>(type: K, listener: (this: Animation, ev: AnimationEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
2142 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
2143 removeEventListener<K extends keyof AnimationEventMap>(type: K, listener: (this: Animation, ev: AnimationEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
2144 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
2147 declare var Animation: {
2148 prototype: Animation;
2149 new(effect?: AnimationEffect | null, timeline?: AnimationTimeline | null): Animation;
2152 interface AnimationEffect {
2153 getComputedTiming(): ComputedEffectTiming;
2154 getTiming(): EffectTiming;
2155 updateTiming(timing?: OptionalEffectTiming): void;
2158 declare var AnimationEffect: {
2159 prototype: AnimationEffect;
2160 new(): AnimationEffect;
2163 /** Events providing information related to animations. */
2164 interface AnimationEvent extends Event {
2165 readonly animationName: string;
2166 readonly elapsedTime: number;
2167 readonly pseudoElement: string;
2170 declare var AnimationEvent: {
2171 prototype: AnimationEvent;
2172 new(type: string, animationEventInitDict?: AnimationEventInit): AnimationEvent;
2175 interface AnimationFrameProvider {
2176 cancelAnimationFrame(handle: number): void;
2177 requestAnimationFrame(callback: FrameRequestCallback): number;
2180 interface AnimationPlaybackEvent extends Event {
2181 readonly currentTime: number | null;
2182 readonly timelineTime: number | null;
2185 declare var AnimationPlaybackEvent: {
2186 prototype: AnimationPlaybackEvent;
2187 new(type: string, eventInitDict?: AnimationPlaybackEventInit): AnimationPlaybackEvent;
2190 interface AnimationTimeline {
2191 readonly currentTime: number | null;
2194 declare var AnimationTimeline: {
2195 prototype: AnimationTimeline;
2196 new(): AnimationTimeline;
2199 interface ApplicationCacheEventMap {
2202 "downloading": Event;
2206 "progress": ProgressEvent<ApplicationCache>;
2207 "updateready": Event;
2210 interface ApplicationCache extends EventTarget {
2212 oncached: ((this: ApplicationCache, ev: Event) => any) | null;
2214 onchecking: ((this: ApplicationCache, ev: Event) => any) | null;
2216 ondownloading: ((this: ApplicationCache, ev: Event) => any) | null;
2218 onerror: ((this: ApplicationCache, ev: Event) => any) | null;
2220 onnoupdate: ((this: ApplicationCache, ev: Event) => any) | null;
2222 onobsolete: ((this: ApplicationCache, ev: Event) => any) | null;
2224 onprogress: ((this: ApplicationCache, ev: ProgressEvent<ApplicationCache>) => any) | null;
2226 onupdateready: ((this: ApplicationCache, ev: Event) => any) | null;
2228 readonly status: number;
2235 readonly CHECKING: number;
2236 readonly DOWNLOADING: number;
2237 readonly IDLE: number;
2238 readonly OBSOLETE: number;
2239 readonly UNCACHED: number;
2240 readonly UPDATEREADY: number;
2241 addEventListener<K extends keyof ApplicationCacheEventMap>(type: K, listener: (this: ApplicationCache, ev: ApplicationCacheEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
2242 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
2243 removeEventListener<K extends keyof ApplicationCacheEventMap>(type: K, listener: (this: ApplicationCache, ev: ApplicationCacheEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
2244 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
2247 declare var ApplicationCache: {
2248 prototype: ApplicationCache;
2249 new(): ApplicationCache;
2250 readonly CHECKING: number;
2251 readonly DOWNLOADING: number;
2252 readonly IDLE: number;
2253 readonly OBSOLETE: number;
2254 readonly UNCACHED: number;
2255 readonly UPDATEREADY: number;
2258 /** A DOM element's attribute as an object. In most DOM methods, you will probably directly retrieve the attribute as a string (e.g., Element.getAttribute(), but certain functions (e.g., Element.getAttributeNode()) or means of iterating give Attr types. */
2259 interface Attr extends Node {
2260 readonly localName: string;
2261 readonly name: string;
2262 readonly namespaceURI: string | null;
2263 readonly ownerDocument: Document;
2264 readonly ownerElement: Element | null;
2265 readonly prefix: string | null;
2266 readonly specified: boolean;
2275 /** A short audio asset residing in memory, created from an audio file using the AudioContext.decodeAudioData() method, or from raw data using AudioContext.createBuffer(). Once put into an AudioBuffer, the audio can then be played by being passed into an AudioBufferSourceNode. */
2276 interface AudioBuffer {
2277 readonly duration: number;
2278 readonly length: number;
2279 readonly numberOfChannels: number;
2280 readonly sampleRate: number;
2281 copyFromChannel(destination: Float32Array, channelNumber: number, bufferOffset?: number): void;
2282 copyToChannel(source: Float32Array, channelNumber: number, bufferOffset?: number): void;
2283 getChannelData(channel: number): Float32Array;
2286 declare var AudioBuffer: {
2287 prototype: AudioBuffer;
2288 new(options: AudioBufferOptions): AudioBuffer;
2291 /** An AudioScheduledSourceNode which represents an audio source consisting of in-memory audio data, stored in an AudioBuffer. It's especially useful for playing back audio which has particularly stringent timing accuracy requirements, such as for sounds that must match a specific rhythm and can be kept in memory rather than being played from disk or the network. */
2292 interface AudioBufferSourceNode extends AudioScheduledSourceNode {
2293 buffer: AudioBuffer | null;
2294 readonly detune: AudioParam;
2298 readonly playbackRate: AudioParam;
2299 start(when?: number, offset?: number, duration?: number): void;
2300 addEventListener<K extends keyof AudioScheduledSourceNodeEventMap>(type: K, listener: (this: AudioBufferSourceNode, ev: AudioScheduledSourceNodeEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
2301 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
2302 removeEventListener<K extends keyof AudioScheduledSourceNodeEventMap>(type: K, listener: (this: AudioBufferSourceNode, ev: AudioScheduledSourceNodeEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
2303 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
2306 declare var AudioBufferSourceNode: {
2307 prototype: AudioBufferSourceNode;
2308 new(context: BaseAudioContext, options?: AudioBufferSourceOptions): AudioBufferSourceNode;
2311 /** An audio-processing graph built from audio modules linked together, each represented by an AudioNode. */
2312 interface AudioContext extends BaseAudioContext {
2313 readonly baseLatency: number;
2314 readonly outputLatency: number;
2315 close(): Promise<void>;
2316 createMediaElementSource(mediaElement: HTMLMediaElement): MediaElementAudioSourceNode;
2317 createMediaStreamDestination(): MediaStreamAudioDestinationNode;
2318 createMediaStreamSource(mediaStream: MediaStream): MediaStreamAudioSourceNode;
2319 createMediaStreamTrackSource(mediaStreamTrack: MediaStreamTrack): MediaStreamTrackAudioSourceNode;
2320 getOutputTimestamp(): AudioTimestamp;
2321 resume(): Promise<void>;
2322 suspend(): Promise<void>;
2323 addEventListener<K extends keyof BaseAudioContextEventMap>(type: K, listener: (this: AudioContext, ev: BaseAudioContextEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
2324 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
2325 removeEventListener<K extends keyof BaseAudioContextEventMap>(type: K, listener: (this: AudioContext, ev: BaseAudioContextEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
2326 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
2329 declare var AudioContext: {
2330 prototype: AudioContext;
2331 new(contextOptions?: AudioContextOptions): AudioContext;
2334 /** AudioDestinationNode has no output (as it is the output, no more AudioNode can be linked after it in the audio graph) and one input. The number of channels in the input must be between 0 and the maxChannelCount value or an exception is raised. */
2335 interface AudioDestinationNode extends AudioNode {
2336 readonly maxChannelCount: number;
2339 declare var AudioDestinationNode: {
2340 prototype: AudioDestinationNode;
2341 new(): AudioDestinationNode;
2344 /** The position and orientation of the unique person listening to the audio scene, and is used in audio spatialization. All PannerNodes spatialize in relation to the AudioListener stored in the BaseAudioContext.listener attribute. */
2345 interface AudioListener {
2346 readonly forwardX: AudioParam;
2347 readonly forwardY: AudioParam;
2348 readonly forwardZ: AudioParam;
2349 readonly positionX: AudioParam;
2350 readonly positionY: AudioParam;
2351 readonly positionZ: AudioParam;
2352 readonly upX: AudioParam;
2353 readonly upY: AudioParam;
2354 readonly upZ: AudioParam;
2356 setOrientation(x: number, y: number, z: number, xUp: number, yUp: number, zUp: number): void;
2358 setPosition(x: number, y: number, z: number): void;
2361 declare var AudioListener: {
2362 prototype: AudioListener;
2363 new(): AudioListener;
2366 /** A generic interface for representing an audio processing module. Examples include: */
2367 interface AudioNode extends EventTarget {
2368 channelCount: number;
2369 channelCountMode: ChannelCountMode;
2370 channelInterpretation: ChannelInterpretation;
2371 readonly context: BaseAudioContext;
2372 readonly numberOfInputs: number;
2373 readonly numberOfOutputs: number;
2374 connect(destinationNode: AudioNode, output?: number, input?: number): AudioNode;
2375 connect(destinationParam: AudioParam, output?: number): void;
2377 disconnect(output: number): void;
2378 disconnect(destinationNode: AudioNode): void;
2379 disconnect(destinationNode: AudioNode, output: number): void;
2380 disconnect(destinationNode: AudioNode, output: number, input: number): void;
2381 disconnect(destinationParam: AudioParam): void;
2382 disconnect(destinationParam: AudioParam, output: number): void;
2385 declare var AudioNode: {
2386 prototype: AudioNode;
2390 /** The Web Audio API's AudioParam interface represents an audio-related parameter, usually a parameter of an AudioNode (such as GainNode.gain). */
2391 interface AudioParam {
2392 automationRate: AutomationRate;
2393 readonly defaultValue: number;
2394 readonly maxValue: number;
2395 readonly minValue: number;
2397 cancelAndHoldAtTime(cancelTime: number): AudioParam;
2398 cancelScheduledValues(cancelTime: number): AudioParam;
2399 exponentialRampToValueAtTime(value: number, endTime: number): AudioParam;
2400 linearRampToValueAtTime(value: number, endTime: number): AudioParam;
2401 setTargetAtTime(target: number, startTime: number, timeConstant: number): AudioParam;
2402 setValueAtTime(value: number, startTime: number): AudioParam;
2403 setValueCurveAtTime(values: number[] | Float32Array, startTime: number, duration: number): AudioParam;
2406 declare var AudioParam: {
2407 prototype: AudioParam;
2411 interface AudioParamMap {
2412 forEach(callbackfn: (value: AudioParam, key: string, parent: AudioParamMap) => void, thisArg?: any): void;
2415 declare var AudioParamMap: {
2416 prototype: AudioParamMap;
2417 new(): AudioParamMap;
2420 /** The Web Audio API events that occur when a ScriptProcessorNode input buffer is ready to be processed.
2421 * @deprecated As of the August 29 2014 Web Audio API spec publication, this feature has been marked as deprecated, and is soon to be replaced by AudioWorklet.
2423 interface AudioProcessingEvent extends Event {
2424 readonly inputBuffer: AudioBuffer;
2425 readonly outputBuffer: AudioBuffer;
2426 readonly playbackTime: number;
2429 declare var AudioProcessingEvent: {
2430 prototype: AudioProcessingEvent;
2431 new(type: string, eventInitDict: AudioProcessingEventInit): AudioProcessingEvent;
2434 interface AudioScheduledSourceNodeEventMap {
2438 interface AudioScheduledSourceNode extends AudioNode {
2439 onended: ((this: AudioScheduledSourceNode, ev: Event) => any) | null;
2440 start(when?: number): void;
2441 stop(when?: number): void;
2442 addEventListener<K extends keyof AudioScheduledSourceNodeEventMap>(type: K, listener: (this: AudioScheduledSourceNode, ev: AudioScheduledSourceNodeEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
2443 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
2444 removeEventListener<K extends keyof AudioScheduledSourceNodeEventMap>(type: K, listener: (this: AudioScheduledSourceNode, ev: AudioScheduledSourceNodeEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
2445 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
2448 declare var AudioScheduledSourceNode: {
2449 prototype: AudioScheduledSourceNode;
2450 new(): AudioScheduledSourceNode;
2453 interface AudioWorklet extends Worklet {
2456 declare var AudioWorklet: {
2457 prototype: AudioWorklet;
2458 new(): AudioWorklet;
2461 interface AudioWorkletNodeEventMap {
2462 "processorerror": Event;
2465 interface AudioWorkletNode extends AudioNode {
2466 onprocessorerror: ((this: AudioWorkletNode, ev: Event) => any) | null;
2467 readonly parameters: AudioParamMap;
2468 readonly port: MessagePort;
2469 addEventListener<K extends keyof AudioWorkletNodeEventMap>(type: K, listener: (this: AudioWorkletNode, ev: AudioWorkletNodeEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
2470 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
2471 removeEventListener<K extends keyof AudioWorkletNodeEventMap>(type: K, listener: (this: AudioWorkletNode, ev: AudioWorkletNodeEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
2472 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
2475 declare var AudioWorkletNode: {
2476 prototype: AudioWorkletNode;
2477 new(context: BaseAudioContext, name: string, options?: AudioWorkletNodeOptions): AudioWorkletNode;
2480 interface AuthenticatorAssertionResponse extends AuthenticatorResponse {
2481 readonly authenticatorData: ArrayBuffer;
2482 readonly signature: ArrayBuffer;
2483 readonly userHandle: ArrayBuffer | null;
2486 declare var AuthenticatorAssertionResponse: {
2487 prototype: AuthenticatorAssertionResponse;
2488 new(): AuthenticatorAssertionResponse;
2491 interface AuthenticatorAttestationResponse extends AuthenticatorResponse {
2492 readonly attestationObject: ArrayBuffer;
2495 declare var AuthenticatorAttestationResponse: {
2496 prototype: AuthenticatorAttestationResponse;
2497 new(): AuthenticatorAttestationResponse;
2500 interface AuthenticatorResponse {
2501 readonly clientDataJSON: ArrayBuffer;
2504 declare var AuthenticatorResponse: {
2505 prototype: AuthenticatorResponse;
2506 new(): AuthenticatorResponse;
2510 readonly visible: boolean;
2513 declare var BarProp: {
2518 interface BaseAudioContextEventMap {
2519 "statechange": Event;
2522 interface BaseAudioContext extends EventTarget {
2523 readonly audioWorklet: AudioWorklet;
2524 readonly currentTime: number;
2525 readonly destination: AudioDestinationNode;
2526 readonly listener: AudioListener;
2527 onstatechange: ((this: BaseAudioContext, ev: Event) => any) | null;
2528 readonly sampleRate: number;
2529 readonly state: AudioContextState;
2530 createAnalyser(): AnalyserNode;
2531 createBiquadFilter(): BiquadFilterNode;
2532 createBuffer(numberOfChannels: number, length: number, sampleRate: number): AudioBuffer;
2533 createBufferSource(): AudioBufferSourceNode;
2534 createChannelMerger(numberOfInputs?: number): ChannelMergerNode;
2535 createChannelSplitter(numberOfOutputs?: number): ChannelSplitterNode;
2536 createConstantSource(): ConstantSourceNode;
2537 createConvolver(): ConvolverNode;
2538 createDelay(maxDelayTime?: number): DelayNode;
2539 createDynamicsCompressor(): DynamicsCompressorNode;
2540 createGain(): GainNode;
2541 createIIRFilter(feedforward: number[], feedback: number[]): IIRFilterNode;
2542 createOscillator(): OscillatorNode;
2543 createPanner(): PannerNode;
2544 createPeriodicWave(real: number[] | Float32Array, imag: number[] | Float32Array, constraints?: PeriodicWaveConstraints): PeriodicWave;
2545 createScriptProcessor(bufferSize?: number, numberOfInputChannels?: number, numberOfOutputChannels?: number): ScriptProcessorNode;
2546 createStereoPanner(): StereoPannerNode;
2547 createWaveShaper(): WaveShaperNode;
2548 decodeAudioData(audioData: ArrayBuffer, successCallback?: DecodeSuccessCallback | null, errorCallback?: DecodeErrorCallback | null): Promise<AudioBuffer>;
2549 addEventListener<K extends keyof BaseAudioContextEventMap>(type: K, listener: (this: BaseAudioContext, ev: BaseAudioContextEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
2550 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
2551 removeEventListener<K extends keyof BaseAudioContextEventMap>(type: K, listener: (this: BaseAudioContext, ev: BaseAudioContextEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
2552 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
2555 declare var BaseAudioContext: {
2556 prototype: BaseAudioContext;
2557 new(): BaseAudioContext;
2560 /** The beforeunload event is fired when the window, the document and its resources are about to be unloaded. */
2561 interface BeforeUnloadEvent extends Event {
2565 declare var BeforeUnloadEvent: {
2566 prototype: BeforeUnloadEvent;
2567 new(): BeforeUnloadEvent;
2570 interface BhxBrowser {
2571 readonly lastError: DOMException;
2572 checkMatchesGlobExpression(pattern: string, value: string): boolean;
2573 checkMatchesUriExpression(pattern: string, value: string): boolean;
2574 clearLastError(): void;
2575 currentWindowId(): number;
2576 fireExtensionApiTelemetry(functionName: string, isSucceeded: boolean, isSupported: boolean, errorString: string): void;
2577 genericFunction(functionId: number, destination: any, parameters?: string, callbackId?: number): void;
2578 genericSynchronousFunction(functionId: number, parameters?: string): string;
2579 getExtensionId(): string;
2580 getThisAddress(): any;
2581 registerGenericFunctionCallbackHandler(callbackHandler: Function): void;
2582 registerGenericListenerHandler(eventHandler: Function): void;
2583 setLastError(parameters: string): void;
2584 webPlatformGenericFunction(destination: any, parameters?: string, callbackId?: number): void;
2587 declare var BhxBrowser: {
2588 prototype: BhxBrowser;
2592 /** A simple low-order filter, and is created using the AudioContext.createBiquadFilter() method. It is an AudioNode that can represent different kinds of filters, tone control devices, and graphic equalizers. */
2593 interface BiquadFilterNode extends AudioNode {
2594 readonly Q: AudioParam;
2595 readonly detune: AudioParam;
2596 readonly frequency: AudioParam;
2597 readonly gain: AudioParam;
2598 type: BiquadFilterType;
2599 getFrequencyResponse(frequencyHz: Float32Array, magResponse: Float32Array, phaseResponse: Float32Array): void;
2602 declare var BiquadFilterNode: {
2603 prototype: BiquadFilterNode;
2604 new(context: BaseAudioContext, options?: BiquadFilterOptions): BiquadFilterNode;
2607 /** A file-like object of immutable, raw data. Blobs represent data that isn't necessarily in a JavaScript-native format. The File interface is based on Blob, inheriting blob functionality and expanding it to support files on the user's system. */
2609 readonly size: number;
2610 readonly type: string;
2611 arrayBuffer(): Promise<ArrayBuffer>;
2612 slice(start?: number, end?: number, contentType?: string): Blob;
2613 stream(): ReadableStream;
2614 text(): Promise<string>;
2619 new(blobParts?: BlobPart[], options?: BlobPropertyBag): Blob;
2623 readonly body: ReadableStream<Uint8Array> | null;
2624 readonly bodyUsed: boolean;
2625 arrayBuffer(): Promise<ArrayBuffer>;
2626 blob(): Promise<Blob>;
2627 formData(): Promise<FormData>;
2628 json(): Promise<any>;
2629 text(): Promise<string>;
2632 interface BroadcastChannelEventMap {
2633 "message": MessageEvent;
2634 "messageerror": MessageEvent;
2637 interface BroadcastChannel extends EventTarget {
2639 * Returns the channel name (as passed to the constructor).
2641 readonly name: string;
2642 onmessage: ((this: BroadcastChannel, ev: MessageEvent) => any) | null;
2643 onmessageerror: ((this: BroadcastChannel, ev: MessageEvent) => any) | null;
2645 * Closes the BroadcastChannel object, opening it up to garbage collection.
2649 * Sends the given message to other BroadcastChannel objects set up for this channel. Messages can be structured objects, e.g. nested objects and arrays.
2651 postMessage(message: any): void;
2652 addEventListener<K extends keyof BroadcastChannelEventMap>(type: K, listener: (this: BroadcastChannel, ev: BroadcastChannelEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
2653 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
2654 removeEventListener<K extends keyof BroadcastChannelEventMap>(type: K, listener: (this: BroadcastChannel, ev: BroadcastChannelEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
2655 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
2658 declare var BroadcastChannel: {
2659 prototype: BroadcastChannel;
2660 new(name: string): BroadcastChannel;
2663 /** This Streams API interface provides a built-in byte length queuing strategy that can be used when constructing streams. */
2664 interface ByteLengthQueuingStrategy extends QueuingStrategy<ArrayBufferView> {
2665 readonly highWaterMark: number;
2666 readonly size: QueuingStrategySize<ArrayBufferView>;
2669 declare var ByteLengthQueuingStrategy: {
2670 prototype: ByteLengthQueuingStrategy;
2671 new(init: QueuingStrategyInit): ByteLengthQueuingStrategy;
2674 /** A CDATA section that can be used within XML to include extended portions of unescaped text. The symbols < and & don’t need escaping as they normally do when inside a CDATA section. */
2675 interface CDATASection extends Text {
2678 declare var CDATASection: {
2679 prototype: CDATASection;
2680 new(): CDATASection;
2683 /** A single condition CSS at-rule, which consists of a condition and a statement block. It is a child of CSSGroupingRule. */
2684 interface CSSConditionRule extends CSSGroupingRule {
2685 conditionText: string;
2688 declare var CSSConditionRule: {
2689 prototype: CSSConditionRule;
2690 new(): CSSConditionRule;
2693 interface CSSFontFaceRule extends CSSRule {
2694 readonly style: CSSStyleDeclaration;
2697 declare var CSSFontFaceRule: {
2698 prototype: CSSFontFaceRule;
2699 new(): CSSFontFaceRule;
2702 /** Any CSS at-rule that contains other rules nested within it. */
2703 interface CSSGroupingRule extends CSSRule {
2704 readonly cssRules: CSSRuleList;
2705 deleteRule(index: number): void;
2706 insertRule(rule: string, index?: number): number;
2709 declare var CSSGroupingRule: {
2710 prototype: CSSGroupingRule;
2711 new(): CSSGroupingRule;
2714 interface CSSImportRule extends CSSRule {
2715 readonly href: string;
2716 readonly media: MediaList;
2717 readonly styleSheet: CSSStyleSheet;
2720 declare var CSSImportRule: {
2721 prototype: CSSImportRule;
2722 new(): CSSImportRule;
2725 /** An object representing a set of style for a given keyframe. It corresponds to the contains of a single keyframe of a @keyframes at-rule. It implements the CSSRule interface with a type value of 8 (CSSRule.KEYFRAME_RULE). */
2726 interface CSSKeyframeRule extends CSSRule {
2728 readonly style: CSSStyleDeclaration;
2731 declare var CSSKeyframeRule: {
2732 prototype: CSSKeyframeRule;
2733 new(): CSSKeyframeRule;
2736 /** An object representing a complete set of keyframes for a CSS animation. It corresponds to the contains of a whole @keyframes at-rule. It implements the CSSRule interface with a type value of 7 (CSSRule.KEYFRAMES_RULE). */
2737 interface CSSKeyframesRule extends CSSRule {
2738 readonly cssRules: CSSRuleList;
2740 appendRule(rule: string): void;
2741 deleteRule(select: string): void;
2742 findRule(select: string): CSSKeyframeRule | null;
2745 declare var CSSKeyframesRule: {
2746 prototype: CSSKeyframesRule;
2747 new(): CSSKeyframesRule;
2750 /** A single CSS @media rule. It implements the CSSConditionRule interface, and therefore the CSSGroupingRule and the CSSRule interface with a type value of 4 (CSSRule.MEDIA_RULE). */
2751 interface CSSMediaRule extends CSSConditionRule {
2752 readonly media: MediaList;
2755 declare var CSSMediaRule: {
2756 prototype: CSSMediaRule;
2757 new(): CSSMediaRule;
2760 /** An object representing a single CSS @namespace at-rule. It implements the CSSRule interface, with a type value of 10 (CSSRule.NAMESPACE_RULE). */
2761 interface CSSNamespaceRule extends CSSRule {
2762 readonly namespaceURI: string;
2763 readonly prefix: string;
2766 declare var CSSNamespaceRule: {
2767 prototype: CSSNamespaceRule;
2768 new(): CSSNamespaceRule;
2771 /** CSSPageRule is an interface representing a single CSS @page rule. It implements the CSSRule interface with a type value of 6 (CSSRule.PAGE_RULE). */
2772 interface CSSPageRule extends CSSGroupingRule {
2773 selectorText: string;
2774 readonly style: CSSStyleDeclaration;
2777 declare var CSSPageRule: {
2778 prototype: CSSPageRule;
2782 /** A single CSS rule. There are several types of rules, listed in the Type constants section below. */
2785 readonly parentRule: CSSRule | null;
2786 readonly parentStyleSheet: CSSStyleSheet | null;
2787 readonly type: number;
2788 readonly CHARSET_RULE: number;
2789 readonly FONT_FACE_RULE: number;
2790 readonly IMPORT_RULE: number;
2791 readonly KEYFRAMES_RULE: number;
2792 readonly KEYFRAME_RULE: number;
2793 readonly MEDIA_RULE: number;
2794 readonly NAMESPACE_RULE: number;
2795 readonly PAGE_RULE: number;
2796 readonly STYLE_RULE: number;
2797 readonly SUPPORTS_RULE: number;
2800 declare var CSSRule: {
2803 readonly CHARSET_RULE: number;
2804 readonly FONT_FACE_RULE: number;
2805 readonly IMPORT_RULE: number;
2806 readonly KEYFRAMES_RULE: number;
2807 readonly KEYFRAME_RULE: number;
2808 readonly MEDIA_RULE: number;
2809 readonly NAMESPACE_RULE: number;
2810 readonly PAGE_RULE: number;
2811 readonly STYLE_RULE: number;
2812 readonly SUPPORTS_RULE: number;
2815 /** A CSSRuleList is an (indirect-modify only) array-like object containing an ordered collection of CSSRule objects. */
2816 interface CSSRuleList {
2817 readonly length: number;
2818 item(index: number): CSSRule | null;
2819 [index: number]: CSSRule;
2822 declare var CSSRuleList: {
2823 prototype: CSSRuleList;
2827 /** An object that is a CSS declaration block, and exposes style information and various style-related methods and properties. */
2828 interface CSSStyleDeclaration {
2829 alignContent: string;
2832 alignmentBaseline: string;
2835 animationDelay: string;
2836 animationDirection: string;
2837 animationDuration: string;
2838 animationFillMode: string;
2839 animationIterationCount: string;
2840 animationName: string;
2841 animationPlayState: string;
2842 animationTimingFunction: string;
2843 backfaceVisibility: string;
2845 backgroundAttachment: string;
2846 backgroundClip: string;
2847 backgroundColor: string;
2848 backgroundImage: string;
2849 backgroundOrigin: string;
2850 backgroundPosition: string;
2851 backgroundPositionX: string;
2852 backgroundPositionY: string;
2853 backgroundRepeat: string;
2854 backgroundSize: string;
2855 baselineShift: string;
2858 borderBlockEnd: string;
2859 borderBlockEndColor: string;
2860 borderBlockEndStyle: string;
2861 borderBlockEndWidth: string;
2862 borderBlockStart: string;
2863 borderBlockStartColor: string;
2864 borderBlockStartStyle: string;
2865 borderBlockStartWidth: string;
2866 borderBottom: string;
2867 borderBottomColor: string;
2868 borderBottomLeftRadius: string;
2869 borderBottomRightRadius: string;
2870 borderBottomStyle: string;
2871 borderBottomWidth: string;
2872 borderCollapse: string;
2873 borderColor: string;
2874 borderImage: string;
2875 borderImageOutset: string;
2876 borderImageRepeat: string;
2877 borderImageSlice: string;
2878 borderImageSource: string;
2879 borderImageWidth: string;
2880 borderInlineEnd: string;
2881 borderInlineEndColor: string;
2882 borderInlineEndStyle: string;
2883 borderInlineEndWidth: string;
2884 borderInlineStart: string;
2885 borderInlineStartColor: string;
2886 borderInlineStartStyle: string;
2887 borderInlineStartWidth: string;
2889 borderLeftColor: string;
2890 borderLeftStyle: string;
2891 borderLeftWidth: string;
2892 borderRadius: string;
2893 borderRight: string;
2894 borderRightColor: string;
2895 borderRightStyle: string;
2896 borderRightWidth: string;
2897 borderSpacing: string;
2898 borderStyle: string;
2900 borderTopColor: string;
2901 borderTopLeftRadius: string;
2902 borderTopRightRadius: string;
2903 borderTopStyle: string;
2904 borderTopWidth: string;
2905 borderWidth: string;
2910 breakBefore: string;
2911 breakInside: string;
2912 captionSide: string;
2919 colorInterpolation: string;
2920 colorInterpolationFilters: string;
2921 columnCount: string;
2925 columnRuleColor: string;
2926 columnRuleStyle: string;
2927 columnRuleWidth: string;
2929 columnWidth: string;
2932 counterIncrement: string;
2933 counterReset: string;
2939 dominantBaseline: string;
2942 fillOpacity: string;
2947 flexDirection: string;
2954 floodOpacity: string;
2957 fontFeatureSettings: string;
2958 fontKerning: string;
2960 fontSizeAdjust: string;
2961 fontStretch: string;
2963 fontSynthesis: string;
2964 fontVariant: string;
2965 fontVariantCaps: string;
2966 fontVariantEastAsian: string;
2967 fontVariantLigatures: string;
2968 fontVariantNumeric: string;
2969 fontVariantPosition: string;
2972 glyphOrientationVertical: string;
2975 gridAutoColumns: string;
2976 gridAutoFlow: string;
2977 gridAutoRows: string;
2979 gridColumnEnd: string;
2980 gridColumnGap: string;
2981 gridColumnStart: string;
2986 gridRowStart: string;
2987 gridTemplate: string;
2988 gridTemplateAreas: string;
2989 gridTemplateColumns: string;
2990 gridTemplateRows: string;
2993 imageOrientation: string;
2994 imageRendering: string;
2996 justifyContent: string;
2997 justifyItems: string;
2998 justifySelf: string;
3000 readonly length: number;
3001 letterSpacing: string;
3002 lightingColor: string;
3006 listStyleImage: string;
3007 listStylePosition: string;
3008 listStyleType: string;
3010 marginBlockEnd: string;
3011 marginBlockStart: string;
3012 marginBottom: string;
3013 marginInlineEnd: string;
3014 marginInlineStart: string;
3016 marginRight: string;
3021 markerStart: string;
3023 maskComposite: string;
3025 maskPosition: string;
3029 maxBlockSize: string;
3031 maxInlineSize: string;
3033 minBlockSize: string;
3035 minInlineSize: string;
3038 objectPosition: string;
3043 outlineColor: string;
3044 outlineOffset: string;
3045 outlineStyle: string;
3046 outlineWidth: string;
3048 overflowAnchor: string;
3049 overflowWrap: string;
3052 overscrollBehavior: string;
3053 overscrollBehaviorBlock: string;
3054 overscrollBehaviorInline: string;
3055 overscrollBehaviorX: string;
3056 overscrollBehaviorY: string;
3058 paddingBlockEnd: string;
3059 paddingBlockStart: string;
3060 paddingBottom: string;
3061 paddingInlineEnd: string;
3062 paddingInlineStart: string;
3063 paddingLeft: string;
3064 paddingRight: string;
3066 pageBreakAfter: string;
3067 pageBreakBefore: string;
3068 pageBreakInside: string;
3070 readonly parentRule: CSSRule | null;
3071 perspective: string;
3072 perspectiveOrigin: string;
3073 placeContent: string;
3076 pointerEvents: string;
3084 rubyPosition: string;
3086 scrollBehavior: string;
3087 shapeRendering: string;
3089 stopOpacity: string;
3091 strokeDasharray: string;
3092 strokeDashoffset: string;
3093 strokeLinecap: string;
3094 strokeLinejoin: string;
3095 strokeMiterlimit: string;
3096 strokeOpacity: string;
3097 strokeWidth: string;
3099 tableLayout: string;
3101 textAlignLast: string;
3103 textCombineUpright: string;
3104 textDecoration: string;
3105 textDecorationColor: string;
3106 textDecorationLine: string;
3107 textDecorationStyle: string;
3108 textEmphasis: string;
3109 textEmphasisColor: string;
3110 textEmphasisPosition: string;
3111 textEmphasisStyle: string;
3113 textJustify: string;
3114 textOrientation: string;
3115 textOverflow: string;
3116 textRendering: string;
3118 textTransform: string;
3119 textUnderlinePosition: string;
3121 touchAction: string;
3123 transformBox: string;
3124 transformOrigin: string;
3125 transformStyle: string;
3127 transitionDelay: string;
3128 transitionDuration: string;
3129 transitionProperty: string;
3130 transitionTimingFunction: string;
3132 unicodeBidi: string;
3134 verticalAlign: string;
3137 webkitAlignContent: string;
3139 webkitAlignItems: string;
3141 webkitAlignSelf: string;
3143 webkitAnimation: string;
3145 webkitAnimationDelay: string;
3147 webkitAnimationDirection: string;
3149 webkitAnimationDuration: string;
3151 webkitAnimationFillMode: string;
3153 webkitAnimationIterationCount: string;
3155 webkitAnimationName: string;
3157 webkitAnimationPlayState: string;
3159 webkitAnimationTimingFunction: string;
3161 webkitAppearance: string;
3163 webkitBackfaceVisibility: string;
3165 webkitBackgroundClip: string;
3167 webkitBackgroundOrigin: string;
3169 webkitBackgroundSize: string;
3171 webkitBorderBottomLeftRadius: string;
3173 webkitBorderBottomRightRadius: string;
3175 webkitBorderRadius: string;
3177 webkitBorderTopLeftRadius: string;
3179 webkitBorderTopRightRadius: string;
3181 webkitBoxAlign: string;
3183 webkitBoxFlex: string;
3185 webkitBoxOrdinalGroup: string;
3187 webkitBoxOrient: string;
3189 webkitBoxPack: string;
3191 webkitBoxShadow: string;
3193 webkitBoxSizing: string;
3195 webkitFilter: string;
3199 webkitFlexBasis: string;
3201 webkitFlexDirection: string;
3203 webkitFlexFlow: string;
3205 webkitFlexGrow: string;
3207 webkitFlexShrink: string;
3209 webkitFlexWrap: string;
3211 webkitJustifyContent: string;
3212 webkitLineClamp: string;
3216 webkitMaskBoxImage: string;
3218 webkitMaskBoxImageOutset: string;
3220 webkitMaskBoxImageRepeat: string;
3222 webkitMaskBoxImageSlice: string;
3224 webkitMaskBoxImageSource: string;
3226 webkitMaskBoxImageWidth: string;
3228 webkitMaskClip: string;
3230 webkitMaskComposite: string;
3232 webkitMaskImage: string;
3234 webkitMaskOrigin: string;
3236 webkitMaskPosition: string;
3238 webkitMaskRepeat: string;
3240 webkitMaskSize: string;
3242 webkitOrder: string;
3244 webkitPerspective: string;
3246 webkitPerspectiveOrigin: string;
3247 webkitTapHighlightColor: string;
3249 webkitTextFillColor: string;
3251 webkitTextSizeAdjust: string;
3253 webkitTextStroke: string;
3255 webkitTextStrokeColor: string;
3257 webkitTextStrokeWidth: string;
3259 webkitTransform: string;
3261 webkitTransformOrigin: string;
3263 webkitTransformStyle: string;
3265 webkitTransition: string;
3267 webkitTransitionDelay: string;
3269 webkitTransitionDuration: string;
3271 webkitTransitionProperty: string;
3273 webkitTransitionTimingFunction: string;
3275 webkitUserSelect: string;
3281 wordSpacing: string;
3283 writingMode: string;
3287 getPropertyPriority(property: string): string;
3288 getPropertyValue(property: string): string;
3289 item(index: number): string;
3290 removeProperty(property: string): string;
3291 setProperty(property: string, value: string | null, priority?: string): void;
3292 [index: number]: string;
3295 declare var CSSStyleDeclaration: {
3296 prototype: CSSStyleDeclaration;
3297 new(): CSSStyleDeclaration;
3300 /** CSSStyleRule represents a single CSS style rule. It implements the CSSRule interface with a type value of 1 (CSSRule.STYLE_RULE). */
3301 interface CSSStyleRule extends CSSRule {
3302 selectorText: string;
3303 readonly style: CSSStyleDeclaration;
3306 declare var CSSStyleRule: {
3307 prototype: CSSStyleRule;
3308 new(): CSSStyleRule;
3311 /** A single CSS style sheet. It inherits properties and methods from its parent, StyleSheet. */
3312 interface CSSStyleSheet extends StyleSheet {
3313 readonly cssRules: CSSRuleList;
3314 readonly ownerRule: CSSRule | null;
3315 readonly rules: CSSRuleList;
3316 addRule(selector?: string, style?: string, index?: number): number;
3317 deleteRule(index: number): void;
3318 insertRule(rule: string, index?: number): number;
3319 removeRule(index?: number): void;
3322 declare var CSSStyleSheet: {
3323 prototype: CSSStyleSheet;
3324 new(): CSSStyleSheet;
3327 /** An object representing a single CSS @supports at-rule. It implements the CSSConditionRule interface, and therefore the CSSRule and CSSGroupingRule interfaces with a type value of 12 (CSSRule.SUPPORTS_RULE). */
3328 interface CSSSupportsRule extends CSSConditionRule {
3331 declare var CSSSupportsRule: {
3332 prototype: CSSSupportsRule;
3333 new(): CSSSupportsRule;
3336 /** Provides a storage mechanism for Request / Response object pairs that are cached, for example as part of the ServiceWorker life cycle. Note that the Cache interface is exposed to windowed scopes as well as workers. You don't have to use it in conjunction with service workers, even though it is defined in the service worker spec. */
3338 add(request: RequestInfo): Promise<void>;
3339 addAll(requests: RequestInfo[]): Promise<void>;
3340 delete(request: RequestInfo, options?: CacheQueryOptions): Promise<boolean>;
3341 keys(request?: RequestInfo, options?: CacheQueryOptions): Promise<ReadonlyArray<Request>>;
3342 match(request: RequestInfo, options?: CacheQueryOptions): Promise<Response | undefined>;
3343 matchAll(request?: RequestInfo, options?: CacheQueryOptions): Promise<ReadonlyArray<Response>>;
3344 put(request: RequestInfo, response: Response): Promise<void>;
3347 declare var Cache: {
3352 /** The storage for Cache objects. */
3353 interface CacheStorage {
3354 delete(cacheName: string): Promise<boolean>;
3355 has(cacheName: string): Promise<boolean>;
3356 keys(): Promise<string[]>;
3357 match(request: RequestInfo, options?: MultiCacheQueryOptions): Promise<Response | undefined>;
3358 open(cacheName: string): Promise<Cache>;
3361 declare var CacheStorage: {
3362 prototype: CacheStorage;
3363 new(): CacheStorage;
3366 interface CanvasCompositing {
3367 globalAlpha: number;
3368 globalCompositeOperation: string;
3371 interface CanvasDrawImage {
3372 drawImage(image: CanvasImageSource, dx: number, dy: number): void;
3373 drawImage(image: CanvasImageSource, dx: number, dy: number, dw: number, dh: number): void;
3374 drawImage(image: CanvasImageSource, sx: number, sy: number, sw: number, sh: number, dx: number, dy: number, dw: number, dh: number): void;
3377 interface CanvasDrawPath {
3379 clip(fillRule?: CanvasFillRule): void;
3380 clip(path: Path2D, fillRule?: CanvasFillRule): void;
3381 fill(fillRule?: CanvasFillRule): void;
3382 fill(path: Path2D, fillRule?: CanvasFillRule): void;
3383 isPointInPath(x: number, y: number, fillRule?: CanvasFillRule): boolean;
3384 isPointInPath(path: Path2D, x: number, y: number, fillRule?: CanvasFillRule): boolean;
3385 isPointInStroke(x: number, y: number): boolean;
3386 isPointInStroke(path: Path2D, x: number, y: number): boolean;
3388 stroke(path: Path2D): void;
3391 interface CanvasFillStrokeStyles {
3392 fillStyle: string | CanvasGradient | CanvasPattern;
3393 strokeStyle: string | CanvasGradient | CanvasPattern;
3394 createLinearGradient(x0: number, y0: number, x1: number, y1: number): CanvasGradient;
3395 createPattern(image: CanvasImageSource, repetition: string | null): CanvasPattern | null;
3396 createRadialGradient(x0: number, y0: number, r0: number, x1: number, y1: number, r1: number): CanvasGradient;
3399 interface CanvasFilters {
3403 /** An opaque object describing a gradient. It is returned by the methods CanvasRenderingContext2D.createLinearGradient() or CanvasRenderingContext2D.createRadialGradient(). */
3404 interface CanvasGradient {
3406 * Adds a color stop with the given color to the gradient at the given offset. 0.0 is the offset at one end of the gradient, 1.0 is the offset at the other end.
3408 * Throws an "IndexSizeError" DOMException if the offset is out of range. Throws a "SyntaxError" DOMException if the color cannot be parsed.
3410 addColorStop(offset: number, color: string): void;
3413 declare var CanvasGradient: {
3414 prototype: CanvasGradient;
3415 new(): CanvasGradient;
3418 interface CanvasImageData {
3419 createImageData(sw: number, sh: number): ImageData;
3420 createImageData(imagedata: ImageData): ImageData;
3421 getImageData(sx: number, sy: number, sw: number, sh: number): ImageData;
3422 putImageData(imagedata: ImageData, dx: number, dy: number): void;
3423 putImageData(imagedata: ImageData, dx: number, dy: number, dirtyX: number, dirtyY: number, dirtyWidth: number, dirtyHeight: number): void;
3426 interface CanvasImageSmoothing {
3427 imageSmoothingEnabled: boolean;
3428 imageSmoothingQuality: ImageSmoothingQuality;
3431 interface CanvasPath {
3432 arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, anticlockwise?: boolean): void;
3433 arcTo(x1: number, y1: number, x2: number, y2: number, radius: number): void;
3434 bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number): void;
3436 ellipse(x: number, y: number, radiusX: number, radiusY: number, rotation: number, startAngle: number, endAngle: number, anticlockwise?: boolean): void;
3437 lineTo(x: number, y: number): void;
3438 moveTo(x: number, y: number): void;
3439 quadraticCurveTo(cpx: number, cpy: number, x: number, y: number): void;
3440 rect(x: number, y: number, w: number, h: number): void;
3443 interface CanvasPathDrawingStyles {
3444 lineCap: CanvasLineCap;
3445 lineDashOffset: number;
3446 lineJoin: CanvasLineJoin;
3449 getLineDash(): number[];
3450 setLineDash(segments: number[]): void;
3453 /** An opaque object describing a pattern, based on an image, a canvas, or a video, created by the CanvasRenderingContext2D.createPattern() method. */
3454 interface CanvasPattern {
3456 * Sets the transformation matrix that will be used when rendering the pattern during a fill or stroke painting operation.
3458 setTransform(transform?: DOMMatrix2DInit): void;
3461 declare var CanvasPattern: {
3462 prototype: CanvasPattern;
3463 new(): CanvasPattern;
3466 interface CanvasRect {
3467 clearRect(x: number, y: number, w: number, h: number): void;
3468 fillRect(x: number, y: number, w: number, h: number): void;
3469 strokeRect(x: number, y: number, w: number, h: number): void;
3472 /** The CanvasRenderingContext2D interface, part of the Canvas API, provides the 2D rendering context for the drawing surface of a <canvas> element. It is used for drawing shapes, text, images, and other objects. */
3473 interface CanvasRenderingContext2D extends CanvasCompositing, CanvasDrawImage, CanvasDrawPath, CanvasFillStrokeStyles, CanvasFilters, CanvasImageData, CanvasImageSmoothing, CanvasPath, CanvasPathDrawingStyles, CanvasRect, CanvasShadowStyles, CanvasState, CanvasText, CanvasTextDrawingStyles, CanvasTransform, CanvasUserInterface {
3474 readonly canvas: HTMLCanvasElement;
3477 declare var CanvasRenderingContext2D: {
3478 prototype: CanvasRenderingContext2D;
3479 new(): CanvasRenderingContext2D;
3482 interface CanvasShadowStyles {
3484 shadowColor: string;
3485 shadowOffsetX: number;
3486 shadowOffsetY: number;
3489 interface CanvasState {
3494 interface CanvasText {
3495 fillText(text: string, x: number, y: number, maxWidth?: number): void;
3496 measureText(text: string): TextMetrics;
3497 strokeText(text: string, x: number, y: number, maxWidth?: number): void;
3500 interface CanvasTextDrawingStyles {
3501 direction: CanvasDirection;
3503 textAlign: CanvasTextAlign;
3504 textBaseline: CanvasTextBaseline;
3507 interface CanvasTransform {
3508 getTransform(): DOMMatrix;
3509 resetTransform(): void;
3510 rotate(angle: number): void;
3511 scale(x: number, y: number): void;
3512 setTransform(a: number, b: number, c: number, d: number, e: number, f: number): void;
3513 setTransform(transform?: DOMMatrix2DInit): void;
3514 transform(a: number, b: number, c: number, d: number, e: number, f: number): void;
3515 translate(x: number, y: number): void;
3518 interface CanvasUserInterface {
3519 drawFocusIfNeeded(element: Element): void;
3520 drawFocusIfNeeded(path: Path2D, element: Element): void;
3521 scrollPathIntoView(): void;
3522 scrollPathIntoView(path: Path2D): void;
3525 interface CaretPosition {
3526 readonly offset: number;
3527 readonly offsetNode: Node;
3528 getClientRect(): DOMRect | null;
3531 declare var CaretPosition: {
3532 prototype: CaretPosition;
3533 new(): CaretPosition;
3536 /** The ChannelMergerNode interface, often used in conjunction with its opposite, ChannelSplitterNode, reunites different mono inputs into a single output. Each input is used to fill a channel of the output. This is useful for accessing each channels separately, e.g. for performing channel mixing where gain must be separately controlled on each channel. */
3537 interface ChannelMergerNode extends AudioNode {
3540 declare var ChannelMergerNode: {
3541 prototype: ChannelMergerNode;
3542 new(context: BaseAudioContext, options?: ChannelMergerOptions): ChannelMergerNode;
3545 /** The ChannelSplitterNode interface, often used in conjunction with its opposite, ChannelMergerNode, separates the different channels of an audio source into a set of mono outputs. This is useful for accessing each channel separately, e.g. for performing channel mixing where gain must be separately controlled on each channel. */
3546 interface ChannelSplitterNode extends AudioNode {
3549 declare var ChannelSplitterNode: {
3550 prototype: ChannelSplitterNode;
3551 new(context: BaseAudioContext, options?: ChannelSplitterOptions): ChannelSplitterNode;
3554 /** The CharacterData abstract interface represents a Node object that contains characters. This is an abstract interface, meaning there aren't any object of type CharacterData: it is implemented by other interfaces, like Text, Comment, or ProcessingInstruction which aren't abstract. */
3555 interface CharacterData extends Node, ChildNode, NonDocumentTypeChildNode {
3557 readonly length: number;
3558 readonly ownerDocument: Document;
3559 appendData(data: string): void;
3560 deleteData(offset: number, count: number): void;
3561 insertData(offset: number, data: string): void;
3562 replaceData(offset: number, count: number, data: string): void;
3563 substringData(offset: number, count: number): string;
3566 declare var CharacterData: {
3567 prototype: CharacterData;
3568 new(): CharacterData;
3571 interface ChildNode extends Node {
3573 * Inserts nodes just after node, while replacing strings in nodes with equivalent Text nodes.
3575 * Throws a "HierarchyRequestError" DOMException if the constraints of the node tree are violated.
3577 after(...nodes: (Node | string)[]): void;
3579 * Inserts nodes just before node, while replacing strings in nodes with equivalent Text nodes.
3581 * Throws a "HierarchyRequestError" DOMException if the constraints of the node tree are violated.
3583 before(...nodes: (Node | string)[]): void;
3589 * Replaces node with nodes, while replacing strings in nodes with equivalent Text nodes.
3591 * Throws a "HierarchyRequestError" DOMException if the constraints of the node tree are violated.
3593 replaceWith(...nodes: (Node | string)[]): void;
3596 interface ClientRect {
3598 readonly height: number;
3602 readonly width: number;
3605 declare var ClientRect: {
3606 prototype: ClientRect;
3610 interface ClientRectList {
3611 readonly length: number;
3612 item(index: number): ClientRect;
3613 [index: number]: ClientRect;
3616 declare var ClientRectList: {
3617 prototype: ClientRectList;
3618 new(): ClientRectList;
3621 interface Clipboard extends EventTarget {
3622 readText(): Promise<string>;
3623 writeText(data: string): Promise<void>;
3626 declare var Clipboard: {
3627 prototype: Clipboard;
3631 /** Events providing information related to modification of the clipboard, that is cut, copy, and paste events. */
3632 interface ClipboardEvent extends Event {
3633 readonly clipboardData: DataTransfer | null;
3636 declare var ClipboardEvent: {
3637 prototype: ClipboardEvent;
3638 new(type: string, eventInitDict?: ClipboardEventInit): ClipboardEvent;
3641 /** A CloseEvent is sent to clients using WebSockets when the connection is closed. This is delivered to the listener indicated by the WebSocket object's onclose attribute. */
3642 interface CloseEvent extends Event {
3644 * Returns the WebSocket connection close code provided by the server.
3646 readonly code: number;
3648 * Returns the WebSocket connection close reason provided by the server.
3650 readonly reason: string;
3652 * Returns true if the connection closed cleanly; false otherwise.
3654 readonly wasClean: boolean;
3657 declare var CloseEvent: {
3658 prototype: CloseEvent;
3659 new(type: string, eventInitDict?: CloseEventInit): CloseEvent;
3662 /** Textual notations within markup; although it is generally not visually shown, such comments are available to be read in the source view. */
3663 interface Comment extends CharacterData {
3666 declare var Comment: {
3668 new(data?: string): Comment;
3671 /** The DOM CompositionEvent represents events that occur due to the user indirectly entering text. */
3672 interface CompositionEvent extends UIEvent {
3673 readonly data: string;
3676 declare var CompositionEvent: {
3677 prototype: CompositionEvent;
3678 new(type: string, eventInitDict?: CompositionEventInit): CompositionEvent;
3681 interface ConcatParams extends Algorithm {
3682 algorithmId: Uint8Array;
3683 hash?: string | Algorithm;
3684 partyUInfo: Uint8Array;
3685 partyVInfo: Uint8Array;
3686 privateInfo?: Uint8Array;
3687 publicInfo?: Uint8Array;
3690 interface ConstantSourceNode extends AudioScheduledSourceNode {
3691 readonly offset: AudioParam;
3692 addEventListener<K extends keyof AudioScheduledSourceNodeEventMap>(type: K, listener: (this: ConstantSourceNode, ev: AudioScheduledSourceNodeEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
3693 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
3694 removeEventListener<K extends keyof AudioScheduledSourceNodeEventMap>(type: K, listener: (this: ConstantSourceNode, ev: AudioScheduledSourceNodeEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
3695 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
3698 declare var ConstantSourceNode: {
3699 prototype: ConstantSourceNode;
3700 new(context: BaseAudioContext, options?: ConstantSourceOptions): ConstantSourceNode;
3703 /** An AudioNode that performs a Linear Convolution on a given AudioBuffer, often used to achieve a reverb effect. A ConvolverNode always has exactly one input and one output. */
3704 interface ConvolverNode extends AudioNode {
3705 buffer: AudioBuffer | null;
3709 declare var ConvolverNode: {
3710 prototype: ConvolverNode;
3711 new(context: BaseAudioContext, options?: ConvolverOptions): ConvolverNode;
3714 /** This Streams API interface provides a built-in byte length queuing strategy that can be used when constructing streams. */
3715 interface CountQueuingStrategy extends QueuingStrategy {
3716 readonly highWaterMark: number;
3717 readonly size: QueuingStrategySize;
3720 declare var CountQueuingStrategy: {
3721 prototype: CountQueuingStrategy;
3722 new(init: QueuingStrategyInit): CountQueuingStrategy;
3725 interface Credential {
3726 readonly id: string;
3727 readonly type: string;
3730 declare var Credential: {
3731 prototype: Credential;
3735 interface CredentialsContainer {
3736 create(options?: CredentialCreationOptions): Promise<Credential | null>;
3737 get(options?: CredentialRequestOptions): Promise<Credential | null>;
3738 preventSilentAccess(): Promise<void>;
3739 store(credential: Credential): Promise<Credential>;
3742 declare var CredentialsContainer: {
3743 prototype: CredentialsContainer;
3744 new(): CredentialsContainer;
3747 /** Basic cryptography features available in the current context. It allows access to a cryptographically strong random number generator and to cryptographic primitives. */
3749 readonly subtle: SubtleCrypto;
3750 getRandomValues<T extends Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | null>(array: T): T;
3753 declare var Crypto: {
3758 /** The CryptoKey dictionary of the Web Crypto API represents a cryptographic key. */
3759 interface CryptoKey {
3760 readonly algorithm: KeyAlgorithm;
3761 readonly extractable: boolean;
3762 readonly type: KeyType;
3763 readonly usages: KeyUsage[];
3766 declare var CryptoKey: {
3767 prototype: CryptoKey;
3771 /** The CryptoKeyPair dictionary of the Web Crypto API represents a key pair for an asymmetric cryptography algorithm, also known as a public-key algorithm. */
3772 interface CryptoKeyPair {
3773 privateKey: CryptoKey;
3774 publicKey: CryptoKey;
3777 declare var CryptoKeyPair: {
3778 prototype: CryptoKeyPair;
3779 new(): CryptoKeyPair;
3782 interface CustomElementRegistry {
3783 define(name: string, constructor: CustomElementConstructor, options?: ElementDefinitionOptions): void;
3784 get(name: string): any;
3785 upgrade(root: Node): void;
3786 whenDefined(name: string): Promise<void>;
3789 declare var CustomElementRegistry: {
3790 prototype: CustomElementRegistry;
3791 new(): CustomElementRegistry;
3794 interface CustomEvent<T = any> extends Event {
3796 * Returns any custom data event was created with. Typically used for synthetic events.
3799 initCustomEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, detailArg: T): void;
3802 declare var CustomEvent: {
3803 prototype: CustomEvent;
3804 new<T>(typeArg: string, eventInitDict?: CustomEventInit<T>): CustomEvent<T>;
3807 /** An error object that contains an error name. */
3808 interface DOMError {
3809 readonly name: string;
3813 declare var DOMError: {
3814 prototype: DOMError;
3818 /** An abnormal event (called an exception) which occurs as a result of calling a method or accessing a property of a web API. */
3819 interface DOMException {
3820 readonly code: number;
3821 readonly message: string;
3822 readonly name: string;
3823 readonly ABORT_ERR: number;
3824 readonly DATA_CLONE_ERR: number;
3825 readonly DOMSTRING_SIZE_ERR: number;
3826 readonly HIERARCHY_REQUEST_ERR: number;
3827 readonly INDEX_SIZE_ERR: number;
3828 readonly INUSE_ATTRIBUTE_ERR: number;
3829 readonly INVALID_ACCESS_ERR: number;
3830 readonly INVALID_CHARACTER_ERR: number;
3831 readonly INVALID_MODIFICATION_ERR: number;
3832 readonly INVALID_NODE_TYPE_ERR: number;
3833 readonly INVALID_STATE_ERR: number;
3834 readonly NAMESPACE_ERR: number;
3835 readonly NETWORK_ERR: number;
3836 readonly NOT_FOUND_ERR: number;
3837 readonly NOT_SUPPORTED_ERR: number;
3838 readonly NO_DATA_ALLOWED_ERR: number;
3839 readonly NO_MODIFICATION_ALLOWED_ERR: number;
3840 readonly QUOTA_EXCEEDED_ERR: number;
3841 readonly SECURITY_ERR: number;
3842 readonly SYNTAX_ERR: number;
3843 readonly TIMEOUT_ERR: number;
3844 readonly TYPE_MISMATCH_ERR: number;
3845 readonly URL_MISMATCH_ERR: number;
3846 readonly VALIDATION_ERR: number;
3847 readonly WRONG_DOCUMENT_ERR: number;
3850 declare var DOMException: {
3851 prototype: DOMException;
3852 new(message?: string, name?: string): DOMException;
3853 readonly ABORT_ERR: number;
3854 readonly DATA_CLONE_ERR: number;
3855 readonly DOMSTRING_SIZE_ERR: number;
3856 readonly HIERARCHY_REQUEST_ERR: number;
3857 readonly INDEX_SIZE_ERR: number;
3858 readonly INUSE_ATTRIBUTE_ERR: number;
3859 readonly INVALID_ACCESS_ERR: number;
3860 readonly INVALID_CHARACTER_ERR: number;
3861 readonly INVALID_MODIFICATION_ERR: number;
3862 readonly INVALID_NODE_TYPE_ERR: number;
3863 readonly INVALID_STATE_ERR: number;
3864 readonly NAMESPACE_ERR: number;
3865 readonly NETWORK_ERR: number;
3866 readonly NOT_FOUND_ERR: number;
3867 readonly NOT_SUPPORTED_ERR: number;
3868 readonly NO_DATA_ALLOWED_ERR: number;
3869 readonly NO_MODIFICATION_ALLOWED_ERR: number;
3870 readonly QUOTA_EXCEEDED_ERR: number;
3871 readonly SECURITY_ERR: number;
3872 readonly SYNTAX_ERR: number;
3873 readonly TIMEOUT_ERR: number;
3874 readonly TYPE_MISMATCH_ERR: number;
3875 readonly URL_MISMATCH_ERR: number;
3876 readonly VALIDATION_ERR: number;
3877 readonly WRONG_DOCUMENT_ERR: number;
3880 /** An object providing methods which are not dependent on any particular document. Such an object is returned by the Document.implementation property. */
3881 interface DOMImplementation {
3882 createDocument(namespace: string | null, qualifiedName: string | null, doctype?: DocumentType | null): XMLDocument;
3883 createDocumentType(qualifiedName: string, publicId: string, systemId: string): DocumentType;
3884 createHTMLDocument(title?: string): Document;
3886 hasFeature(...args: any[]): true;
3889 declare var DOMImplementation: {
3890 prototype: DOMImplementation;
3891 new(): DOMImplementation;
3894 interface DOML2DeprecatedColorProperty {
3898 interface DOMMatrix extends DOMMatrixReadOnly {
3921 invertSelf(): DOMMatrix;
3922 multiplySelf(other?: DOMMatrixInit): DOMMatrix;
3923 preMultiplySelf(other?: DOMMatrixInit): DOMMatrix;
3924 rotateAxisAngleSelf(x?: number, y?: number, z?: number, angle?: number): DOMMatrix;
3925 rotateFromVectorSelf(x?: number, y?: number): DOMMatrix;
3926 rotateSelf(rotX?: number, rotY?: number, rotZ?: number): DOMMatrix;
3927 scale3dSelf(scale?: number, originX?: number, originY?: number, originZ?: number): DOMMatrix;
3928 scaleSelf(scaleX?: number, scaleY?: number, scaleZ?: number, originX?: number, originY?: number, originZ?: number): DOMMatrix;
3929 setMatrixValue(transformList: string): DOMMatrix;
3930 skewXSelf(sx?: number): DOMMatrix;
3931 skewYSelf(sy?: number): DOMMatrix;
3932 translateSelf(tx?: number, ty?: number, tz?: number): DOMMatrix;
3935 declare var DOMMatrix: {
3936 prototype: DOMMatrix;
3937 new(init?: string | number[]): DOMMatrix;
3938 fromFloat32Array(array32: Float32Array): DOMMatrix;
3939 fromFloat64Array(array64: Float64Array): DOMMatrix;
3940 fromMatrix(other?: DOMMatrixInit): DOMMatrix;
3943 type SVGMatrix = DOMMatrix;
3944 declare var SVGMatrix: typeof DOMMatrix;
3946 type WebKitCSSMatrix = DOMMatrix;
3947 declare var WebKitCSSMatrix: typeof DOMMatrix;
3949 interface DOMMatrixReadOnly {
3956 readonly is2D: boolean;
3957 readonly isIdentity: boolean;
3958 readonly m11: number;
3959 readonly m12: number;
3960 readonly m13: number;
3961 readonly m14: number;
3962 readonly m21: number;
3963 readonly m22: number;
3964 readonly m23: number;
3965 readonly m24: number;
3966 readonly m31: number;
3967 readonly m32: number;
3968 readonly m33: number;
3969 readonly m34: number;
3970 readonly m41: number;
3971 readonly m42: number;
3972 readonly m43: number;
3973 readonly m44: number;
3976 inverse(): DOMMatrix;
3977 multiply(other?: DOMMatrixInit): DOMMatrix;
3978 rotate(rotX?: number, rotY?: number, rotZ?: number): DOMMatrix;
3979 rotateAxisAngle(x?: number, y?: number, z?: number, angle?: number): DOMMatrix;
3980 rotateFromVector(x?: number, y?: number): DOMMatrix;
3981 scale(scaleX?: number, scaleY?: number, scaleZ?: number, originX?: number, originY?: number, originZ?: number): DOMMatrix;
3982 scale3d(scale?: number, originX?: number, originY?: number, originZ?: number): DOMMatrix;
3984 scaleNonUniform(scaleX?: number, scaleY?: number): DOMMatrix;
3985 skewX(sx?: number): DOMMatrix;
3986 skewY(sy?: number): DOMMatrix;
3987 toFloat32Array(): Float32Array;
3988 toFloat64Array(): Float64Array;
3990 transformPoint(point?: DOMPointInit): DOMPoint;
3991 translate(tx?: number, ty?: number, tz?: number): DOMMatrix;
3995 declare var DOMMatrixReadOnly: {
3996 prototype: DOMMatrixReadOnly;
3997 new(init?: string | number[]): DOMMatrixReadOnly;
3998 fromFloat32Array(array32: Float32Array): DOMMatrixReadOnly;
3999 fromFloat64Array(array64: Float64Array): DOMMatrixReadOnly;
4000 fromMatrix(other?: DOMMatrixInit): DOMMatrixReadOnly;
4004 /** Provides the ability to parse XML or HTML source code from a string into a DOM Document. */
4005 interface DOMParser {
4007 * Parses string using either the HTML or XML parser, according to type, and returns the resulting Document. type can be "text/html" (which will invoke the HTML parser), or any of "text/xml", "application/xml", "application/xhtml+xml", or "image/svg+xml" (which will invoke the XML parser).
4009 * For the XML parser, if string cannot be parsed, then the returned Document will contain elements describing the resulting error.
4011 * Note that script elements are not evaluated during parsing, and the resulting document's encoding will always be UTF-8.
4013 * Values other than the above for type will cause a TypeError exception to be thrown.
4015 parseFromString(string: string, type: DOMParserSupportedType): Document;
4018 declare var DOMParser: {
4019 prototype: DOMParser;
4023 interface DOMPoint extends DOMPointReadOnly {
4030 declare var DOMPoint: {
4031 prototype: DOMPoint;
4032 new(x?: number, y?: number, z?: number, w?: number): DOMPoint;
4033 fromPoint(other?: DOMPointInit): DOMPoint;
4036 type SVGPoint = DOMPoint;
4037 declare var SVGPoint: typeof DOMPoint;
4039 interface DOMPointReadOnly {
4044 matrixTransform(matrix?: DOMMatrixInit): DOMPoint;
4048 declare var DOMPointReadOnly: {
4049 prototype: DOMPointReadOnly;
4050 new(x?: number, y?: number, z?: number, w?: number): DOMPointReadOnly;
4051 fromPoint(other?: DOMPointInit): DOMPointReadOnly;
4055 readonly p1: DOMPoint;
4056 readonly p2: DOMPoint;
4057 readonly p3: DOMPoint;
4058 readonly p4: DOMPoint;
4059 getBounds(): DOMRect;
4063 declare var DOMQuad: {
4065 new(p1?: DOMPointInit, p2?: DOMPointInit, p3?: DOMPointInit, p4?: DOMPointInit): DOMQuad;
4066 fromQuad(other?: DOMQuadInit): DOMQuad;
4067 fromRect(other?: DOMRectInit): DOMQuad;
4070 interface DOMRect extends DOMRectReadOnly {
4077 declare var DOMRect: {
4079 new(x?: number, y?: number, width?: number, height?: number): DOMRect;
4080 fromRect(other?: DOMRectInit): DOMRect;
4083 type SVGRect = DOMRect;
4084 declare var SVGRect: typeof DOMRect;
4086 interface DOMRectList {
4087 readonly length: number;
4088 item(index: number): DOMRect | null;
4089 [index: number]: DOMRect;
4092 declare var DOMRectList: {
4093 prototype: DOMRectList;
4097 interface DOMRectReadOnly {
4098 readonly bottom: number;
4099 readonly height: number;
4100 readonly left: number;
4101 readonly right: number;
4102 readonly top: number;
4103 readonly width: number;
4109 declare var DOMRectReadOnly: {
4110 prototype: DOMRectReadOnly;
4111 new(x?: number, y?: number, width?: number, height?: number): DOMRectReadOnly;
4112 fromRect(other?: DOMRectInit): DOMRectReadOnly;
4115 interface DOMSettableTokenList extends DOMTokenList {
4119 declare var DOMSettableTokenList: {
4120 prototype: DOMSettableTokenList;
4121 new(): DOMSettableTokenList;
4124 /** A type returned by some APIs which contains a list of DOMString (strings). */
4125 interface DOMStringList {
4127 * Returns the number of strings in strings.
4129 readonly length: number;
4131 * Returns true if strings contains string, and false otherwise.
4133 contains(string: string): boolean;
4135 * Returns the string with index index from strings.
4137 item(index: number): string | null;
4138 [index: number]: string;
4141 declare var DOMStringList: {
4142 prototype: DOMStringList;
4143 new(): DOMStringList;
4146 /** Used by the dataset HTML attribute to represent data for custom attributes added to elements. */
4147 interface DOMStringMap {
4148 [name: string]: string | undefined;
4151 declare var DOMStringMap: {
4152 prototype: DOMStringMap;
4153 new(): DOMStringMap;
4156 /** A set of space-separated tokens. Such a set is returned by Element.classList, HTMLLinkElement.relList, HTMLAnchorElement.relList, HTMLAreaElement.relList, HTMLIframeElement.sandbox, or HTMLOutputElement.htmlFor. It is indexed beginning with 0 as with JavaScript Array objects. DOMTokenList is always case-sensitive. */
4157 interface DOMTokenList {
4159 * Returns the number of tokens.
4161 readonly length: number;
4163 * Returns the associated set as string.
4165 * Can be set, to change the associated attribute.
4170 * Adds all arguments passed, except those already present.
4172 * Throws a "SyntaxError" DOMException if one of the arguments is the empty string.
4174 * Throws an "InvalidCharacterError" DOMException if one of the arguments contains any ASCII whitespace.
4176 add(...tokens: string[]): void;
4178 * Returns true if token is present, and false otherwise.
4180 contains(token: string): boolean;
4182 * Returns the token with index index.
4184 item(index: number): string | null;
4186 * Removes arguments passed, if they are present.
4188 * Throws a "SyntaxError" DOMException if one of the arguments is the empty string.
4190 * Throws an "InvalidCharacterError" DOMException if one of the arguments contains any ASCII whitespace.
4192 remove(...tokens: string[]): void;
4194 * Replaces token with newToken.
4196 * Returns true if token was replaced with newToken, and false otherwise.
4198 * Throws a "SyntaxError" DOMException if one of the arguments is the empty string.
4200 * Throws an "InvalidCharacterError" DOMException if one of the arguments contains any ASCII whitespace.
4202 replace(oldToken: string, newToken: string): void;
4204 * Returns true if token is in the associated attribute's supported tokens. Returns false otherwise.
4206 * Throws a TypeError if the associated attribute has no supported tokens defined.
4208 supports(token: string): boolean;
4210 * If force is not given, "toggles" token, removing it if it's present and adding it if it's not present. If force is true, adds token (same as add()). If force is false, removes token (same as remove()).
4212 * Returns true if token is now present, and false otherwise.
4214 * Throws a "SyntaxError" DOMException if token is empty.
4216 * Throws an "InvalidCharacterError" DOMException if token contains any spaces.
4218 toggle(token: string, force?: boolean): boolean;
4219 forEach(callbackfn: (value: string, key: number, parent: DOMTokenList) => void, thisArg?: any): void;
4220 [index: number]: string;
4223 declare var DOMTokenList: {
4224 prototype: DOMTokenList;
4225 new(): DOMTokenList;
4228 interface DataCue extends TextTrackCue {
4230 addEventListener<K extends keyof TextTrackCueEventMap>(type: K, listener: (this: DataCue, ev: TextTrackCueEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
4231 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
4232 removeEventListener<K extends keyof TextTrackCueEventMap>(type: K, listener: (this: DataCue, ev: TextTrackCueEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
4233 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
4236 declare var DataCue: {
4241 /** Used to hold the data that is being dragged during a drag and drop operation. It may hold one or more data items, each of one or more data types. For more information about drag and drop, see HTML Drag and Drop API. */
4242 interface DataTransfer {
4244 * Returns the kind of operation that is currently selected. If the kind of operation isn't one of those that is allowed by the effectAllowed attribute, then the operation will fail.
4246 * Can be set, to change the selected operation.
4248 * The possible values are "none", "copy", "link", and "move".
4250 dropEffect: "none" | "copy" | "link" | "move";
4252 * Returns the kinds of operations that are to be allowed.
4254 * Can be set (during the dragstart event), to change the allowed operations.
4256 * The possible values are "none", "copy", "copyLink", "copyMove", "link", "linkMove", "move", "all", and "uninitialized",
4258 effectAllowed: "none" | "copy" | "copyLink" | "copyMove" | "link" | "linkMove" | "move" | "all" | "uninitialized";
4260 * Returns a FileList of the files being dragged, if any.
4262 readonly files: FileList;
4264 * Returns a DataTransferItemList object, with the drag data.
4266 readonly items: DataTransferItemList;
4268 * Returns a frozen array listing the formats that were set in the dragstart event. In addition, if any files are being dragged, then one of the types will be the string "Files".
4270 readonly types: ReadonlyArray<string>;
4272 * Removes the data of the specified formats. Removes all data if the argument is omitted.
4274 clearData(format?: string): void;
4276 * Returns the specified data. If there is no such data, returns the empty string.
4278 getData(format: string): string;
4280 * Adds the specified data.
4282 setData(format: string, data: string): void;
4284 * Uses the given element to update the drag feedback, replacing any previously specified feedback.
4286 setDragImage(image: Element, x: number, y: number): void;
4289 declare var DataTransfer: {
4290 prototype: DataTransfer;
4291 new(): DataTransfer;
4294 /** One drag data item. During a drag operation, each drag event has a dataTransfer property which contains a list of drag data items. Each item in the list is a DataTransferItem object. */
4295 interface DataTransferItem {
4297 * Returns the drag data item kind, one of: "string", "file".
4299 readonly kind: string;
4301 * Returns the drag data item type string.
4303 readonly type: string;
4305 * Returns a File object, if the drag data item kind is File.
4307 getAsFile(): File | null;
4309 * Invokes the callback with the string data as the argument, if the drag data item kind is text.
4311 getAsString(callback: FunctionStringCallback | null): void;
4312 webkitGetAsEntry(): any;
4315 declare var DataTransferItem: {
4316 prototype: DataTransferItem;
4317 new(): DataTransferItem;
4320 /** A list of DataTransferItem objects representing items being dragged. During a drag operation, each DragEvent has a dataTransfer property and that property is a DataTransferItemList. */
4321 interface DataTransferItemList {
4323 * Returns the number of items in the drag data store.
4325 readonly length: number;
4327 * Adds a new entry for the given data to the drag data store. If the data is plain text then a type string has to be provided also.
4329 add(data: string, type: string): DataTransferItem | null;
4330 add(data: File): DataTransferItem | null;
4332 * Removes all the entries in the drag data store.
4335 item(index: number): DataTransferItem;
4337 * Removes the indexth entry in the drag data store.
4339 remove(index: number): void;
4340 [name: number]: DataTransferItem;
4343 declare var DataTransferItemList: {
4344 prototype: DataTransferItemList;
4345 new(): DataTransferItemList;
4348 interface DeferredPermissionRequest {
4349 readonly id: number;
4350 readonly type: MSWebViewPermissionType;
4351 readonly uri: string;
4356 declare var DeferredPermissionRequest: {
4357 prototype: DeferredPermissionRequest;
4358 new(): DeferredPermissionRequest;
4361 /** A delay-line; an AudioNode audio-processing module that causes a delay between the arrival of an input data and its propagation to the output. */
4362 interface DelayNode extends AudioNode {
4363 readonly delayTime: AudioParam;
4366 declare var DelayNode: {
4367 prototype: DelayNode;
4368 new(context: BaseAudioContext, options?: DelayOptions): DelayNode;
4371 /** Provides information about the amount of acceleration the device is experiencing along all three axes. */
4372 interface DeviceAcceleration {
4373 readonly x: number | null;
4374 readonly y: number | null;
4375 readonly z: number | null;
4378 declare var DeviceAcceleration: {
4379 prototype: DeviceAcceleration;
4380 new(): DeviceAcceleration;
4383 /** The DeviceLightEvent provides web developers with information from photo sensors or similiar detectors about ambient light levels near the device. For example this may be useful to adjust the screen's brightness based on the current ambient light level in order to save energy or provide better readability. */
4384 interface DeviceLightEvent extends Event {
4385 readonly value: number;
4388 declare var DeviceLightEvent: {
4389 prototype: DeviceLightEvent;
4390 new(typeArg: string, eventInitDict?: DeviceLightEventInit): DeviceLightEvent;
4393 /** The DeviceMotionEvent provides web developers with information about the speed of changes for the device's position and orientation. */
4394 interface DeviceMotionEvent extends Event {
4395 readonly acceleration: DeviceMotionEventAcceleration | null;
4396 readonly accelerationIncludingGravity: DeviceMotionEventAcceleration | null;
4397 readonly interval: number;
4398 readonly rotationRate: DeviceMotionEventRotationRate | null;
4401 declare var DeviceMotionEvent: {
4402 prototype: DeviceMotionEvent;
4403 new(type: string, eventInitDict?: DeviceMotionEventInit): DeviceMotionEvent;
4404 requestPermission(): Promise<PermissionState>;
4407 interface DeviceMotionEventAcceleration {
4408 readonly x: number | null;
4409 readonly y: number | null;
4410 readonly z: number | null;
4413 interface DeviceMotionEventRotationRate {
4414 readonly alpha: number | null;
4415 readonly beta: number | null;
4416 readonly gamma: number | null;
4419 /** The DeviceOrientationEvent provides web developers with information from the physical orientation of the device running the web page. */
4420 interface DeviceOrientationEvent extends Event {
4421 readonly absolute: boolean;
4422 readonly alpha: number | null;
4423 readonly beta: number | null;
4424 readonly gamma: number | null;
4427 declare var DeviceOrientationEvent: {
4428 prototype: DeviceOrientationEvent;
4429 new(type: string, eventInitDict?: DeviceOrientationEventInit): DeviceOrientationEvent;
4430 requestPermission(): Promise<PermissionState>;
4433 /** Provides information about the rate at which the device is rotating around all three axes. */
4434 interface DeviceRotationRate {
4435 readonly alpha: number | null;
4436 readonly beta: number | null;
4437 readonly gamma: number | null;
4440 declare var DeviceRotationRate: {
4441 prototype: DeviceRotationRate;
4442 new(): DeviceRotationRate;
4445 interface DhImportKeyParams extends Algorithm {
4446 generator: Uint8Array;
4450 interface DhKeyAlgorithm extends KeyAlgorithm {
4451 generator: Uint8Array;
4455 interface DhKeyDeriveParams extends Algorithm {
4459 interface DhKeyGenParams extends Algorithm {
4460 generator: Uint8Array;
4464 interface DocumentEventMap extends GlobalEventHandlersEventMap, DocumentAndElementEventHandlersEventMap {
4465 "fullscreenchange": Event;
4466 "fullscreenerror": Event;
4467 "pointerlockchange": Event;
4468 "pointerlockerror": Event;
4469 "readystatechange": Event;
4470 "visibilitychange": Event;
4473 /** Any web page loaded in the browser and serves as an entry point into the web page's content, which is the DOM tree. */
4474 interface Document extends Node, DocumentAndElementEventHandlers, DocumentOrShadowRoot, GlobalEventHandlers, NonElementParentNode, ParentNode, XPathEvaluatorBase {
4476 * Sets or gets the URL for the current document.
4478 readonly URL: string;
4480 * Sets or gets the color of all active links in the document.
4485 * Returns a reference to the collection of elements contained by the object.
4488 readonly all: HTMLAllCollection;
4490 * Retrieves a collection of all a objects that have a name and/or id property. Objects in this collection are in HTML source order.
4493 readonly anchors: HTMLCollectionOf<HTMLAnchorElement>;
4495 * Retrieves a collection of all applet objects in the document.
4498 readonly applets: HTMLCollectionOf<HTMLAppletElement>;
4500 * Deprecated. Sets or retrieves a value that indicates the background color behind the object.
4505 * Specifies the beginning and end of the document body.
4509 * Returns document's encoding.
4511 readonly characterSet: string;
4513 * Gets or sets the character set used to encode the object.
4515 readonly charset: string;
4517 * Gets a value that indicates whether standards-compliant mode is switched on for the object.
4519 readonly compatMode: string;
4521 * Returns document's content type.
4523 readonly contentType: string;
4525 * Returns the HTTP cookies that apply to the Document. If there are no cookies or cookies can't be applied to this resource, the empty string will be returned.
4527 * Can be set, to add a new cookie to the element's set of HTTP cookies.
4529 * If the contents are sandboxed into a unique origin (e.g. in an iframe with the sandbox attribute), a "SecurityError" DOMException will be thrown on getting and setting.
4533 * Returns the script element, or the SVG script element, that is currently executing, as long as the element represents a classic script. In the case of reentrant script execution, returns the one that most recently started executing amongst those that have not yet finished executing.
4535 * Returns null if the Document is not currently executing a script or SVG script element (e.g., because the running script is an event handler, or a timeout), or if the currently executing script or SVG script element represents a module script.
4537 readonly currentScript: HTMLOrSVGScriptElement | null;
4538 readonly defaultView: (WindowProxy & typeof globalThis) | null;
4540 * Sets or gets a value that indicates whether the document can be edited.
4544 * Sets or retrieves a value that indicates the reading order of the object.
4548 * Gets an object representing the document type declaration associated with the current document.
4550 readonly doctype: DocumentType | null;
4552 * Gets a reference to the root node of the document.
4554 readonly documentElement: HTMLElement;
4556 * Returns document's URL.
4558 readonly documentURI: string;
4560 * Sets or gets the security domain of the document.
4564 * Retrieves a collection of all embed objects in the document.
4566 readonly embeds: HTMLCollectionOf<HTMLEmbedElement>;
4568 * Sets or gets the foreground (text) color of the document.
4573 * Retrieves a collection, in source order, of all form objects in the document.
4575 readonly forms: HTMLCollectionOf<HTMLFormElement>;
4577 readonly fullscreen: boolean;
4579 * Returns true if document has the ability to display elements fullscreen and fullscreen is supported, or false otherwise.
4581 readonly fullscreenEnabled: boolean;
4583 * Returns the head element.
4585 readonly head: HTMLHeadElement;
4586 readonly hidden: boolean;
4588 * Retrieves a collection, in source order, of img objects in the document.
4590 readonly images: HTMLCollectionOf<HTMLImageElement>;
4592 * Gets the implementation object of the current document.
4594 readonly implementation: DOMImplementation;
4596 * Returns the character encoding used to create the webpage that is loaded into the document object.
4598 readonly inputEncoding: string;
4600 * Gets the date that the page was last modified, if the page supplies one.
4602 readonly lastModified: string;
4604 * Sets or gets the color of the document links.
4609 * Retrieves a collection of all a objects that specify the href property and all area objects in the document.
4611 readonly links: HTMLCollectionOf<HTMLAnchorElement | HTMLAreaElement>;
4613 * Contains information about the current URL.
4616 onfullscreenchange: ((this: Document, ev: Event) => any) | null;
4617 onfullscreenerror: ((this: Document, ev: Event) => any) | null;
4618 onpointerlockchange: ((this: Document, ev: Event) => any) | null;
4619 onpointerlockerror: ((this: Document, ev: Event) => any) | null;
4621 * Fires when the state of the object has changed.
4622 * @param ev The event
4624 onreadystatechange: ((this: Document, ev: Event) => any) | null;
4625 onvisibilitychange: ((this: Document, ev: Event) => any) | null;
4626 readonly ownerDocument: null;
4628 * Return an HTMLCollection of the embed elements in the Document.
4630 readonly plugins: HTMLCollectionOf<HTMLEmbedElement>;
4632 * Retrieves a value that indicates the current state of the object.
4634 readonly readyState: DocumentReadyState;
4636 * Gets the URL of the location that referred the user to the current page.
4638 readonly referrer: string;
4640 * Retrieves a collection of all script objects in the document.
4642 readonly scripts: HTMLCollectionOf<HTMLScriptElement>;
4643 readonly scrollingElement: Element | null;
4644 readonly timeline: DocumentTimeline;
4646 * Contains the title of the document.
4649 readonly visibilityState: VisibilityState;
4651 * Sets or gets the color of the links that the user has visited.
4656 * Moves node from another document and returns it.
4658 * If node is a document, throws a "NotSupportedError" DOMException or, if node is a shadow root, throws a "HierarchyRequestError" DOMException.
4660 adoptNode<T extends Node>(source: T): T;
4662 captureEvents(): void;
4663 caretPositionFromPoint(x: number, y: number): CaretPosition | null;
4665 caretRangeFromPoint(x: number, y: number): Range;
4669 * Closes an output stream and forces the sent data to display.
4673 * Creates an attribute object with a specified name.
4674 * @param name String that sets the attribute object's name.
4676 createAttribute(localName: string): Attr;
4677 createAttributeNS(namespace: string | null, qualifiedName: string): Attr;
4679 * Returns a CDATASection node whose data is data.
4681 createCDATASection(data: string): CDATASection;
4683 * Creates a comment object with the specified data.
4684 * @param data Sets the comment object's data.
4686 createComment(data: string): Comment;
4688 * Creates a new document.
4690 createDocumentFragment(): DocumentFragment;
4692 * Creates an instance of the element for the specified tag.
4693 * @param tagName The name of an element.
4695 createElement<K extends keyof HTMLElementTagNameMap>(tagName: K, options?: ElementCreationOptions): HTMLElementTagNameMap[K];
4697 createElement<K extends keyof HTMLElementDeprecatedTagNameMap>(tagName: K, options?: ElementCreationOptions): HTMLElementDeprecatedTagNameMap[K];
4698 createElement(tagName: string, options?: ElementCreationOptions): HTMLElement;
4700 * Returns an element with namespace namespace. Its namespace prefix will be everything before ":" (U+003E) in qualifiedName or null. Its local name will be everything after ":" (U+003E) in qualifiedName or qualifiedName.
4702 * If localName does not match the Name production an "InvalidCharacterError" DOMException will be thrown.
4704 * If one of the following conditions is true a "NamespaceError" DOMException will be thrown:
4706 * localName does not match the QName production.
4707 * Namespace prefix is not null and namespace is the empty string.
4708 * Namespace prefix is "xml" and namespace is not the XML namespace.
4709 * qualifiedName or namespace prefix is "xmlns" and namespace is not the XMLNS namespace.
4710 * namespace is the XMLNS namespace and neither qualifiedName nor namespace prefix is "xmlns".
4712 * When supplied, options's is can be used to create a customized built-in element.
4714 createElementNS(namespaceURI: "http://www.w3.org/1999/xhtml", qualifiedName: string): HTMLElement;
4715 createElementNS<K extends keyof SVGElementTagNameMap>(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: K): SVGElementTagNameMap[K];
4716 createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: string): SVGElement;
4717 createElementNS(namespaceURI: string | null, qualifiedName: string, options?: ElementCreationOptions): Element;
4718 createElementNS(namespace: string | null, qualifiedName: string, options?: string | ElementCreationOptions): Element;
4719 createEvent(eventInterface: "AnimationEvent"): AnimationEvent;
4720 createEvent(eventInterface: "AnimationPlaybackEvent"): AnimationPlaybackEvent;
4721 createEvent(eventInterface: "AudioProcessingEvent"): AudioProcessingEvent;
4722 createEvent(eventInterface: "BeforeUnloadEvent"): BeforeUnloadEvent;
4723 createEvent(eventInterface: "ClipboardEvent"): ClipboardEvent;
4724 createEvent(eventInterface: "CloseEvent"): CloseEvent;
4725 createEvent(eventInterface: "CompositionEvent"): CompositionEvent;
4726 createEvent(eventInterface: "CustomEvent"): CustomEvent;
4727 createEvent(eventInterface: "DeviceLightEvent"): DeviceLightEvent;
4728 createEvent(eventInterface: "DeviceMotionEvent"): DeviceMotionEvent;
4729 createEvent(eventInterface: "DeviceOrientationEvent"): DeviceOrientationEvent;
4730 createEvent(eventInterface: "DragEvent"): DragEvent;
4731 createEvent(eventInterface: "ErrorEvent"): ErrorEvent;
4732 createEvent(eventInterface: "Event"): Event;
4733 createEvent(eventInterface: "Events"): Event;
4734 createEvent(eventInterface: "FocusEvent"): FocusEvent;
4735 createEvent(eventInterface: "FocusNavigationEvent"): FocusNavigationEvent;
4736 createEvent(eventInterface: "GamepadEvent"): GamepadEvent;
4737 createEvent(eventInterface: "HashChangeEvent"): HashChangeEvent;
4738 createEvent(eventInterface: "IDBVersionChangeEvent"): IDBVersionChangeEvent;
4739 createEvent(eventInterface: "InputEvent"): InputEvent;
4740 createEvent(eventInterface: "KeyboardEvent"): KeyboardEvent;
4741 createEvent(eventInterface: "ListeningStateChangedEvent"): ListeningStateChangedEvent;
4742 createEvent(eventInterface: "MSGestureEvent"): MSGestureEvent;
4743 createEvent(eventInterface: "MSMediaKeyMessageEvent"): MSMediaKeyMessageEvent;
4744 createEvent(eventInterface: "MSMediaKeyNeededEvent"): MSMediaKeyNeededEvent;
4745 createEvent(eventInterface: "MSPointerEvent"): MSPointerEvent;
4746 createEvent(eventInterface: "MediaEncryptedEvent"): MediaEncryptedEvent;
4747 createEvent(eventInterface: "MediaKeyMessageEvent"): MediaKeyMessageEvent;
4748 createEvent(eventInterface: "MediaQueryListEvent"): MediaQueryListEvent;
4749 createEvent(eventInterface: "MediaStreamErrorEvent"): MediaStreamErrorEvent;
4750 createEvent(eventInterface: "MediaStreamEvent"): MediaStreamEvent;
4751 createEvent(eventInterface: "MediaStreamTrackEvent"): MediaStreamTrackEvent;
4752 createEvent(eventInterface: "MessageEvent"): MessageEvent;
4753 createEvent(eventInterface: "MouseEvent"): MouseEvent;
4754 createEvent(eventInterface: "MouseEvents"): MouseEvent;
4755 createEvent(eventInterface: "MutationEvent"): MutationEvent;
4756 createEvent(eventInterface: "MutationEvents"): MutationEvent;
4757 createEvent(eventInterface: "OfflineAudioCompletionEvent"): OfflineAudioCompletionEvent;
4758 createEvent(eventInterface: "OverflowEvent"): OverflowEvent;
4759 createEvent(eventInterface: "PageTransitionEvent"): PageTransitionEvent;
4760 createEvent(eventInterface: "PaymentRequestUpdateEvent"): PaymentRequestUpdateEvent;
4761 createEvent(eventInterface: "PermissionRequestedEvent"): PermissionRequestedEvent;
4762 createEvent(eventInterface: "PointerEvent"): PointerEvent;
4763 createEvent(eventInterface: "PopStateEvent"): PopStateEvent;
4764 createEvent(eventInterface: "ProgressEvent"): ProgressEvent;
4765 createEvent(eventInterface: "PromiseRejectionEvent"): PromiseRejectionEvent;
4766 createEvent(eventInterface: "RTCDTMFToneChangeEvent"): RTCDTMFToneChangeEvent;
4767 createEvent(eventInterface: "RTCDataChannelEvent"): RTCDataChannelEvent;
4768 createEvent(eventInterface: "RTCDtlsTransportStateChangedEvent"): RTCDtlsTransportStateChangedEvent;
4769 createEvent(eventInterface: "RTCErrorEvent"): RTCErrorEvent;
4770 createEvent(eventInterface: "RTCIceCandidatePairChangedEvent"): RTCIceCandidatePairChangedEvent;
4771 createEvent(eventInterface: "RTCIceGathererEvent"): RTCIceGathererEvent;
4772 createEvent(eventInterface: "RTCIceTransportStateChangedEvent"): RTCIceTransportStateChangedEvent;
4773 createEvent(eventInterface: "RTCPeerConnectionIceErrorEvent"): RTCPeerConnectionIceErrorEvent;
4774 createEvent(eventInterface: "RTCPeerConnectionIceEvent"): RTCPeerConnectionIceEvent;
4775 createEvent(eventInterface: "RTCSsrcConflictEvent"): RTCSsrcConflictEvent;
4776 createEvent(eventInterface: "RTCStatsEvent"): RTCStatsEvent;
4777 createEvent(eventInterface: "RTCTrackEvent"): RTCTrackEvent;
4778 createEvent(eventInterface: "SVGZoomEvent"): SVGZoomEvent;
4779 createEvent(eventInterface: "SVGZoomEvents"): SVGZoomEvent;
4780 createEvent(eventInterface: "SecurityPolicyViolationEvent"): SecurityPolicyViolationEvent;
4781 createEvent(eventInterface: "ServiceWorkerMessageEvent"): ServiceWorkerMessageEvent;
4782 createEvent(eventInterface: "SpeechRecognitionErrorEvent"): SpeechRecognitionErrorEvent;
4783 createEvent(eventInterface: "SpeechRecognitionEvent"): SpeechRecognitionEvent;
4784 createEvent(eventInterface: "SpeechSynthesisErrorEvent"): SpeechSynthesisErrorEvent;
4785 createEvent(eventInterface: "SpeechSynthesisEvent"): SpeechSynthesisEvent;
4786 createEvent(eventInterface: "StorageEvent"): StorageEvent;
4787 createEvent(eventInterface: "TextEvent"): TextEvent;
4788 createEvent(eventInterface: "TouchEvent"): TouchEvent;
4789 createEvent(eventInterface: "TrackEvent"): TrackEvent;
4790 createEvent(eventInterface: "TransitionEvent"): TransitionEvent;
4791 createEvent(eventInterface: "UIEvent"): UIEvent;
4792 createEvent(eventInterface: "UIEvents"): UIEvent;
4793 createEvent(eventInterface: "VRDisplayEvent"): VRDisplayEvent;
4794 createEvent(eventInterface: "VRDisplayEvent "): VRDisplayEvent ;
4795 createEvent(eventInterface: "WebGLContextEvent"): WebGLContextEvent;
4796 createEvent(eventInterface: "WheelEvent"): WheelEvent;
4797 createEvent(eventInterface: string): Event;
4799 * Creates a NodeIterator object that you can use to traverse filtered lists of nodes or elements in a document.
4800 * @param root The root element or node to start traversing on.
4801 * @param whatToShow The type of nodes or elements to appear in the node list
4802 * @param filter A custom NodeFilter function to use. For more information, see filter. Use null for no filter.
4803 * @param entityReferenceExpansion A flag that specifies whether entity reference nodes are expanded.
4805 createNodeIterator(root: Node, whatToShow?: number, filter?: NodeFilter | null): NodeIterator;
4807 * Returns a ProcessingInstruction node whose target is target and data is data. If target does not match the Name production an "InvalidCharacterError" DOMException will be thrown. If data contains "?>" an "InvalidCharacterError" DOMException will be thrown.
4809 createProcessingInstruction(target: string, data: string): ProcessingInstruction;
4811 * Returns an empty range object that has both of its boundary points positioned at the beginning of the document.
4813 createRange(): Range;
4815 * Creates a text string from the specified value.
4816 * @param data String that specifies the nodeValue property of the text node.
4818 createTextNode(data: string): Text;
4820 * Creates a TreeWalker object that you can use to traverse filtered lists of nodes or elements in a document.
4821 * @param root The root element or node to start traversing on.
4822 * @param whatToShow The type of nodes or elements to appear in the node list. For more information, see whatToShow.
4823 * @param filter A custom NodeFilter function to use.
4824 * @param entityReferenceExpansion A flag that specifies whether entity reference nodes are expanded.
4826 createTreeWalker(root: Node, whatToShow?: number, filter?: NodeFilter | null): TreeWalker;
4828 createTreeWalker(root: Node, whatToShow: number, filter: NodeFilter | null, entityReferenceExpansion?: boolean): TreeWalker;
4830 * Returns the element for the specified x coordinate and the specified y coordinate.
4831 * @param x The x-offset
4832 * @param y The y-offset
4834 elementFromPoint(x: number, y: number): Element | null;
4835 elementsFromPoint(x: number, y: number): Element[];
4837 * Executes a command on the current document, current selection, or the given range.
4838 * @param commandId String that specifies the command to execute. This command can be any of the command identifiers that can be executed in script.
4839 * @param showUI Display the user interface, defaults to false.
4840 * @param value Value to assign.
4842 execCommand(commandId: string, showUI?: boolean, value?: string): boolean;
4844 * Stops document's fullscreen element from being displayed fullscreen and resolves promise when done.
4846 exitFullscreen(): Promise<void>;
4847 exitPointerLock(): void;
4848 getAnimations(): Animation[];
4850 * Returns a reference to the first object with the specified value of the ID attribute.
4851 * @param elementId String that specifies the ID value.
4853 getElementById(elementId: string): HTMLElement | null;
4855 * Returns a HTMLCollection of the elements in the object on which the method was invoked (a document or an element) that have all the classes given by classNames. The classNames argument is interpreted as a space-separated list of classes.
4857 getElementsByClassName(classNames: string): HTMLCollectionOf<Element>;
4859 * Gets a collection of objects based on the value of the NAME or ID attribute.
4860 * @param elementName Gets a collection of objects based on the value of the NAME or ID attribute.
4862 getElementsByName(elementName: string): NodeListOf<HTMLElement>;
4864 * Retrieves a collection of objects based on the specified element name.
4865 * @param name Specifies the name of an element.
4867 getElementsByTagName<K extends keyof HTMLElementTagNameMap>(qualifiedName: K): HTMLCollectionOf<HTMLElementTagNameMap[K]>;
4868 getElementsByTagName<K extends keyof SVGElementTagNameMap>(qualifiedName: K): HTMLCollectionOf<SVGElementTagNameMap[K]>;
4869 getElementsByTagName(qualifiedName: string): HTMLCollectionOf<Element>;
4871 * If namespace and localName are "*" returns a HTMLCollection of all descendant elements.
4873 * If only namespace is "*" returns a HTMLCollection of all descendant elements whose local name is localName.
4875 * If only localName is "*" returns a HTMLCollection of all descendant elements whose namespace is namespace.
4877 * Otherwise, returns a HTMLCollection of all descendant elements whose namespace is namespace and local name is localName.
4879 getElementsByTagNameNS(namespaceURI: "http://www.w3.org/1999/xhtml", localName: string): HTMLCollectionOf<HTMLElement>;
4880 getElementsByTagNameNS(namespaceURI: "http://www.w3.org/2000/svg", localName: string): HTMLCollectionOf<SVGElement>;
4881 getElementsByTagNameNS(namespaceURI: string, localName: string): HTMLCollectionOf<Element>;
4883 * Returns an object representing the current selection of the document that is loaded into the object displaying a webpage.
4885 getSelection(): Selection | null;
4887 * Gets a value indicating whether the object currently has focus.
4889 hasFocus(): boolean;
4891 * Returns a copy of node. If deep is true, the copy also includes the node's descendants.
4893 * If node is a document or a shadow root, throws a "NotSupportedError" DOMException.
4895 importNode<T extends Node>(importedNode: T, deep: boolean): T;
4897 * Opens a new window and loads a document specified by a given URL. Also, opens a new window that uses the url parameter and the name parameter to collect the output of the write method and the writeln method.
4898 * @param url Specifies a MIME type for the document.
4899 * @param name Specifies the name of the window. This name is used as the value for the TARGET attribute on a form or an anchor element.
4900 * @param features Contains a list of items separated by commas. Each item consists of an option and a value, separated by an equals sign (for example, "fullscreen=yes, toolbar=yes"). The following values are supported.
4901 * @param replace Specifies whether the existing entry for the document is replaced in the history list.
4903 open(url?: string, name?: string, features?: string, replace?: boolean): Document;
4905 * Returns a Boolean value that indicates whether a specified command can be successfully executed using execCommand, given the current state of the document.
4906 * @param commandId Specifies a command identifier.
4908 queryCommandEnabled(commandId: string): boolean;
4910 * Returns a Boolean value that indicates whether the specified command is in the indeterminate state.
4911 * @param commandId String that specifies a command identifier.
4913 queryCommandIndeterm(commandId: string): boolean;
4915 * Returns a Boolean value that indicates the current state of the command.
4916 * @param commandId String that specifies a command identifier.
4918 queryCommandState(commandId: string): boolean;
4920 * Returns a Boolean value that indicates whether the current command is supported on the current range.
4921 * @param commandId Specifies a command identifier.
4923 queryCommandSupported(commandId: string): boolean;
4925 * Returns the current value of the document, range, or current selection for the given command.
4926 * @param commandId String that specifies a command identifier.
4928 queryCommandValue(commandId: string): string;
4930 releaseEvents(): void;
4932 * Writes one or more HTML expressions to a document in the specified window.
4933 * @param content Specifies the text and HTML tags to write.
4935 write(...text: string[]): void;
4937 * Writes one or more HTML expressions, followed by a carriage return, to a document in the specified window.
4938 * @param content The text and HTML tags to write.
4940 writeln(...text: string[]): void;
4941 addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
4942 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
4943 removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
4944 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
4947 declare var Document: {
4948 prototype: Document;
4952 interface DocumentAndElementEventHandlersEventMap {
4953 "copy": ClipboardEvent;
4954 "cut": ClipboardEvent;
4955 "paste": ClipboardEvent;
4958 interface DocumentAndElementEventHandlers {
4959 oncopy: ((this: DocumentAndElementEventHandlers, ev: ClipboardEvent) => any) | null;
4960 oncut: ((this: DocumentAndElementEventHandlers, ev: ClipboardEvent) => any) | null;
4961 onpaste: ((this: DocumentAndElementEventHandlers, ev: ClipboardEvent) => any) | null;
4962 addEventListener<K extends keyof DocumentAndElementEventHandlersEventMap>(type: K, listener: (this: DocumentAndElementEventHandlers, ev: DocumentAndElementEventHandlersEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
4963 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
4964 removeEventListener<K extends keyof DocumentAndElementEventHandlersEventMap>(type: K, listener: (this: DocumentAndElementEventHandlers, ev: DocumentAndElementEventHandlersEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
4965 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
4968 interface DocumentEvent {
4969 createEvent(eventInterface: "AnimationEvent"): AnimationEvent;
4970 createEvent(eventInterface: "AnimationPlaybackEvent"): AnimationPlaybackEvent;
4971 createEvent(eventInterface: "AudioProcessingEvent"): AudioProcessingEvent;
4972 createEvent(eventInterface: "BeforeUnloadEvent"): BeforeUnloadEvent;
4973 createEvent(eventInterface: "ClipboardEvent"): ClipboardEvent;
4974 createEvent(eventInterface: "CloseEvent"): CloseEvent;
4975 createEvent(eventInterface: "CompositionEvent"): CompositionEvent;
4976 createEvent(eventInterface: "CustomEvent"): CustomEvent;
4977 createEvent(eventInterface: "DeviceLightEvent"): DeviceLightEvent;
4978 createEvent(eventInterface: "DeviceMotionEvent"): DeviceMotionEvent;
4979 createEvent(eventInterface: "DeviceOrientationEvent"): DeviceOrientationEvent;
4980 createEvent(eventInterface: "DragEvent"): DragEvent;
4981 createEvent(eventInterface: "ErrorEvent"): ErrorEvent;
4982 createEvent(eventInterface: "Event"): Event;
4983 createEvent(eventInterface: "Events"): Event;
4984 createEvent(eventInterface: "FocusEvent"): FocusEvent;
4985 createEvent(eventInterface: "FocusNavigationEvent"): FocusNavigationEvent;
4986 createEvent(eventInterface: "GamepadEvent"): GamepadEvent;
4987 createEvent(eventInterface: "HashChangeEvent"): HashChangeEvent;
4988 createEvent(eventInterface: "IDBVersionChangeEvent"): IDBVersionChangeEvent;
4989 createEvent(eventInterface: "InputEvent"): InputEvent;
4990 createEvent(eventInterface: "KeyboardEvent"): KeyboardEvent;
4991 createEvent(eventInterface: "ListeningStateChangedEvent"): ListeningStateChangedEvent;
4992 createEvent(eventInterface: "MSGestureEvent"): MSGestureEvent;
4993 createEvent(eventInterface: "MSMediaKeyMessageEvent"): MSMediaKeyMessageEvent;
4994 createEvent(eventInterface: "MSMediaKeyNeededEvent"): MSMediaKeyNeededEvent;
4995 createEvent(eventInterface: "MSPointerEvent"): MSPointerEvent;
4996 createEvent(eventInterface: "MediaEncryptedEvent"): MediaEncryptedEvent;
4997 createEvent(eventInterface: "MediaKeyMessageEvent"): MediaKeyMessageEvent;
4998 createEvent(eventInterface: "MediaQueryListEvent"): MediaQueryListEvent;
4999 createEvent(eventInterface: "MediaStreamErrorEvent"): MediaStreamErrorEvent;
5000 createEvent(eventInterface: "MediaStreamEvent"): MediaStreamEvent;
5001 createEvent(eventInterface: "MediaStreamTrackEvent"): MediaStreamTrackEvent;
5002 createEvent(eventInterface: "MessageEvent"): MessageEvent;
5003 createEvent(eventInterface: "MouseEvent"): MouseEvent;
5004 createEvent(eventInterface: "MouseEvents"): MouseEvent;
5005 createEvent(eventInterface: "MutationEvent"): MutationEvent;
5006 createEvent(eventInterface: "MutationEvents"): MutationEvent;
5007 createEvent(eventInterface: "OfflineAudioCompletionEvent"): OfflineAudioCompletionEvent;
5008 createEvent(eventInterface: "OverflowEvent"): OverflowEvent;
5009 createEvent(eventInterface: "PageTransitionEvent"): PageTransitionEvent;
5010 createEvent(eventInterface: "PaymentRequestUpdateEvent"): PaymentRequestUpdateEvent;
5011 createEvent(eventInterface: "PermissionRequestedEvent"): PermissionRequestedEvent;
5012 createEvent(eventInterface: "PointerEvent"): PointerEvent;
5013 createEvent(eventInterface: "PopStateEvent"): PopStateEvent;
5014 createEvent(eventInterface: "ProgressEvent"): ProgressEvent;
5015 createEvent(eventInterface: "PromiseRejectionEvent"): PromiseRejectionEvent;
5016 createEvent(eventInterface: "RTCDTMFToneChangeEvent"): RTCDTMFToneChangeEvent;
5017 createEvent(eventInterface: "RTCDataChannelEvent"): RTCDataChannelEvent;
5018 createEvent(eventInterface: "RTCDtlsTransportStateChangedEvent"): RTCDtlsTransportStateChangedEvent;
5019 createEvent(eventInterface: "RTCErrorEvent"): RTCErrorEvent;
5020 createEvent(eventInterface: "RTCIceCandidatePairChangedEvent"): RTCIceCandidatePairChangedEvent;
5021 createEvent(eventInterface: "RTCIceGathererEvent"): RTCIceGathererEvent;
5022 createEvent(eventInterface: "RTCIceTransportStateChangedEvent"): RTCIceTransportStateChangedEvent;
5023 createEvent(eventInterface: "RTCPeerConnectionIceErrorEvent"): RTCPeerConnectionIceErrorEvent;
5024 createEvent(eventInterface: "RTCPeerConnectionIceEvent"): RTCPeerConnectionIceEvent;
5025 createEvent(eventInterface: "RTCSsrcConflictEvent"): RTCSsrcConflictEvent;
5026 createEvent(eventInterface: "RTCStatsEvent"): RTCStatsEvent;
5027 createEvent(eventInterface: "RTCTrackEvent"): RTCTrackEvent;
5028 createEvent(eventInterface: "SVGZoomEvent"): SVGZoomEvent;
5029 createEvent(eventInterface: "SVGZoomEvents"): SVGZoomEvent;
5030 createEvent(eventInterface: "SecurityPolicyViolationEvent"): SecurityPolicyViolationEvent;
5031 createEvent(eventInterface: "ServiceWorkerMessageEvent"): ServiceWorkerMessageEvent;
5032 createEvent(eventInterface: "SpeechRecognitionErrorEvent"): SpeechRecognitionErrorEvent;
5033 createEvent(eventInterface: "SpeechRecognitionEvent"): SpeechRecognitionEvent;
5034 createEvent(eventInterface: "SpeechSynthesisErrorEvent"): SpeechSynthesisErrorEvent;
5035 createEvent(eventInterface: "SpeechSynthesisEvent"): SpeechSynthesisEvent;
5036 createEvent(eventInterface: "StorageEvent"): StorageEvent;
5037 createEvent(eventInterface: "TextEvent"): TextEvent;
5038 createEvent(eventInterface: "TouchEvent"): TouchEvent;
5039 createEvent(eventInterface: "TrackEvent"): TrackEvent;
5040 createEvent(eventInterface: "TransitionEvent"): TransitionEvent;
5041 createEvent(eventInterface: "UIEvent"): UIEvent;
5042 createEvent(eventInterface: "UIEvents"): UIEvent;
5043 createEvent(eventInterface: "VRDisplayEvent"): VRDisplayEvent;
5044 createEvent(eventInterface: "VRDisplayEvent "): VRDisplayEvent ;
5045 createEvent(eventInterface: "WebGLContextEvent"): WebGLContextEvent;
5046 createEvent(eventInterface: "WheelEvent"): WheelEvent;
5047 createEvent(eventInterface: string): Event;
5050 /** A minimal document object that has no parent. It is used as a lightweight version of Document that stores a segment of a document structure comprised of nodes just like a standard document. The key difference is that because the document fragment isn't part of the active document tree structure, changes made to the fragment don't affect the document, cause reflow, or incur any performance impact that can occur when changes are made. */
5051 interface DocumentFragment extends Node, NonElementParentNode, ParentNode {
5052 readonly ownerDocument: Document;
5053 getElementById(elementId: string): HTMLElement | null;
5056 declare var DocumentFragment: {
5057 prototype: DocumentFragment;
5058 new(): DocumentFragment;
5061 interface DocumentOrShadowRoot {
5062 readonly activeElement: Element | null;
5064 * Returns document's fullscreen element.
5066 readonly fullscreenElement: Element | null;
5067 readonly pointerLockElement: Element | null;
5069 * Retrieves a collection of styleSheet objects representing the style sheets that correspond to each instance of a link or style object in the document.
5071 readonly styleSheets: StyleSheetList;
5072 caretPositionFromPoint(x: number, y: number): CaretPosition | null;
5074 caretRangeFromPoint(x: number, y: number): Range;
5075 elementFromPoint(x: number, y: number): Element | null;
5076 elementsFromPoint(x: number, y: number): Element[];
5077 getSelection(): Selection | null;
5080 interface DocumentTimeline extends AnimationTimeline {
5083 declare var DocumentTimeline: {
5084 prototype: DocumentTimeline;
5085 new(options?: DocumentTimelineOptions): DocumentTimeline;
5088 /** A Node containing a doctype. */
5089 interface DocumentType extends Node, ChildNode {
5090 readonly name: string;
5091 readonly ownerDocument: Document;
5092 readonly publicId: string;
5093 readonly systemId: string;
5096 declare var DocumentType: {
5097 prototype: DocumentType;
5098 new(): DocumentType;
5101 /** A DOM event that represents a drag and drop interaction. The user initiates a drag by placing a pointer device (such as a mouse) on the touch surface and then dragging the pointer to a new location (such as another DOM element). Applications are free to interpret a drag and drop interaction in an application-specific way. */
5102 interface DragEvent extends MouseEvent {
5104 * Returns the DataTransfer object for the event.
5106 readonly dataTransfer: DataTransfer | null;
5109 declare var DragEvent: {
5110 prototype: DragEvent;
5111 new(type: string, eventInitDict?: DragEventInit): DragEvent;
5114 /** Inherits properties from its parent, AudioNode. */
5115 interface DynamicsCompressorNode extends AudioNode {
5116 readonly attack: AudioParam;
5117 readonly knee: AudioParam;
5118 readonly ratio: AudioParam;
5119 readonly reduction: number;
5120 readonly release: AudioParam;
5121 readonly threshold: AudioParam;
5124 declare var DynamicsCompressorNode: {
5125 prototype: DynamicsCompressorNode;
5126 new(context: BaseAudioContext, options?: DynamicsCompressorOptions): DynamicsCompressorNode;
5129 interface EXT_blend_minmax {
5130 readonly MAX_EXT: GLenum;
5131 readonly MIN_EXT: GLenum;
5134 /** The EXT_frag_depth extension is part of the WebGL API and enables to set a depth value of a fragment from within the fragment shader. */
5135 interface EXT_frag_depth {
5138 interface EXT_sRGB {
5139 readonly FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT: GLenum;
5140 readonly SRGB8_ALPHA8_EXT: GLenum;
5141 readonly SRGB_ALPHA_EXT: GLenum;
5142 readonly SRGB_EXT: GLenum;
5145 interface EXT_shader_texture_lod {
5148 /** The EXT_texture_filter_anisotropic extension is part of the WebGL API and exposes two constants for anisotropic filtering (AF). */
5149 interface EXT_texture_filter_anisotropic {
5150 readonly MAX_TEXTURE_MAX_ANISOTROPY_EXT: GLenum;
5151 readonly TEXTURE_MAX_ANISOTROPY_EXT: GLenum;
5154 interface ElementEventMap {
5155 "fullscreenchange": Event;
5156 "fullscreenerror": Event;
5159 /** Element is the most general base class from which all objects in a Document inherit. It only has methods and properties common to all kinds of elements. More specific classes inherit from Element. */
5160 interface Element extends Node, Animatable, ChildNode, InnerHTML, NonDocumentTypeChildNode, ParentNode, Slottable {
5161 readonly attributes: NamedNodeMap;
5163 * Allows for manipulation of element's class content attribute as a set of whitespace-separated tokens through a DOMTokenList object.
5165 readonly classList: DOMTokenList;
5167 * Returns the value of element's class content attribute. Can be set to change it.
5170 readonly clientHeight: number;
5171 readonly clientLeft: number;
5172 readonly clientTop: number;
5173 readonly clientWidth: number;
5175 * Returns the value of element's id content attribute. Can be set to change it.
5179 * Returns the local name.
5181 readonly localName: string;
5183 * Returns the namespace.
5185 readonly namespaceURI: string | null;
5186 onfullscreenchange: ((this: Element, ev: Event) => any) | null;
5187 onfullscreenerror: ((this: Element, ev: Event) => any) | null;
5189 readonly ownerDocument: Document;
5191 * Returns the namespace prefix.
5193 readonly prefix: string | null;
5194 readonly scrollHeight: number;
5197 readonly scrollWidth: number;
5199 * Returns element's shadow root, if any, and if shadow root's mode is "open", and null otherwise.
5201 readonly shadowRoot: ShadowRoot | null;
5203 * Returns the value of element's slot content attribute. Can be set to change it.
5207 * Returns the HTML-uppercased qualified name.
5209 readonly tagName: string;
5211 * Creates a shadow root for element and returns it.
5213 attachShadow(init: ShadowRootInit): ShadowRoot;
5215 * Returns the first (starting at element) inclusive ancestor that matches selectors, and null otherwise.
5217 closest<K extends keyof HTMLElementTagNameMap>(selector: K): HTMLElementTagNameMap[K] | null;
5218 closest<K extends keyof SVGElementTagNameMap>(selector: K): SVGElementTagNameMap[K] | null;
5219 closest<E extends Element = Element>(selector: string): E | null;
5221 * Returns element's first attribute whose qualified name is qualifiedName, and null if there is no such attribute otherwise.
5223 getAttribute(qualifiedName: string): string | null;
5225 * Returns element's attribute whose namespace is namespace and local name is localName, and null if there is no such attribute otherwise.
5227 getAttributeNS(namespace: string | null, localName: string): string | null;
5229 * Returns the qualified names of all element's attributes. Can contain duplicates.
5231 getAttributeNames(): string[];
5232 getAttributeNode(qualifiedName: string): Attr | null;
5233 getAttributeNodeNS(namespace: string | null, localName: string): Attr | null;
5234 getBoundingClientRect(): DOMRect;
5235 getClientRects(): DOMRectList;
5237 * Returns a HTMLCollection of the elements in the object on which the method was invoked (a document or an element) that have all the classes given by classNames. The classNames argument is interpreted as a space-separated list of classes.
5239 getElementsByClassName(classNames: string): HTMLCollectionOf<Element>;
5240 getElementsByTagName<K extends keyof HTMLElementTagNameMap>(qualifiedName: K): HTMLCollectionOf<HTMLElementTagNameMap[K]>;
5241 getElementsByTagName<K extends keyof SVGElementTagNameMap>(qualifiedName: K): HTMLCollectionOf<SVGElementTagNameMap[K]>;
5242 getElementsByTagName(qualifiedName: string): HTMLCollectionOf<Element>;
5243 getElementsByTagNameNS(namespaceURI: "http://www.w3.org/1999/xhtml", localName: string): HTMLCollectionOf<HTMLElement>;
5244 getElementsByTagNameNS(namespaceURI: "http://www.w3.org/2000/svg", localName: string): HTMLCollectionOf<SVGElement>;
5245 getElementsByTagNameNS(namespaceURI: string, localName: string): HTMLCollectionOf<Element>;
5247 * Returns true if element has an attribute whose qualified name is qualifiedName, and false otherwise.
5249 hasAttribute(qualifiedName: string): boolean;
5251 * Returns true if element has an attribute whose namespace is namespace and local name is localName.
5253 hasAttributeNS(namespace: string | null, localName: string): boolean;
5255 * Returns true if element has attributes, and false otherwise.
5257 hasAttributes(): boolean;
5258 hasPointerCapture(pointerId: number): boolean;
5259 insertAdjacentElement(position: InsertPosition, insertedElement: Element): Element | null;
5260 insertAdjacentHTML(where: InsertPosition, html: string): void;
5261 insertAdjacentText(where: InsertPosition, text: string): void;
5263 * Returns true if matching selectors against element's root yields element, and false otherwise.
5265 matches(selectors: string): boolean;
5266 msGetRegionContent(): any;
5267 releasePointerCapture(pointerId: number): void;
5269 * Removes element's first attribute whose qualified name is qualifiedName.
5271 removeAttribute(qualifiedName: string): void;
5273 * Removes element's attribute whose namespace is namespace and local name is localName.
5275 removeAttributeNS(namespace: string | null, localName: string): void;
5276 removeAttributeNode(attr: Attr): Attr;
5278 * Displays element fullscreen and resolves promise when done.
5280 * When supplied, options's navigationUI member indicates whether showing navigation UI while in fullscreen is preferred or not. If set to "show", navigation simplicity is preferred over screen space, and if set to "hide", more screen space is preferred. User agents are always free to honor user preference over the application's. The default value "auto" indicates no application preference.
5282 requestFullscreen(options?: FullscreenOptions): Promise<void>;
5283 requestPointerLock(): void;
5284 scroll(options?: ScrollToOptions): void;
5285 scroll(x: number, y: number): void;
5286 scrollBy(options?: ScrollToOptions): void;
5287 scrollBy(x: number, y: number): void;
5288 scrollIntoView(arg?: boolean | ScrollIntoViewOptions): void;
5289 scrollTo(options?: ScrollToOptions): void;
5290 scrollTo(x: number, y: number): void;
5292 * Sets the value of element's first attribute whose qualified name is qualifiedName to value.
5294 setAttribute(qualifiedName: string, value: string): void;
5296 * Sets the value of element's attribute whose namespace is namespace and local name is localName to value.
5298 setAttributeNS(namespace: string | null, qualifiedName: string, value: string): void;
5299 setAttributeNode(attr: Attr): Attr | null;
5300 setAttributeNodeNS(attr: Attr): Attr | null;
5301 setPointerCapture(pointerId: number): void;
5303 * If force is not given, "toggles" qualifiedName, removing it if it is present and adding it if it is not present. If force is true, adds qualifiedName. If force is false, removes qualifiedName.
5305 * Returns true if qualifiedName is now present, and false otherwise.
5307 toggleAttribute(qualifiedName: string, force?: boolean): boolean;
5308 webkitMatchesSelector(selectors: string): boolean;
5309 addEventListener<K extends keyof ElementEventMap>(type: K, listener: (this: Element, ev: ElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
5310 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
5311 removeEventListener<K extends keyof ElementEventMap>(type: K, listener: (this: Element, ev: ElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
5312 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
5315 declare var Element: {
5320 interface ElementCSSInlineStyle {
5321 readonly style: CSSStyleDeclaration;
5324 interface ElementContentEditable {
5325 contentEditable: string;
5326 enterKeyHint: string;
5328 readonly isContentEditable: boolean;
5331 /** Events providing information related to errors in scripts or in files. */
5332 interface ErrorEvent extends Event {
5333 readonly colno: number;
5334 readonly error: any;
5335 readonly filename: string;
5336 readonly lineno: number;
5337 readonly message: string;
5340 declare var ErrorEvent: {
5341 prototype: ErrorEvent;
5342 new(type: string, eventInitDict?: ErrorEventInit): ErrorEvent;
5345 /** An event which takes place in the DOM. */
5348 * Returns true or false depending on how event was initialized. True if event goes through its target's ancestors in reverse tree order, and false otherwise.
5350 readonly bubbles: boolean;
5351 cancelBubble: boolean;
5353 * Returns true or false depending on how event was initialized. Its return value does not always carry meaning, but true can indicate that part of the operation during which event was dispatched, can be canceled by invoking the preventDefault() method.
5355 readonly cancelable: boolean;
5357 * Returns true or false depending on how event was initialized. True if event invokes listeners past a ShadowRoot node that is the root of its target, and false otherwise.
5359 readonly composed: boolean;
5361 * Returns the object whose event listener's callback is currently being invoked.
5363 readonly currentTarget: EventTarget | null;
5365 * Returns true if preventDefault() was invoked successfully to indicate cancelation, and false otherwise.
5367 readonly defaultPrevented: boolean;
5369 * Returns the event's phase, which is one of NONE, CAPTURING_PHASE, AT_TARGET, and BUBBLING_PHASE.
5371 readonly eventPhase: number;
5373 * Returns true if event was dispatched by the user agent, and false otherwise.
5375 readonly isTrusted: boolean;
5376 returnValue: boolean;
5378 readonly srcElement: EventTarget | null;
5380 * Returns the object to which event is dispatched (its target).
5382 readonly target: EventTarget | null;
5384 * Returns the event's timestamp as the number of milliseconds measured relative to the time origin.
5386 readonly timeStamp: number;
5388 * Returns the type of event, e.g. "click", "hashchange", or "submit".
5390 readonly type: string;
5392 * Returns the invocation target objects of event's path (objects on which listeners will be invoked), except for any nodes in shadow trees of which the shadow root's mode is "closed" that are not reachable from event's currentTarget.
5394 composedPath(): EventTarget[];
5395 initEvent(type: string, bubbles?: boolean, cancelable?: boolean): void;
5397 * If invoked when the cancelable attribute value is true, and while executing a listener for the event with passive set to false, signals to the operation that caused event to be dispatched that it needs to be canceled.
5399 preventDefault(): void;
5401 * Invoking this method prevents event from reaching any registered event listeners after the current one finishes running and, when dispatched in a tree, also prevents event from reaching any other objects.
5403 stopImmediatePropagation(): void;
5405 * When dispatched in a tree, invoking this method prevents event from reaching any objects other than the current object.
5407 stopPropagation(): void;
5408 readonly AT_TARGET: number;
5409 readonly BUBBLING_PHASE: number;
5410 readonly CAPTURING_PHASE: number;
5411 readonly NONE: number;
5414 declare var Event: {
5416 new(type: string, eventInitDict?: EventInit): Event;
5417 readonly AT_TARGET: number;
5418 readonly BUBBLING_PHASE: number;
5419 readonly CAPTURING_PHASE: number;
5420 readonly NONE: number;
5423 interface EventListenerObject {
5424 handleEvent(evt: Event): void;
5427 interface EventSourceEventMap {
5429 "message": MessageEvent;
5433 interface EventSource extends EventTarget {
5434 onerror: ((this: EventSource, ev: Event) => any) | null;
5435 onmessage: ((this: EventSource, ev: MessageEvent) => any) | null;
5436 onopen: ((this: EventSource, ev: Event) => any) | null;
5438 * Returns the state of this EventSource object's connection. It can have the values described below.
5440 readonly readyState: number;
5442 * Returns the URL providing the event stream.
5444 readonly url: string;
5446 * Returns true if the credentials mode for connection requests to the URL providing the event stream is set to "include", and false otherwise.
5448 readonly withCredentials: boolean;
5450 * Aborts any instances of the fetch algorithm started for this EventSource object, and sets the readyState attribute to CLOSED.
5453 readonly CLOSED: number;
5454 readonly CONNECTING: number;
5455 readonly OPEN: number;
5456 addEventListener<K extends keyof EventSourceEventMap>(type: K, listener: (this: EventSource, ev: EventSourceEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
5457 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
5458 removeEventListener<K extends keyof EventSourceEventMap>(type: K, listener: (this: EventSource, ev: EventSourceEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
5459 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
5462 declare var EventSource: {
5463 prototype: EventSource;
5464 new(url: string, eventSourceInitDict?: EventSourceInit): EventSource;
5465 readonly CLOSED: number;
5466 readonly CONNECTING: number;
5467 readonly OPEN: number;
5470 /** EventTarget is a DOM interface implemented by objects that can receive events and may have listeners for them. */
5471 interface EventTarget {
5473 * Appends an event listener for events whose type attribute value is type. The callback argument sets the callback that will be invoked when the event is dispatched.
5475 * The options argument sets listener-specific options. For compatibility this can be a boolean, in which case the method behaves exactly as if the value was specified as options's capture.
5477 * When set to true, options's capture prevents callback from being invoked when the event's eventPhase attribute value is BUBBLING_PHASE. When false (or not present), callback will not be invoked when event's eventPhase attribute value is CAPTURING_PHASE. Either way, callback will be invoked if event's eventPhase attribute value is AT_TARGET.
5479 * When set to true, options's passive indicates that the callback will not cancel the event by invoking preventDefault(). This is used to enable performance optimizations described in § 2.8 Observing event listeners.
5481 * When set to true, options's once indicates that the callback will only be invoked once after which the event listener will be removed.
5483 * The event listener is appended to target's event listener list and is not appended if it has the same type, callback, and capture.
5485 addEventListener(type: string, listener: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions): void;
5487 * Dispatches a synthetic event event to target and returns true if either event's cancelable attribute value is false or its preventDefault() method was not invoked, and false otherwise.
5489 dispatchEvent(event: Event): boolean;
5491 * Removes the event listener in target's event listener list with the same type, callback, and options.
5493 removeEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
5496 declare var EventTarget: {
5497 prototype: EventTarget;
5501 interface ExtensionScriptApis {
5502 extensionIdToShortId(extensionId: string): number;
5503 fireExtensionApiTelemetry(functionName: string, isSucceeded: boolean, isSupported: boolean, errorString: string): void;
5504 genericFunction(routerAddress: any, parameters?: string, callbackId?: number): void;
5505 genericSynchronousFunction(functionId: number, parameters?: string): string;
5506 genericWebRuntimeCallout(to: any, from: any, payload: string): void;
5507 getExtensionId(): string;
5508 registerGenericFunctionCallbackHandler(callbackHandler: Function): void;
5509 registerGenericPersistentCallbackHandler(callbackHandler: Function): void;
5510 registerWebRuntimeCallbackHandler(handler: Function): any;
5513 declare var ExtensionScriptApis: {
5514 prototype: ExtensionScriptApis;
5515 new(): ExtensionScriptApis;
5518 interface External {
5520 AddSearchProvider(): void;
5522 IsSearchProviderInstalled(): void;
5525 declare var External: {
5526 prototype: External;
5530 /** Provides information about files and allows JavaScript in a web page to access their content. */
5531 interface File extends Blob {
5532 readonly lastModified: number;
5533 readonly name: string;
5538 new(fileBits: BlobPart[], fileName: string, options?: FilePropertyBag): File;
5541 /** An object of this type is returned by the files property of the HTML <input> element; this lets you access the list of files selected with the <input type="file"> element. It's also used for a list of files dropped into web content when using the drag and drop API; see the DataTransfer object for details on this usage. */
5542 interface FileList {
5543 readonly length: number;
5544 item(index: number): File | null;
5545 [index: number]: File;
5548 declare var FileList: {
5549 prototype: FileList;
5553 interface FileReaderEventMap {
5554 "abort": ProgressEvent<FileReader>;
5555 "error": ProgressEvent<FileReader>;
5556 "load": ProgressEvent<FileReader>;
5557 "loadend": ProgressEvent<FileReader>;
5558 "loadstart": ProgressEvent<FileReader>;
5559 "progress": ProgressEvent<FileReader>;
5562 /** Lets web applications asynchronously read the contents of files (or raw data buffers) stored on the user's computer, using File or Blob objects to specify the file or data to read. */
5563 interface FileReader extends EventTarget {
5564 readonly error: DOMException | null;
5565 onabort: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
5566 onerror: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
5567 onload: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
5568 onloadend: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
5569 onloadstart: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
5570 onprogress: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
5571 readonly readyState: number;
5572 readonly result: string | ArrayBuffer | null;
5574 readAsArrayBuffer(blob: Blob): void;
5575 readAsBinaryString(blob: Blob): void;
5576 readAsDataURL(blob: Blob): void;
5577 readAsText(blob: Blob, encoding?: string): void;
5578 readonly DONE: number;
5579 readonly EMPTY: number;
5580 readonly LOADING: number;
5581 addEventListener<K extends keyof FileReaderEventMap>(type: K, listener: (this: FileReader, ev: FileReaderEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
5582 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
5583 removeEventListener<K extends keyof FileReaderEventMap>(type: K, listener: (this: FileReader, ev: FileReaderEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
5584 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
5587 declare var FileReader: {
5588 prototype: FileReader;
5590 readonly DONE: number;
5591 readonly EMPTY: number;
5592 readonly LOADING: number;
5595 /** Focus-related events like focus, blur, focusin, or focusout. */
5596 interface FocusEvent extends UIEvent {
5597 readonly relatedTarget: EventTarget | null;
5600 declare var FocusEvent: {
5601 prototype: FocusEvent;
5602 new(type: string, eventInitDict?: FocusEventInit): FocusEvent;
5605 interface FocusNavigationEvent extends Event {
5606 readonly navigationReason: NavigationReason;
5607 readonly originHeight: number;
5608 readonly originLeft: number;
5609 readonly originTop: number;
5610 readonly originWidth: number;
5611 requestFocus(): void;
5614 declare var FocusNavigationEvent: {
5615 prototype: FocusNavigationEvent;
5616 new(type: string, eventInitDict?: FocusNavigationEventInit): FocusNavigationEvent;
5619 /** Provides a way to easily construct a set of key/value pairs representing form fields and their values, which can then be easily sent using the XMLHttpRequest.send() method. It uses the same format a form would use if the encoding type were set to "multipart/form-data". */
5620 interface FormData {
5621 append(name: string, value: string | Blob, fileName?: string): void;
5622 delete(name: string): void;
5623 get(name: string): FormDataEntryValue | null;
5624 getAll(name: string): FormDataEntryValue[];
5625 has(name: string): boolean;
5626 set(name: string, value: string | Blob, fileName?: string): void;
5627 forEach(callbackfn: (value: FormDataEntryValue, key: string, parent: FormData) => void, thisArg?: any): void;
5630 declare var FormData: {
5631 prototype: FormData;
5632 new(form?: HTMLFormElement): FormData;
5635 /** A change in volume. It is an AudioNode audio-processing module that causes a given gain to be applied to the input data before its propagation to the output. A GainNode always has exactly one input and one output, both with the same number of channels. */
5636 interface GainNode extends AudioNode {
5637 readonly gain: AudioParam;
5640 declare var GainNode: {
5641 prototype: GainNode;
5642 new(context: BaseAudioContext, options?: GainOptions): GainNode;
5645 /** This Gamepad API interface defines an individual gamepad or other controller, allowing access to information such as button presses, axis positions, and id. */
5647 readonly axes: ReadonlyArray<number>;
5648 readonly buttons: ReadonlyArray<GamepadButton>;
5649 readonly connected: boolean;
5650 readonly hand: GamepadHand;
5651 readonly hapticActuators: ReadonlyArray<GamepadHapticActuator>;
5652 readonly id: string;
5653 readonly index: number;
5654 readonly mapping: GamepadMappingType;
5655 readonly pose: GamepadPose | null;
5656 readonly timestamp: number;
5659 declare var Gamepad: {
5664 /** An individual button of a gamepad or other controller, allowing access to the current state of different types of buttons available on the control device. */
5665 interface GamepadButton {
5666 readonly pressed: boolean;
5667 readonly touched: boolean;
5668 readonly value: number;
5671 declare var GamepadButton: {
5672 prototype: GamepadButton;
5673 new(): GamepadButton;
5676 /** This Gamepad API interface contains references to gamepads connected to the system, which is what the gamepad events Window.gamepadconnected and Window.gamepaddisconnected are fired in response to. */
5677 interface GamepadEvent extends Event {
5678 readonly gamepad: Gamepad;
5681 declare var GamepadEvent: {
5682 prototype: GamepadEvent;
5683 new(type: string, eventInitDict: GamepadEventInit): GamepadEvent;
5686 /** This Gamepad API interface represents hardware in the controller designed to provide haptic feedback to the user (if available), most commonly vibration hardware. */
5687 interface GamepadHapticActuator {
5688 readonly type: GamepadHapticActuatorType;
5689 pulse(value: number, duration: number): Promise<boolean>;
5692 declare var GamepadHapticActuator: {
5693 prototype: GamepadHapticActuator;
5694 new(): GamepadHapticActuator;
5697 /** This Gamepad API interface represents the pose of a WebVR controller at a given timestamp (which includes orientation, position, velocity, and acceleration information.) */
5698 interface GamepadPose {
5699 readonly angularAcceleration: Float32Array | null;
5700 readonly angularVelocity: Float32Array | null;
5701 readonly hasOrientation: boolean;
5702 readonly hasPosition: boolean;
5703 readonly linearAcceleration: Float32Array | null;
5704 readonly linearVelocity: Float32Array | null;
5705 readonly orientation: Float32Array | null;
5706 readonly position: Float32Array | null;
5709 declare var GamepadPose: {
5710 prototype: GamepadPose;
5714 interface GenericTransformStream {
5715 readonly readable: ReadableStream;
5716 readonly writable: WritableStream;
5719 /** An object able to programmatically obtain the position of the device. It gives Web content access to the location of the device. This allows a Web site or app to offer customized results based on the user's location. */
5720 interface Geolocation {
5721 clearWatch(watchId: number): void;
5722 getCurrentPosition(successCallback: PositionCallback, errorCallback?: PositionErrorCallback, options?: PositionOptions): void;
5723 watchPosition(successCallback: PositionCallback, errorCallback?: PositionErrorCallback, options?: PositionOptions): number;
5726 declare var Geolocation: {
5727 prototype: Geolocation;
5731 interface GeolocationCoordinates {
5732 readonly accuracy: number;
5733 readonly altitude: number | null;
5734 readonly altitudeAccuracy: number | null;
5735 readonly heading: number | null;
5736 readonly latitude: number;
5737 readonly longitude: number;
5738 readonly speed: number | null;
5741 declare var GeolocationCoordinates: {
5742 prototype: GeolocationCoordinates;
5743 new(): GeolocationCoordinates;
5746 interface GeolocationPosition {
5747 readonly coords: GeolocationCoordinates;
5748 readonly timestamp: number;
5751 declare var GeolocationPosition: {
5752 prototype: GeolocationPosition;
5753 new(): GeolocationPosition;
5756 interface GeolocationPositionError {
5757 readonly code: number;
5758 readonly message: string;
5759 readonly PERMISSION_DENIED: number;
5760 readonly POSITION_UNAVAILABLE: number;
5761 readonly TIMEOUT: number;
5764 declare var GeolocationPositionError: {
5765 prototype: GeolocationPositionError;
5766 new(): GeolocationPositionError;
5767 readonly PERMISSION_DENIED: number;
5768 readonly POSITION_UNAVAILABLE: number;
5769 readonly TIMEOUT: number;
5772 interface GlobalEventHandlersEventMap {
5774 "animationcancel": AnimationEvent;
5775 "animationend": AnimationEvent;
5776 "animationiteration": AnimationEvent;
5777 "animationstart": AnimationEvent;
5778 "auxclick": MouseEvent;
5779 "beforeinput": InputEvent;
5783 "canplaythrough": Event;
5785 "click": MouseEvent;
5787 "compositionend": CompositionEvent;
5788 "compositionstart": CompositionEvent;
5789 "compositionupdate": CompositionEvent;
5790 "contextmenu": MouseEvent;
5792 "dblclick": MouseEvent;
5794 "dragend": DragEvent;
5795 "dragenter": DragEvent;
5797 "dragleave": DragEvent;
5798 "dragover": DragEvent;
5799 "dragstart": DragEvent;
5801 "durationchange": Event;
5804 "error": ErrorEvent;
5805 "focus": FocusEvent;
5806 "focusin": FocusEvent;
5807 "focusout": FocusEvent;
5808 "gotpointercapture": PointerEvent;
5811 "keydown": KeyboardEvent;
5812 "keypress": KeyboardEvent;
5813 "keyup": KeyboardEvent;
5815 "loadeddata": Event;
5816 "loadedmetadata": Event;
5818 "lostpointercapture": PointerEvent;
5819 "mousedown": MouseEvent;
5820 "mouseenter": MouseEvent;
5821 "mouseleave": MouseEvent;
5822 "mousemove": MouseEvent;
5823 "mouseout": MouseEvent;
5824 "mouseover": MouseEvent;
5825 "mouseup": MouseEvent;
5829 "pointercancel": PointerEvent;
5830 "pointerdown": PointerEvent;
5831 "pointerenter": PointerEvent;
5832 "pointerleave": PointerEvent;
5833 "pointermove": PointerEvent;
5834 "pointerout": PointerEvent;
5835 "pointerover": PointerEvent;
5836 "pointerup": PointerEvent;
5837 "progress": ProgressEvent;
5838 "ratechange": Event;
5842 "securitypolicyviolation": SecurityPolicyViolationEvent;
5846 "selectionchange": Event;
5847 "selectstart": Event;
5851 "timeupdate": Event;
5853 "touchcancel": TouchEvent;
5854 "touchend": TouchEvent;
5855 "touchmove": TouchEvent;
5856 "touchstart": TouchEvent;
5857 "transitioncancel": TransitionEvent;
5858 "transitionend": TransitionEvent;
5859 "transitionrun": TransitionEvent;
5860 "transitionstart": TransitionEvent;
5861 "volumechange": Event;
5863 "wheel": WheelEvent;
5866 interface GlobalEventHandlers {
5868 * Fires when the user aborts the download.
5869 * @param ev The event.
5871 onabort: ((this: GlobalEventHandlers, ev: UIEvent) => any) | null;
5872 onanimationcancel: ((this: GlobalEventHandlers, ev: AnimationEvent) => any) | null;
5873 onanimationend: ((this: GlobalEventHandlers, ev: AnimationEvent) => any) | null;
5874 onanimationiteration: ((this: GlobalEventHandlers, ev: AnimationEvent) => any) | null;
5875 onanimationstart: ((this: GlobalEventHandlers, ev: AnimationEvent) => any) | null;
5876 onauxclick: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
5878 * Fires when the object loses the input focus.
5879 * @param ev The focus event.
5881 onblur: ((this: GlobalEventHandlers, ev: FocusEvent) => any) | null;
5882 oncancel: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5884 * Occurs when playback is possible, but would require further buffering.
5885 * @param ev The event.
5887 oncanplay: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5888 oncanplaythrough: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5890 * Fires when the contents of the object or selection have changed.
5891 * @param ev The event.
5893 onchange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5895 * Fires when the user clicks the left mouse button on the object
5896 * @param ev The mouse event.
5898 onclick: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
5899 onclose: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5901 * Fires when the user clicks the right mouse button in the client area, opening the context menu.
5902 * @param ev The mouse event.
5904 oncontextmenu: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
5905 oncuechange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5907 * Fires when the user double-clicks the object.
5908 * @param ev The mouse event.
5910 ondblclick: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
5912 * Fires on the source object continuously during a drag operation.
5913 * @param ev The event.
5915 ondrag: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
5917 * Fires on the source object when the user releases the mouse at the close of a drag operation.
5918 * @param ev The event.
5920 ondragend: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
5922 * Fires on the target element when the user drags the object to a valid drop target.
5923 * @param ev The drag event.
5925 ondragenter: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
5926 ondragexit: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5928 * Fires on the target object when the user moves the mouse out of a valid drop target during a drag operation.
5929 * @param ev The drag event.
5931 ondragleave: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
5933 * Fires on the target element continuously while the user drags the object over a valid drop target.
5934 * @param ev The event.
5936 ondragover: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
5938 * Fires on the source object when the user starts to drag a text selection or selected object.
5939 * @param ev The event.
5941 ondragstart: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
5942 ondrop: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
5944 * Occurs when the duration attribute is updated.
5945 * @param ev The event.
5947 ondurationchange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5949 * Occurs when the media element is reset to its initial state.
5950 * @param ev The event.
5952 onemptied: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5954 * Occurs when the end of playback is reached.
5955 * @param ev The event
5957 onended: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5959 * Fires when an error occurs during object loading.
5960 * @param ev The event.
5962 onerror: OnErrorEventHandler;
5964 * Fires when the object receives focus.
5965 * @param ev The event.
5967 onfocus: ((this: GlobalEventHandlers, ev: FocusEvent) => any) | null;
5968 ongotpointercapture: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
5969 oninput: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5970 oninvalid: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5972 * Fires when the user presses a key.
5973 * @param ev The keyboard event
5975 onkeydown: ((this: GlobalEventHandlers, ev: KeyboardEvent) => any) | null;
5977 * Fires when the user presses an alphanumeric key.
5978 * @param ev The event.
5980 onkeypress: ((this: GlobalEventHandlers, ev: KeyboardEvent) => any) | null;
5982 * Fires when the user releases a key.
5983 * @param ev The keyboard event
5985 onkeyup: ((this: GlobalEventHandlers, ev: KeyboardEvent) => any) | null;
5987 * Fires immediately after the browser loads the object.
5988 * @param ev The event.
5990 onload: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5992 * Occurs when media data is loaded at the current playback position.
5993 * @param ev The event.
5995 onloadeddata: ((this: GlobalEventHandlers, ev: Event) => any) | null;
5997 * Occurs when the duration and dimensions of the media have been determined.
5998 * @param ev The event.
6000 onloadedmetadata: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6002 * Occurs when Internet Explorer begins looking for media data.
6003 * @param ev The event.
6005 onloadstart: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6006 onlostpointercapture: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
6008 * Fires when the user clicks the object with either mouse button.
6009 * @param ev The mouse event.
6011 onmousedown: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
6012 onmouseenter: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
6013 onmouseleave: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
6015 * Fires when the user moves the mouse over the object.
6016 * @param ev The mouse event.
6018 onmousemove: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
6020 * Fires when the user moves the mouse pointer outside the boundaries of the object.
6021 * @param ev The mouse event.
6023 onmouseout: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
6025 * Fires when the user moves the mouse pointer into the object.
6026 * @param ev The mouse event.
6028 onmouseover: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
6030 * Fires when the user releases a mouse button while the mouse is over the object.
6031 * @param ev The mouse event.
6033 onmouseup: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
6035 * Occurs when playback is paused.
6036 * @param ev The event.
6038 onpause: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6040 * Occurs when the play method is requested.
6041 * @param ev The event.
6043 onplay: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6045 * Occurs when the audio or video has started playing.
6046 * @param ev The event.
6048 onplaying: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6049 onpointercancel: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
6050 onpointerdown: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
6051 onpointerenter: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
6052 onpointerleave: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
6053 onpointermove: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
6054 onpointerout: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
6055 onpointerover: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
6056 onpointerup: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
6058 * Occurs to indicate progress while downloading media data.
6059 * @param ev The event.
6061 onprogress: ((this: GlobalEventHandlers, ev: ProgressEvent) => any) | null;
6063 * Occurs when the playback rate is increased or decreased.
6064 * @param ev The event.
6066 onratechange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6068 * Fires when the user resets a form.
6069 * @param ev The event.
6071 onreset: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6072 onresize: ((this: GlobalEventHandlers, ev: UIEvent) => any) | null;
6074 * Fires when the user repositions the scroll box in the scroll bar on the object.
6075 * @param ev The event.
6077 onscroll: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6078 onsecuritypolicyviolation: ((this: GlobalEventHandlers, ev: SecurityPolicyViolationEvent) => any) | null;
6080 * Occurs when the seek operation ends.
6081 * @param ev The event.
6083 onseeked: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6085 * Occurs when the current playback position is moved.
6086 * @param ev The event.
6088 onseeking: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6090 * Fires when the current selection changes.
6091 * @param ev The event.
6093 onselect: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6094 onselectionchange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6095 onselectstart: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6097 * Occurs when the download has stopped.
6098 * @param ev The event.
6100 onstalled: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6101 onsubmit: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6103 * Occurs if the load operation has been intentionally halted.
6104 * @param ev The event.
6106 onsuspend: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6108 * Occurs to indicate the current playback position.
6109 * @param ev The event.
6111 ontimeupdate: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6112 ontoggle: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6113 ontouchcancel?: ((this: GlobalEventHandlers, ev: TouchEvent) => any) | null;
6114 ontouchend?: ((this: GlobalEventHandlers, ev: TouchEvent) => any) | null;
6115 ontouchmove?: ((this: GlobalEventHandlers, ev: TouchEvent) => any) | null;
6116 ontouchstart?: ((this: GlobalEventHandlers, ev: TouchEvent) => any) | null;
6117 ontransitioncancel: ((this: GlobalEventHandlers, ev: TransitionEvent) => any) | null;
6118 ontransitionend: ((this: GlobalEventHandlers, ev: TransitionEvent) => any) | null;
6119 ontransitionrun: ((this: GlobalEventHandlers, ev: TransitionEvent) => any) | null;
6120 ontransitionstart: ((this: GlobalEventHandlers, ev: TransitionEvent) => any) | null;
6122 * Occurs when the volume is changed, or playback is muted or unmuted.
6123 * @param ev The event.
6125 onvolumechange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6127 * Occurs when playback stops because the next frame of a video resource is not available.
6128 * @param ev The event.
6130 onwaiting: ((this: GlobalEventHandlers, ev: Event) => any) | null;
6131 onwheel: ((this: GlobalEventHandlers, ev: WheelEvent) => any) | null;
6132 addEventListener<K extends keyof GlobalEventHandlersEventMap>(type: K, listener: (this: GlobalEventHandlers, ev: GlobalEventHandlersEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6133 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6134 removeEventListener<K extends keyof GlobalEventHandlersEventMap>(type: K, listener: (this: GlobalEventHandlers, ev: GlobalEventHandlersEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6135 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6138 interface HTMLAllCollection {
6140 * Returns the number of elements in the collection.
6142 readonly length: number;
6144 * Returns the item with index index from the collection (determined by tree order).
6146 item(nameOrIndex?: string): HTMLCollection | Element | null;
6148 * Returns the item with ID or name name from the collection.
6150 * If there are multiple matching items, then an HTMLCollection object containing all those elements is returned.
6152 * Only button, form, iframe, input, map, meta, object, select, and textarea elements can have a name for the purpose of this method; their name is given by the value of their name attribute.
6154 namedItem(name: string): HTMLCollection | Element | null;
6155 [index: number]: Element;
6158 declare var HTMLAllCollection: {
6159 prototype: HTMLAllCollection;
6160 new(): HTMLAllCollection;
6163 /** Hyperlink elements and provides special properties and methods (beyond those of the regular HTMLElement object interface that they inherit from) for manipulating the layout and presentation of such elements. */
6164 interface HTMLAnchorElement extends HTMLElement, HTMLHyperlinkElementUtils {
6166 * Sets or retrieves the character set used to encode the object.
6171 * Sets or retrieves the coordinates of the object.
6177 * Sets or retrieves the language code of the object.
6181 * Sets or retrieves the shape of the object.
6186 referrerPolicy: string;
6188 * Sets or retrieves the relationship between the object and the destination of the link.
6191 readonly relList: DOMTokenList;
6193 * Sets or retrieves the relationship between the object and the destination of the link.
6198 * Sets or retrieves the shape of the object.
6203 * Sets or retrieves the window or frame at which to target content.
6207 * Retrieves or sets the text of the object as a string.
6211 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLAnchorElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6212 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6213 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLAnchorElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6214 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6217 declare var HTMLAnchorElement: {
6218 prototype: HTMLAnchorElement;
6219 new(): HTMLAnchorElement;
6222 interface HTMLAppletElement extends HTMLElement {
6226 * Sets or retrieves a text alternative to the graphic.
6231 * Sets or retrieves a character string that can be used to implement your own archive functionality for the object.
6238 * Sets or retrieves the URL of the component.
6242 readonly form: HTMLFormElement | null;
6244 * Sets or retrieves the height of the object.
6251 * Sets or retrieves the shape of the object.
6261 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLAppletElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6262 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6263 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLAppletElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6264 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6267 declare var HTMLAppletElement: {
6268 prototype: HTMLAppletElement;
6269 new(): HTMLAppletElement;
6272 /** Provides special properties and methods (beyond those of the regular object HTMLElement interface it also has available to it by inheritance) for manipulating the layout and presentation of <area> elements. */
6273 interface HTMLAreaElement extends HTMLElement, HTMLHyperlinkElementUtils {
6275 * Sets or retrieves a text alternative to the graphic.
6279 * Sets or retrieves the coordinates of the object.
6284 * Sets or gets whether clicks in this region cause action.
6289 referrerPolicy: string;
6291 readonly relList: DOMTokenList;
6293 * Sets or retrieves the shape of the object.
6297 * Sets or retrieves the window or frame at which to target content.
6300 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLAreaElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6301 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6302 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLAreaElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6303 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6306 declare var HTMLAreaElement: {
6307 prototype: HTMLAreaElement;
6308 new(): HTMLAreaElement;
6311 /** Provides access to the properties of <audio> elements, as well as methods to manipulate them. It derives from the HTMLMediaElement interface. */
6312 interface HTMLAudioElement extends HTMLMediaElement {
6313 addEventListener<K extends keyof HTMLMediaElementEventMap>(type: K, listener: (this: HTMLAudioElement, ev: HTMLMediaElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6314 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6315 removeEventListener<K extends keyof HTMLMediaElementEventMap>(type: K, listener: (this: HTMLAudioElement, ev: HTMLMediaElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6316 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6319 declare var HTMLAudioElement: {
6320 prototype: HTMLAudioElement;
6321 new(): HTMLAudioElement;
6324 /** A HTML line break element (<br>). It inherits from HTMLElement. */
6325 interface HTMLBRElement extends HTMLElement {
6327 * Sets or retrieves the side on which floating objects are not to be positioned when any IHTMLBlockElement is inserted into the document.
6331 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLBRElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6332 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6333 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLBRElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6334 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6337 declare var HTMLBRElement: {
6338 prototype: HTMLBRElement;
6339 new(): HTMLBRElement;
6342 /** Contains the base URIÂ for a document. This object inherits all of the properties and methods as described in the HTMLElement interface. */
6343 interface HTMLBaseElement extends HTMLElement {
6345 * Gets or sets the baseline URL on which relative links are based.
6349 * Sets or retrieves the window or frame at which to target content.
6352 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLBaseElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6353 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6354 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLBaseElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6355 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6358 declare var HTMLBaseElement: {
6359 prototype: HTMLBaseElement;
6360 new(): HTMLBaseElement;
6363 /** Provides special properties (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating <basefont> elements. */
6364 interface HTMLBaseFontElement extends HTMLElement, DOML2DeprecatedColorProperty {
6366 * Sets or retrieves the current typeface family.
6371 * Sets or retrieves the font size of the object.
6375 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLBaseFontElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6376 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6377 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLBaseFontElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6378 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6381 declare var HTMLBaseFontElement: {
6382 prototype: HTMLBaseFontElement;
6383 new(): HTMLBaseFontElement;
6386 interface HTMLBodyElementEventMap extends HTMLElementEventMap, WindowEventHandlersEventMap {
6387 "orientationchange": Event;
6390 /** Provides special properties (beyond those inherited from the regular HTMLElement interface) for manipulating <body> elements. */
6391 interface HTMLBodyElement extends HTMLElement, WindowEventHandlers {
6401 onorientationchange: ((this: HTMLBodyElement, ev: Event) => any) | null;
6406 addEventListener<K extends keyof HTMLBodyElementEventMap>(type: K, listener: (this: HTMLBodyElement, ev: HTMLBodyElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6407 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6408 removeEventListener<K extends keyof HTMLBodyElementEventMap>(type: K, listener: (this: HTMLBodyElement, ev: HTMLBodyElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6409 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6412 declare var HTMLBodyElement: {
6413 prototype: HTMLBodyElement;
6414 new(): HTMLBodyElement;
6417 /** Provides properties and methods (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating <button> elements. */
6418 interface HTMLButtonElement extends HTMLElement {
6421 * Retrieves a reference to the form that the object is embedded in.
6423 readonly form: HTMLFormElement | null;
6425 * Overrides the action attribute (where the data on a form is sent) on the parent form element.
6429 * Used to override the encoding (formEnctype attribute) specified on the form element.
6431 formEnctype: string;
6433 * Overrides the submit method attribute previously specified on a form element.
6437 * Overrides any validation or required attributes on a form or form elements to allow it to be submitted without validation. This can be used to create a "save draft"-type submit option.
6439 formNoValidate: boolean;
6441 * Overrides the target attribute on a form element.
6444 readonly labels: NodeListOf<HTMLLabelElement>;
6446 * Sets or retrieves the name of the object.
6450 * Gets the classification and default behavior of the button.
6454 * Returns the error message that would be displayed if the user submits the form, or an empty string if no error message. It also triggers the standard error message, such as "this is a required field". The result is that the user sees validation messages without actually submitting.
6456 readonly validationMessage: string;
6458 * Returns a ValidityState object that represents the validity states of an element.
6460 readonly validity: ValidityState;
6462 * Sets or retrieves the default or selected value of the control.
6466 * Returns whether an element will successfully validate based on forms validation rules and constraints.
6468 readonly willValidate: boolean;
6470 * Returns whether a form will validate when it is submitted, without having to submit it.
6472 checkValidity(): boolean;
6473 reportValidity(): boolean;
6475 * Sets a custom error message that is displayed when a form is submitted.
6476 * @param error Sets a custom error message that is displayed when a form is submitted.
6478 setCustomValidity(error: string): void;
6479 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLButtonElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6480 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6481 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLButtonElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6482 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6485 declare var HTMLButtonElement: {
6486 prototype: HTMLButtonElement;
6487 new(): HTMLButtonElement;
6490 /** Provides properties and methods for manipulating the layout and presentation of <canvas> elements. The HTMLCanvasElement interface also inherits the properties and methods of the HTMLElement interface. */
6491 interface HTMLCanvasElement extends HTMLElement {
6493 * Gets or sets the height of a canvas element on a document.
6497 * Gets or sets the width of a canvas element on a document.
6501 * Returns an object that provides methods and properties for drawing and manipulating images and graphics on a canvas element in a document. A context object includes information about colors, line widths, fonts, and other graphic parameters that can be drawn on a canvas.
6502 * @param contextId The identifier (ID) of the type of canvas to create. Internet Explorer 9 and Internet Explorer 10 support only a 2-D context using canvas.getContext("2d"); IE11 Preview also supports 3-D or WebGL context using canvas.getContext("experimental-webgl");
6504 getContext(contextId: "2d", options?: CanvasRenderingContext2DSettings): CanvasRenderingContext2D | null;
6505 getContext(contextId: "bitmaprenderer", options?: ImageBitmapRenderingContextSettings): ImageBitmapRenderingContext | null;
6506 getContext(contextId: "webgl", options?: WebGLContextAttributes): WebGLRenderingContext | null;
6507 getContext(contextId: "webgl2", options?: WebGLContextAttributes): WebGL2RenderingContext | null;
6508 getContext(contextId: string, options?: any): RenderingContext | null;
6509 toBlob(callback: BlobCallback, type?: string, quality?: any): void;
6511 * Returns the content of the current canvas as an image that you can use as a source for another canvas or an HTML element.
6512 * @param type The standard MIME type for the image format to return. If you do not specify this parameter, the default value is a PNG format image.
6514 toDataURL(type?: string, quality?: any): string;
6515 transferControlToOffscreen(): OffscreenCanvas;
6516 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLCanvasElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6517 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6518 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLCanvasElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6519 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6522 declare var HTMLCanvasElement: {
6523 prototype: HTMLCanvasElement;
6524 new(): HTMLCanvasElement;
6527 /** A generic collection (array-like object similar to arguments) of elements (in document order) and offers methods and properties for selecting from the list. */
6528 interface HTMLCollectionBase {
6530 * Sets or retrieves the number of objects in a collection.
6532 readonly length: number;
6534 * Retrieves an object from various collections.
6536 item(index: number): Element | null;
6537 [index: number]: Element;
6540 interface HTMLCollection extends HTMLCollectionBase {
6542 * Retrieves a select object or an object from an options collection.
6544 namedItem(name: string): Element | null;
6547 declare var HTMLCollection: {
6548 prototype: HTMLCollection;
6549 new(): HTMLCollection;
6552 interface HTMLCollectionOf<T extends Element> extends HTMLCollectionBase {
6553 item(index: number): T | null;
6554 namedItem(name: string): T | null;
6558 /** Provides special properties (beyond those of the regular HTMLElement interface it also has available to it by inheritance) for manipulating definition list (<dl>) elements. */
6559 interface HTMLDListElement extends HTMLElement {
6562 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDListElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6563 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6564 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDListElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6565 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6568 declare var HTMLDListElement: {
6569 prototype: HTMLDListElement;
6570 new(): HTMLDListElement;
6573 /** Provides special properties (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating <data> elements. */
6574 interface HTMLDataElement extends HTMLElement {
6576 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDataElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6577 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6578 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDataElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6579 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6582 declare var HTMLDataElement: {
6583 prototype: HTMLDataElement;
6584 new(): HTMLDataElement;
6587 /** Provides special properties (beyond the HTMLElement object interface it also has available to it by inheritance) to manipulate <datalist> elements and their content. */
6588 interface HTMLDataListElement extends HTMLElement {
6589 readonly options: HTMLCollectionOf<HTMLOptionElement>;
6590 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDataListElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6591 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6592 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDataListElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6593 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6596 declare var HTMLDataListElement: {
6597 prototype: HTMLDataListElement;
6598 new(): HTMLDataListElement;
6601 interface HTMLDetailsElement extends HTMLElement {
6603 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDetailsElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6604 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6605 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDetailsElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6606 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6609 declare var HTMLDetailsElement: {
6610 prototype: HTMLDetailsElement;
6611 new(): HTMLDetailsElement;
6614 interface HTMLDialogElement extends HTMLElement {
6616 returnValue: string;
6617 close(returnValue?: string): void;
6620 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDialogElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6621 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6622 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDialogElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6623 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6626 declare var HTMLDialogElement: {
6627 prototype: HTMLDialogElement;
6628 new(): HTMLDialogElement;
6631 interface HTMLDirectoryElement extends HTMLElement {
6634 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDirectoryElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6635 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6636 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDirectoryElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6637 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6640 declare var HTMLDirectoryElement: {
6641 prototype: HTMLDirectoryElement;
6642 new(): HTMLDirectoryElement;
6645 /** Provides special properties (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating <div> elements. */
6646 interface HTMLDivElement extends HTMLElement {
6648 * Sets or retrieves how the object is aligned with adjacent text.
6652 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDivElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6653 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6654 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDivElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6655 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6658 declare var HTMLDivElement: {
6659 prototype: HTMLDivElement;
6660 new(): HTMLDivElement;
6663 /** The HTMLDocument property of Window objects is an alias that browsers expose for the Document interface object. */
6664 interface HTMLDocument extends Document {
6665 addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: HTMLDocument, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6666 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6667 removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: HTMLDocument, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6668 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6671 declare var HTMLDocument: {
6672 prototype: HTMLDocument;
6673 new(): HTMLDocument;
6676 interface HTMLElementEventMap extends ElementEventMap, GlobalEventHandlersEventMap, DocumentAndElementEventHandlersEventMap {
6679 /** Any HTML element. Some elements directly implement this interface, while others implement it via an interface that inherits it. */
6680 interface HTMLElement extends Element, DocumentAndElementEventHandlers, ElementCSSInlineStyle, ElementCSSInlineStyle, ElementContentEditable, GlobalEventHandlers, HTMLOrSVGElement {
6682 readonly accessKeyLabel: string;
6683 autocapitalize: string;
6689 readonly offsetHeight: number;
6690 readonly offsetLeft: number;
6691 readonly offsetParent: Element | null;
6692 readonly offsetTop: number;
6693 readonly offsetWidth: number;
6694 spellcheck: boolean;
6698 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6699 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6700 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6701 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6704 declare var HTMLElement: {
6705 prototype: HTMLElement;
6709 /** Provides special properties (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating <embed> elements. */
6710 interface HTMLEmbedElement extends HTMLElement {
6714 * Sets or retrieves the height of the object.
6718 * Sets or retrieves the name of the object.
6723 * Sets or retrieves a URL to be loaded by the object.
6728 * Sets or retrieves the width of the object.
6731 getSVGDocument(): Document | null;
6732 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLEmbedElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6733 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6734 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLEmbedElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6735 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6738 declare var HTMLEmbedElement: {
6739 prototype: HTMLEmbedElement;
6740 new(): HTMLEmbedElement;
6743 /** Provides special properties and methods (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating the layout and presentation of <fieldset> elements. */
6744 interface HTMLFieldSetElement extends HTMLElement {
6746 readonly elements: HTMLCollection;
6748 * Retrieves a reference to the form that the object is embedded in.
6750 readonly form: HTMLFormElement | null;
6752 readonly type: string;
6754 * Returns the error message that would be displayed if the user submits the form, or an empty string if no error message. It also triggers the standard error message, such as "this is a required field". The result is that the user sees validation messages without actually submitting.
6756 readonly validationMessage: string;
6758 * Returns a ValidityState object that represents the validity states of an element.
6760 readonly validity: ValidityState;
6762 * Returns whether an element will successfully validate based on forms validation rules and constraints.
6764 readonly willValidate: boolean;
6766 * Returns whether a form will validate when it is submitted, without having to submit it.
6768 checkValidity(): boolean;
6769 reportValidity(): boolean;
6771 * Sets a custom error message that is displayed when a form is submitted.
6772 * @param error Sets a custom error message that is displayed when a form is submitted.
6774 setCustomValidity(error: string): void;
6775 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLFieldSetElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6776 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6777 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLFieldSetElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6778 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6781 declare var HTMLFieldSetElement: {
6782 prototype: HTMLFieldSetElement;
6783 new(): HTMLFieldSetElement;
6786 /** Implements the document object model (DOM) representation of the font element. The HTML Font Element <font> defines the font size, font face and color of text. */
6787 interface HTMLFontElement extends HTMLElement {
6791 * Sets or retrieves the current typeface family.
6797 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLFontElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6798 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6799 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLFontElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6800 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6803 declare var HTMLFontElement: {
6804 prototype: HTMLFontElement;
6805 new(): HTMLFontElement;
6808 /** A collection of HTML form control elements. */
6809 interface HTMLFormControlsCollection extends HTMLCollectionBase {
6811 * Returns the item with ID or name name from the collection.
6813 * If there are multiple matching items, then a RadioNodeList object containing all those elements is returned.
6815 namedItem(name: string): RadioNodeList | Element | null;
6818 declare var HTMLFormControlsCollection: {
6819 prototype: HTMLFormControlsCollection;
6820 new(): HTMLFormControlsCollection;
6823 /** A <form> element in the DOM; it allows access to and in some cases modification of aspects of the form, as well as access to its component elements. */
6824 interface HTMLFormElement extends HTMLElement {
6826 * Sets or retrieves a list of character encodings for input data that must be accepted by the server processing the form.
6828 acceptCharset: string;
6830 * Sets or retrieves the URL to which the form content is sent for processing.
6834 * Specifies whether autocomplete is applied to an editable text field.
6836 autocomplete: string;
6838 * Retrieves a collection, in source order, of all controls in a given form.
6840 readonly elements: HTMLFormControlsCollection;
6842 * Sets or retrieves the MIME encoding for the form.
6846 * Sets or retrieves the encoding type for the form.
6850 * Sets or retrieves the number of objects in a collection.
6852 readonly length: number;
6854 * Sets or retrieves how to send the form data to the server.
6858 * Sets or retrieves the name of the object.
6862 * Designates a form that is not validated when submitted.
6864 noValidate: boolean;
6866 * Sets or retrieves the window or frame at which to target content.
6870 * Returns whether a form will validate when it is submitted, without having to submit it.
6872 checkValidity(): boolean;
6873 reportValidity(): boolean;
6875 * Fires when the user resets a form.
6879 * Fires when a FORM is about to be submitted.
6882 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLFormElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6883 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6884 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLFormElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6885 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6886 [index: number]: Element;
6887 [name: string]: any;
6890 declare var HTMLFormElement: {
6891 prototype: HTMLFormElement;
6892 new(): HTMLFormElement;
6895 interface HTMLFrameElement extends HTMLElement {
6897 * Retrieves the document object of the page or frame.
6900 readonly contentDocument: Document | null;
6902 * Retrieves the object of the specified.
6905 readonly contentWindow: WindowProxy | null;
6907 * Sets or retrieves whether to display a border for the frame.
6910 frameBorder: string;
6912 * Sets or retrieves a URI to a long description of the object.
6917 * Sets or retrieves the top and bottom margin heights before displaying the text in a frame.
6920 marginHeight: string;
6922 * Sets or retrieves the left and right margin widths before displaying the text in a frame.
6925 marginWidth: string;
6927 * Sets or retrieves the frame name.
6932 * Sets or retrieves whether the user can resize the frame.
6937 * Sets or retrieves whether the frame can be scrolled.
6942 * Sets or retrieves a URL to be loaded by the object.
6946 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLFrameElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6947 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6948 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLFrameElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6949 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6952 declare var HTMLFrameElement: {
6953 prototype: HTMLFrameElement;
6954 new(): HTMLFrameElement;
6957 interface HTMLFrameSetElementEventMap extends HTMLElementEventMap, WindowEventHandlersEventMap {
6960 /** Provides special properties (beyond those of the regular HTMLElement interface they also inherit) for manipulating <frameset> elements. */
6961 interface HTMLFrameSetElement extends HTMLElement, WindowEventHandlers {
6963 * Sets or retrieves the frame widths of the object.
6968 * Sets or retrieves the frame heights of the object.
6972 addEventListener<K extends keyof HTMLFrameSetElementEventMap>(type: K, listener: (this: HTMLFrameSetElement, ev: HTMLFrameSetElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6973 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6974 removeEventListener<K extends keyof HTMLFrameSetElementEventMap>(type: K, listener: (this: HTMLFrameSetElement, ev: HTMLFrameSetElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6975 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6978 declare var HTMLFrameSetElement: {
6979 prototype: HTMLFrameSetElement;
6980 new(): HTMLFrameSetElement;
6983 /** Provides special properties (beyond those of the HTMLElement interface it also has available to it by inheritance) for manipulating <hr> elements. */
6984 interface HTMLHRElement extends HTMLElement {
6986 * Sets or retrieves how the object is aligned with adjacent text.
6993 * Sets or retrieves whether the horizontal rule is drawn with 3-D shading.
7000 * Sets or retrieves the width of the object.
7004 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLHRElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7005 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7006 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLHRElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7007 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7010 declare var HTMLHRElement: {
7011 prototype: HTMLHRElement;
7012 new(): HTMLHRElement;
7015 /** Contains the descriptive information, or metadata, for a document. This object inherits all of the properties and methods described in the HTMLElement interface. */
7016 interface HTMLHeadElement extends HTMLElement {
7017 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLHeadElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7018 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7019 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLHeadElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7020 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7023 declare var HTMLHeadElement: {
7024 prototype: HTMLHeadElement;
7025 new(): HTMLHeadElement;
7028 /** The different heading elements. It inherits methods and properties from the HTMLElement interface. */
7029 interface HTMLHeadingElement extends HTMLElement {
7031 * Sets or retrieves a value that indicates the table alignment.
7035 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLHeadingElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7036 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7037 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLHeadingElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7038 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7041 declare var HTMLHeadingElement: {
7042 prototype: HTMLHeadingElement;
7043 new(): HTMLHeadingElement;
7046 /** Serves as the root node for a given HTML document. This object inherits the properties and methods described in the HTMLElement interface. */
7047 interface HTMLHtmlElement extends HTMLElement {
7049 * Sets or retrieves the DTD version that governs the current document.
7053 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLHtmlElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7054 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7055 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLHtmlElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7056 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7059 declare var HTMLHtmlElement: {
7060 prototype: HTMLHtmlElement;
7061 new(): HTMLHtmlElement;
7064 interface HTMLHyperlinkElementUtils {
7070 readonly origin: string;
7079 /** Provides special properties and methods (beyond those of the HTMLElement interface it also has available to it by inheritance) for manipulating the layout and presentation of inline frame elements. */
7080 interface HTMLIFrameElement extends HTMLElement {
7082 * Sets or retrieves how the object is aligned with adjacent text.
7087 allowFullscreen: boolean;
7088 allowPaymentRequest: boolean;
7090 * Retrieves the document object of the page or frame.
7092 readonly contentDocument: Document | null;
7094 * Retrieves the object of the specified.
7096 readonly contentWindow: WindowProxy | null;
7098 * Sets or retrieves whether to display a border for the frame.
7101 frameBorder: string;
7103 * Sets or retrieves the height of the object.
7107 * Sets or retrieves a URI to a long description of the object.
7112 * Sets or retrieves the top and bottom margin heights before displaying the text in a frame.
7115 marginHeight: string;
7117 * Sets or retrieves the left and right margin widths before displaying the text in a frame.
7120 marginWidth: string;
7122 * Sets or retrieves the frame name.
7125 referrerPolicy: ReferrerPolicy;
7126 readonly sandbox: DOMTokenList;
7128 * Sets or retrieves whether the frame can be scrolled.
7133 * Sets or retrieves a URL to be loaded by the object.
7137 * Sets or retrives the content of the page that is to contain.
7141 * Sets or retrieves the width of the object.
7144 getSVGDocument(): Document | null;
7145 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLIFrameElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7146 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7147 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLIFrameElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7148 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7151 declare var HTMLIFrameElement: {
7152 prototype: HTMLIFrameElement;
7153 new(): HTMLIFrameElement;
7156 /** Provides special properties and methods for manipulating <img> elements. */
7157 interface HTMLImageElement extends HTMLElement {
7159 * Sets or retrieves how the object is aligned with adjacent text.
7164 * Sets or retrieves a text alternative to the graphic.
7168 * Specifies the properties of a border drawn around an object.
7173 * Retrieves whether the object is fully loaded.
7175 readonly complete: boolean;
7176 crossOrigin: string | null;
7177 readonly currentSrc: string;
7178 decoding: "async" | "sync" | "auto";
7180 * Sets or retrieves the height of the object.
7184 * Sets or retrieves the width of the border to draw around the object.
7189 * Sets or retrieves whether the image is a server-side image map.
7194 * Sets or retrieves a Uniform Resource Identifier (URI) to a long description of the object.
7201 * Sets or retrieves the name of the object.
7206 * The original height of the image resource before sizing.
7208 readonly naturalHeight: number;
7210 * The original width of the image resource before sizing.
7212 readonly naturalWidth: number;
7213 referrerPolicy: string;
7216 * The address or URL of the a media resource that is to be considered.
7221 * Sets or retrieves the URL, often with a bookmark extension (#name), to use as a client-side image map.
7225 * Sets or retrieves the vertical margin for the object.
7230 * Sets or retrieves the width of the object.
7235 decode(): Promise<void>;
7236 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLImageElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7237 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7238 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLImageElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7239 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7242 declare var HTMLImageElement: {
7243 prototype: HTMLImageElement;
7244 new(): HTMLImageElement;
7247 /** Provides special properties and methods for manipulating the options, layout, and presentation of <input> elements. */
7248 interface HTMLInputElement extends HTMLElement {
7250 * Sets or retrieves a comma-separated list of content types.
7254 * Sets or retrieves how the object is aligned with adjacent text.
7259 * Sets or retrieves a text alternative to the graphic.
7263 * Specifies whether autocomplete is applied to an editable text field.
7265 autocomplete: string;
7267 * Sets or retrieves the state of the check box or radio button.
7271 * Sets or retrieves the state of the check box or radio button.
7273 defaultChecked: boolean;
7275 * Sets or retrieves the initial contents of the object.
7277 defaultValue: string;
7281 * Returns a FileList object on a file type input object.
7283 files: FileList | null;
7285 * Retrieves a reference to the form that the object is embedded in.
7287 readonly form: HTMLFormElement | null;
7289 * Overrides the action attribute (where the data on a form is sent) on the parent form element.
7293 * Used to override the encoding (formEnctype attribute) specified on the form element.
7295 formEnctype: string;
7297 * Overrides the submit method attribute previously specified on a form element.
7301 * Overrides any validation or required attributes on a form or form elements to allow it to be submitted without validation. This can be used to create a "save draft"-type submit option.
7303 formNoValidate: boolean;
7305 * Overrides the target attribute on a form element.
7309 * Sets or retrieves the height of the object.
7312 indeterminate: boolean;
7313 readonly labels: NodeListOf<HTMLLabelElement> | null;
7315 * Specifies the ID of a pre-defined datalist of options for an input element.
7317 readonly list: HTMLElement | null;
7319 * Defines the maximum acceptable value for an input element with type="number".When used with the min and step attributes, lets you control the range and increment (such as only even numbers) that the user can enter into an input field.
7323 * Sets or retrieves the maximum number of characters that the user can enter in a text control.
7327 * Defines the minimum acceptable value for an input element with type="number". When used with the max and step attributes, lets you control the range and increment (such as even numbers only) that the user can enter into an input field.
7332 * Sets or retrieves the Boolean value indicating whether multiple items can be selected from a list.
7336 * Sets or retrieves the name of the object.
7340 * Gets or sets a string containing a regular expression that the user's input must match.
7344 * Gets or sets a text string that is displayed in an input field as a hint or prompt to users as the format or type of information they need to enter.The text appears in an input field until the user puts focus on the field.
7346 placeholder: string;
7349 * When present, marks an element that can't be submitted without a value.
7352 selectionDirection: "forward" | "backward" | "none" | null;
7354 * Gets or sets the end position or offset of a text selection.
7356 selectionEnd: number | null;
7358 * Gets or sets the starting position or offset of a text selection.
7360 selectionStart: number | null;
7363 * The address or URL of the a media resource that is to be considered.
7367 * Defines an increment or jump between values that you want to allow the user to enter. When used with the max and min attributes, lets you control the range and increment (for example, allow only even numbers) that the user can enter into an input field.
7371 * Returns the content type of the object.
7375 * Sets or retrieves the URL, often with a bookmark extension (#name), to use as a client-side image map.
7380 * Returns the error message that would be displayed if the user submits the form, or an empty string if no error message. It also triggers the standard error message, such as "this is a required field". The result is that the user sees validation messages without actually submitting.
7382 readonly validationMessage: string;
7384 * Returns a ValidityState object that represents the validity states of an element.
7386 readonly validity: ValidityState;
7388 * Returns the value of the data at the cursor's current position.
7392 * Returns a Date object representing the form control's value, if applicable; otherwise, returns null. Can be set, to change the value. Throws an "InvalidStateError" DOMException if the control isn't date- or time-based.
7394 valueAsDate: Date | null;
7396 * Returns the input field value as a number.
7398 valueAsNumber: number;
7400 * Sets or retrieves the width of the object.
7404 * Returns whether an element will successfully validate based on forms validation rules and constraints.
7406 readonly willValidate: boolean;
7408 * Returns whether a form will validate when it is submitted, without having to submit it.
7410 checkValidity(): boolean;
7411 reportValidity(): boolean;
7413 * Makes the selection equal to the current object.
7417 * Sets a custom error message that is displayed when a form is submitted.
7418 * @param error Sets a custom error message that is displayed when a form is submitted.
7420 setCustomValidity(error: string): void;
7421 setRangeText(replacement: string): void;
7422 setRangeText(replacement: string, start: number, end: number, selectionMode?: SelectionMode): void;
7424 * Sets the start and end positions of a selection in a text field.
7425 * @param start The offset into the text field for the start of the selection.
7426 * @param end The offset into the text field for the end of the selection.
7427 * @param direction The direction in which the selection is performed.
7429 setSelectionRange(start: number | null, end: number | null, direction?: "forward" | "backward" | "none"): void;
7431 * Decrements a range input control's value by the value given by the Step attribute. If the optional parameter is used, it will decrement the input control's step value multiplied by the parameter's value.
7432 * @param n Value to decrement the value by.
7434 stepDown(n?: number): void;
7436 * Increments a range input control's value by the value given by the Step attribute. If the optional parameter is used, will increment the input control's value by that value.
7437 * @param n Value to increment the value by.
7439 stepUp(n?: number): void;
7440 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLInputElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7441 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7442 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLInputElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7443 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7446 declare var HTMLInputElement: {
7447 prototype: HTMLInputElement;
7448 new(): HTMLInputElement;
7451 /** Exposes specific properties and methods (beyond those defined by regular HTMLElement interface it also has available to it by inheritance) for manipulating list elements. */
7452 interface HTMLLIElement extends HTMLElement {
7456 * Sets or retrieves the value of a list item.
7459 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLLIElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7460 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7461 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLLIElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7462 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7465 declare var HTMLLIElement: {
7466 prototype: HTMLLIElement;
7467 new(): HTMLLIElement;
7470 /** Gives access to properties specific to <label> elements. It inherits methods and properties from the base HTMLElement interface. */
7471 interface HTMLLabelElement extends HTMLElement {
7472 readonly control: HTMLElement | null;
7474 * Retrieves a reference to the form that the object is embedded in.
7476 readonly form: HTMLFormElement | null;
7478 * Sets or retrieves the object to which the given label object is assigned.
7481 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLLabelElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7482 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7483 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLLabelElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7484 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7487 declare var HTMLLabelElement: {
7488 prototype: HTMLLabelElement;
7489 new(): HTMLLabelElement;
7492 /** The HTMLLegendElement is an interface allowing to access properties of the <legend> elements. It inherits properties and methods from the HTMLElement interface. */
7493 interface HTMLLegendElement extends HTMLElement {
7497 * Retrieves a reference to the form that the object is embedded in.
7499 readonly form: HTMLFormElement | null;
7500 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLLegendElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7501 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7502 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLLegendElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7503 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7506 declare var HTMLLegendElement: {
7507 prototype: HTMLLegendElement;
7508 new(): HTMLLegendElement;
7511 /** Reference information for external resources and the relationship of those resources to a document and vice-versa. This object inherits all of the properties and methods of the HTMLElement interface. */
7512 interface HTMLLinkElement extends HTMLElement, LinkStyle {
7515 * Sets or retrieves the character set used to encode the object.
7519 crossOrigin: string | null;
7522 * Sets or retrieves a destination URL or an anchor point.
7526 * Sets or retrieves the language code of the object.
7530 imageSrcset: string;
7533 * Sets or retrieves the media type.
7536 referrerPolicy: string;
7538 * Sets or retrieves the relationship between the object and the destination of the link.
7541 readonly relList: DOMTokenList;
7543 * Sets or retrieves the relationship between the object and the destination of the link.
7547 readonly sizes: DOMTokenList;
7549 * Sets or retrieves the window or frame at which to target content.
7554 * Sets or retrieves the MIME type of the object.
7557 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLLinkElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7558 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7559 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLLinkElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7560 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7563 declare var HTMLLinkElement: {
7564 prototype: HTMLLinkElement;
7565 new(): HTMLLinkElement;
7568 /** Provides special properties and methods (beyond those of the regular object HTMLElement interface it also has available to it by inheritance) for manipulating the layout and presentation of map elements. */
7569 interface HTMLMapElement extends HTMLElement {
7571 * Retrieves a collection of the area objects defined for the given map object.
7573 readonly areas: HTMLCollection;
7575 * Sets or retrieves the name of the object.
7578 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLMapElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7579 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7580 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLMapElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7581 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7584 declare var HTMLMapElement: {
7585 prototype: HTMLMapElement;
7586 new(): HTMLMapElement;
7589 interface HTMLMarqueeElementEventMap extends HTMLElementEventMap {
7595 /** Provides methods to manipulate <marquee> elements. */
7596 interface HTMLMarqueeElement extends HTMLElement {
7610 onbounce: ((this: HTMLMarqueeElement, ev: Event) => any) | null;
7612 onfinish: ((this: HTMLMarqueeElement, ev: Event) => any) | null;
7614 onstart: ((this: HTMLMarqueeElement, ev: Event) => any) | null;
7616 scrollAmount: number;
7618 scrollDelay: number;
7629 addEventListener<K extends keyof HTMLMarqueeElementEventMap>(type: K, listener: (this: HTMLMarqueeElement, ev: HTMLMarqueeElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7630 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7631 removeEventListener<K extends keyof HTMLMarqueeElementEventMap>(type: K, listener: (this: HTMLMarqueeElement, ev: HTMLMarqueeElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7632 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7635 declare var HTMLMarqueeElement: {
7636 prototype: HTMLMarqueeElement;
7637 new(): HTMLMarqueeElement;
7640 interface HTMLMediaElementEventMap extends HTMLElementEventMap {
7641 "encrypted": MediaEncryptedEvent;
7642 "waitingforkey": Event;
7645 /** Adds to HTMLElement the properties and methods needed to support basic media-related capabilities that are common to audio and video. */
7646 interface HTMLMediaElement extends HTMLElement {
7648 * Gets or sets a value that indicates whether to start playing the media automatically.
7652 * Gets a collection of buffered time ranges.
7654 readonly buffered: TimeRanges;
7656 * Gets or sets a flag that indicates whether the client provides a set of controls for the media (in case the developer does not include controls for the player).
7659 crossOrigin: string | null;
7661 * Gets the address or URL of the current media resource that is selected by IHTMLMediaElement.
7663 readonly currentSrc: string;
7665 * Gets or sets the current playback position, in seconds.
7667 currentTime: number;
7668 defaultMuted: boolean;
7670 * Gets or sets the default playback rate when the user is not using fast forward or reverse for a video or audio resource.
7672 defaultPlaybackRate: number;
7674 * Returns the duration in seconds of the current media resource. A NaN value is returned if duration is not available, or Infinity if the media resource is streaming.
7676 readonly duration: number;
7678 * Gets information about whether the playback has ended or not.
7680 readonly ended: boolean;
7682 * Returns an object representing the current error state of the audio or video element.
7684 readonly error: MediaError | null;
7686 * Gets or sets a flag to specify whether playback should restart after it completes.
7689 readonly mediaKeys: MediaKeys | null;
7691 * Gets or sets a flag that indicates whether the audio (either audio or the audio track on video media) is muted.
7695 * Gets the current network activity for the element.
7697 readonly networkState: number;
7698 onencrypted: ((this: HTMLMediaElement, ev: MediaEncryptedEvent) => any) | null;
7699 onwaitingforkey: ((this: HTMLMediaElement, ev: Event) => any) | null;
7701 * Gets a flag that specifies whether playback is paused.
7703 readonly paused: boolean;
7705 * Gets or sets the current rate of speed for the media resource to play. This speed is expressed as a multiple of the normal speed of the media resource.
7707 playbackRate: number;
7709 * Gets TimeRanges for the current media resource that has been played.
7711 readonly played: TimeRanges;
7713 * Gets or sets the current playback position, in seconds.
7716 readonly readyState: number;
7718 * Returns a TimeRanges object that represents the ranges of the current media resource that can be seeked.
7720 readonly seekable: TimeRanges;
7722 * Gets a flag that indicates whether the client is currently moving to a new playback position in the media resource.
7724 readonly seeking: boolean;
7726 * The address or URL of the a media resource that is to be considered.
7729 srcObject: MediaProvider | null;
7730 readonly textTracks: TextTrackList;
7732 * Gets or sets the volume level for audio portions of the media element.
7735 addTextTrack(kind: TextTrackKind, label?: string, language?: string): TextTrack;
7737 * Returns a string that specifies whether the client can play a given media resource type.
7739 canPlayType(type: string): CanPlayTypeResult;
7740 fastSeek(time: number): void;
7742 * Resets the audio or video object and loads a new media resource.
7746 * Pauses the current playback and sets paused to TRUE. This can be used to test whether the media is playing or paused. You can also use the pause or play events to tell whether the media is playing or not.
7750 * Loads and starts playback of a media resource.
7752 play(): Promise<void>;
7753 setMediaKeys(mediaKeys: MediaKeys | null): Promise<void>;
7754 readonly HAVE_CURRENT_DATA: number;
7755 readonly HAVE_ENOUGH_DATA: number;
7756 readonly HAVE_FUTURE_DATA: number;
7757 readonly HAVE_METADATA: number;
7758 readonly HAVE_NOTHING: number;
7759 readonly NETWORK_EMPTY: number;
7760 readonly NETWORK_IDLE: number;
7761 readonly NETWORK_LOADING: number;
7762 readonly NETWORK_NO_SOURCE: number;
7763 addEventListener<K extends keyof HTMLMediaElementEventMap>(type: K, listener: (this: HTMLMediaElement, ev: HTMLMediaElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7764 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7765 removeEventListener<K extends keyof HTMLMediaElementEventMap>(type: K, listener: (this: HTMLMediaElement, ev: HTMLMediaElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7766 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7769 declare var HTMLMediaElement: {
7770 prototype: HTMLMediaElement;
7771 new(): HTMLMediaElement;
7772 readonly HAVE_CURRENT_DATA: number;
7773 readonly HAVE_ENOUGH_DATA: number;
7774 readonly HAVE_FUTURE_DATA: number;
7775 readonly HAVE_METADATA: number;
7776 readonly HAVE_NOTHING: number;
7777 readonly NETWORK_EMPTY: number;
7778 readonly NETWORK_IDLE: number;
7779 readonly NETWORK_LOADING: number;
7780 readonly NETWORK_NO_SOURCE: number;
7783 interface HTMLMenuElement extends HTMLElement {
7786 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLMenuElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7787 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7788 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLMenuElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7789 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7792 declare var HTMLMenuElement: {
7793 prototype: HTMLMenuElement;
7794 new(): HTMLMenuElement;
7797 /** Contains descriptive metadata about a document. It inherits all of the properties and methods described in the HTMLElement interface. */
7798 interface HTMLMetaElement extends HTMLElement {
7800 * Gets or sets meta-information to associate with httpEquiv or name.
7804 * Gets or sets information used to bind the value of a content attribute of a meta element to an HTTP response header.
7808 * Sets or retrieves the value specified in the content attribute of the meta object.
7812 * Sets or retrieves a scheme to be used in interpreting the value of a property specified for the object.
7816 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLMetaElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7817 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7818 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLMetaElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7819 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7822 declare var HTMLMetaElement: {
7823 prototype: HTMLMetaElement;
7824 new(): HTMLMetaElement;
7827 /** The HTML <meter> elements expose the HTMLMeterElement interface, which provides special properties and methods (beyond the HTMLElement object interface they also have available to them by inheritance) for manipulating the layout and presentation of <meter> elements. */
7828 interface HTMLMeterElement extends HTMLElement {
7830 readonly labels: NodeListOf<HTMLLabelElement>;
7836 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLMeterElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7837 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7838 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLMeterElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7839 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7842 declare var HTMLMeterElement: {
7843 prototype: HTMLMeterElement;
7844 new(): HTMLMeterElement;
7847 /** Provides special properties (beyond the regular methods and properties available through the HTMLElement interface they also have available to them by inheritance) for manipulating modification elements, that is <del> and <ins>. */
7848 interface HTMLModElement extends HTMLElement {
7850 * Sets or retrieves reference information about the object.
7854 * Sets or retrieves the date and time of a modification to the object.
7857 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLModElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7858 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7859 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLModElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7860 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7863 declare var HTMLModElement: {
7864 prototype: HTMLModElement;
7865 new(): HTMLModElement;
7868 /** Provides special properties (beyond those defined on the regular HTMLElement interface it also has available to it by inheritance) for manipulating ordered list elements. */
7869 interface HTMLOListElement extends HTMLElement {
7874 * The starting number.
7878 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLOListElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7879 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7880 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLOListElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7881 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7884 declare var HTMLOListElement: {
7885 prototype: HTMLOListElement;
7886 new(): HTMLOListElement;
7889 /** Provides special properties and methods (beyond those on the HTMLElement interface it also has available to it by inheritance) for manipulating the layout and presentation of <object> element, representing external resources. */
7890 interface HTMLObjectElement extends HTMLElement {
7894 * Sets or retrieves a character string that can be used to implement your own archive functionality for the object.
7901 * Sets or retrieves the URL of the file containing the compiled Java class.
7906 * Sets or retrieves the URL of the component.
7911 * Sets or retrieves the Internet media type for the code associated with the object.
7916 * Retrieves the document object of the page or frame.
7918 readonly contentDocument: Document | null;
7919 readonly contentWindow: WindowProxy | null;
7921 * Sets or retrieves the URL that references the data of the object.
7927 * Retrieves a reference to the form that the object is embedded in.
7929 readonly form: HTMLFormElement | null;
7931 * Sets or retrieves the height of the object.
7937 * Sets or retrieves the name of the object.
7941 * Sets or retrieves a message to be displayed while an object is loading.
7946 * Sets or retrieves the MIME type of the object.
7950 * Sets or retrieves the URL, often with a bookmark extension (#name), to use as a client-side image map.
7954 * Returns the error message that would be displayed if the user submits the form, or an empty string if no error message. It also triggers the standard error message, such as "this is a required field". The result is that the user sees validation messages without actually submitting.
7956 readonly validationMessage: string;
7958 * Returns a ValidityState object that represents the validity states of an element.
7960 readonly validity: ValidityState;
7964 * Sets or retrieves the width of the object.
7968 * Returns whether an element will successfully validate based on forms validation rules and constraints.
7970 readonly willValidate: boolean;
7972 * Returns whether a form will validate when it is submitted, without having to submit it.
7974 checkValidity(): boolean;
7975 getSVGDocument(): Document | null;
7976 reportValidity(): boolean;
7978 * Sets a custom error message that is displayed when a form is submitted.
7979 * @param error Sets a custom error message that is displayed when a form is submitted.
7981 setCustomValidity(error: string): void;
7982 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLObjectElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7983 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7984 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLObjectElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7985 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7988 declare var HTMLObjectElement: {
7989 prototype: HTMLObjectElement;
7990 new(): HTMLObjectElement;
7993 /** Provides special properties and methods (beyond the regular HTMLElement object interface they also have available to them by inheritance) for manipulating the layout and presentation of <optgroup> elements. */
7994 interface HTMLOptGroupElement extends HTMLElement {
7997 * Retrieves a reference to the form that the object is embedded in.
7999 readonly form: HTMLFormElement | null;
8001 * Sets or retrieves a value that you can use to implement your own label functionality for the object.
8004 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLOptGroupElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8005 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8006 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLOptGroupElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8007 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8010 declare var HTMLOptGroupElement: {
8011 prototype: HTMLOptGroupElement;
8012 new(): HTMLOptGroupElement;
8015 /** <option> elements and inherits all classes and methods of the HTMLElement interface. */
8016 interface HTMLOptionElement extends HTMLElement {
8018 * Sets or retrieves the status of an option.
8020 defaultSelected: boolean;
8023 * Retrieves a reference to the form that the object is embedded in.
8025 readonly form: HTMLFormElement | null;
8027 * Sets or retrieves the ordinal position of an option in a list box.
8029 readonly index: number;
8031 * Sets or retrieves a value that you can use to implement your own label functionality for the object.
8035 * Sets or retrieves whether the option in the list box is the default item.
8039 * Sets or retrieves the text string specified by the option tag.
8043 * Sets or retrieves the value which is returned to the server when the form control is submitted.
8046 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLOptionElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8047 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8048 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLOptionElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8049 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8052 declare var HTMLOptionElement: {
8053 prototype: HTMLOptionElement;
8054 new(): HTMLOptionElement;
8057 /** HTMLOptionsCollection is an interface representing a collection of HTML option elements (in document order) and offers methods and properties for traversing the list as well as optionally altering its items. This type is returned solely by the "options" property of select. */
8058 interface HTMLOptionsCollection extends HTMLCollectionOf<HTMLOptionElement> {
8060 * Returns the number of elements in the collection.
8062 * When set to a smaller number, truncates the number of option elements in the corresponding container.
8064 * When set to a greater number, adds new blank option elements to that container.
8068 * Returns the index of the first selected item, if any, or −1 if there is no selected item.
8070 * Can be set, to change the selection.
8072 selectedIndex: number;
8074 * Inserts element before the node given by before.
8076 * The before argument can be a number, in which case element is inserted before the item with that number, or an element from the collection, in which case element is inserted before that element.
8078 * If before is omitted, null, or a number out of range, then element will be added at the end of the list.
8080 * This method will throw a "HierarchyRequestError" DOMException if element is an ancestor of the element into which it is to be inserted.
8082 add(element: HTMLOptionElement | HTMLOptGroupElement, before?: HTMLElement | number | null): void;
8084 * Removes the item with index index from the collection.
8086 remove(index: number): void;
8089 declare var HTMLOptionsCollection: {
8090 prototype: HTMLOptionsCollection;
8091 new(): HTMLOptionsCollection;
8094 interface HTMLOrSVGElement {
8096 readonly dataset: DOMStringMap;
8100 focus(options?: FocusOptions): void;
8103 /** Provides properties and methods (beyond those inherited from HTMLElement) for manipulating the layout and presentation of <output> elements. */
8104 interface HTMLOutputElement extends HTMLElement {
8105 defaultValue: string;
8106 readonly form: HTMLFormElement | null;
8107 readonly htmlFor: DOMTokenList;
8108 readonly labels: NodeListOf<HTMLLabelElement>;
8110 readonly type: string;
8111 readonly validationMessage: string;
8112 readonly validity: ValidityState;
8114 readonly willValidate: boolean;
8115 checkValidity(): boolean;
8116 reportValidity(): boolean;
8117 setCustomValidity(error: string): void;
8118 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLOutputElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8119 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8120 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLOutputElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8121 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8124 declare var HTMLOutputElement: {
8125 prototype: HTMLOutputElement;
8126 new(): HTMLOutputElement;
8129 /** Provides special properties (beyond those of the regular HTMLElement object interface it inherits) for manipulating <p> elements. */
8130 interface HTMLParagraphElement extends HTMLElement {
8132 * Sets or retrieves how the object is aligned with adjacent text.
8136 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLParagraphElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8137 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8138 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLParagraphElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8139 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8142 declare var HTMLParagraphElement: {
8143 prototype: HTMLParagraphElement;
8144 new(): HTMLParagraphElement;
8147 /** Provides special properties (beyond those of the regular HTMLElement object interface it inherits) for manipulating <param> elements, representing a pair of a key and a value that acts as a parameter for an <object> element. */
8148 interface HTMLParamElement extends HTMLElement {
8150 * Sets or retrieves the name of an input parameter for an element.
8154 * Sets or retrieves the content type of the resource designated by the value attribute.
8159 * Sets or retrieves the value of an input parameter for an element.
8163 * Sets or retrieves the data type of the value attribute.
8167 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLParamElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8168 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8169 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLParamElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8170 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8173 declare var HTMLParamElement: {
8174 prototype: HTMLParamElement;
8175 new(): HTMLParamElement;
8178 /** A <picture> HTML element. It doesn't implement specific properties or methods. */
8179 interface HTMLPictureElement extends HTMLElement {
8180 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLPictureElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8181 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8182 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLPictureElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8183 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8186 declare var HTMLPictureElement: {
8187 prototype: HTMLPictureElement;
8188 new(): HTMLPictureElement;
8191 /** Exposes specific properties and methods (beyond those of the HTMLElement interface it also has available to it by inheritance) for manipulating a block of preformatted text (<pre>). */
8192 interface HTMLPreElement extends HTMLElement {
8194 * Sets or gets a value that you can use to implement your own width functionality for the object.
8198 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLPreElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8199 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8200 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLPreElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8201 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8204 declare var HTMLPreElement: {
8205 prototype: HTMLPreElement;
8206 new(): HTMLPreElement;
8209 /** Provides special properties and methods (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating the layout and presentation of <progress> elements. */
8210 interface HTMLProgressElement extends HTMLElement {
8211 readonly labels: NodeListOf<HTMLLabelElement>;
8213 * Defines the maximum, or "done" value for a progress element.
8217 * Returns the quotient of value/max when the value attribute is set (determinate progress bar), or -1 when the value attribute is missing (indeterminate progress bar).
8219 readonly position: number;
8221 * Sets or gets the current value of a progress element. The value must be a non-negative number between 0 and the max value.
8224 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLProgressElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8225 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8226 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLProgressElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8227 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8230 declare var HTMLProgressElement: {
8231 prototype: HTMLProgressElement;
8232 new(): HTMLProgressElement;
8235 /** Provides special properties and methods (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating quoting elements, like <blockquote> and <q>, but not the <cite> element. */
8236 interface HTMLQuoteElement extends HTMLElement {
8238 * Sets or retrieves reference information about the object.
8241 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLQuoteElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8242 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8243 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLQuoteElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8244 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8247 declare var HTMLQuoteElement: {
8248 prototype: HTMLQuoteElement;
8249 new(): HTMLQuoteElement;
8252 /** HTML <script> elements expose the HTMLScriptElement interface, which provides special properties and methods for manipulating the behavior and execution of <script> elements (beyond the inherited HTMLElement interface). */
8253 interface HTMLScriptElement extends HTMLElement {
8256 * Sets or retrieves the character set used to encode the object.
8260 crossOrigin: string | null;
8262 * Sets or retrieves the status of the script.
8266 * Sets or retrieves the event for which the script is written.
8271 * Sets or retrieves the object that is bound to the event script.
8277 referrerPolicy: string;
8279 * Retrieves the URL to an external file that contains the source code or data.
8283 * Retrieves or sets the text of the object as a string.
8287 * Sets or retrieves the MIME type for the associated scripting engine.
8290 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLScriptElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8291 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8292 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLScriptElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8293 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8296 declare var HTMLScriptElement: {
8297 prototype: HTMLScriptElement;
8298 new(): HTMLScriptElement;
8301 /** A <select> HTML Element. These elements also share all of the properties and methods of other HTML elements via the HTMLElement interface. */
8302 interface HTMLSelectElement extends HTMLElement {
8303 autocomplete: string;
8306 * Retrieves a reference to the form that the object is embedded in.
8308 readonly form: HTMLFormElement | null;
8309 readonly labels: NodeListOf<HTMLLabelElement>;
8311 * Sets or retrieves the number of objects in a collection.
8315 * Sets or retrieves the Boolean value indicating whether multiple items can be selected from a list.
8319 * Sets or retrieves the name of the object.
8322 readonly options: HTMLOptionsCollection;
8324 * When present, marks an element that can't be submitted without a value.
8328 * Sets or retrieves the index of the selected option in a select object.
8330 selectedIndex: number;
8331 readonly selectedOptions: HTMLCollectionOf<HTMLOptionElement>;
8333 * Sets or retrieves the number of rows in the list box.
8337 * Retrieves the type of select control based on the value of the MULTIPLE attribute.
8339 readonly type: string;
8341 * Returns the error message that would be displayed if the user submits the form, or an empty string if no error message. It also triggers the standard error message, such as "this is a required field". The result is that the user sees validation messages without actually submitting.
8343 readonly validationMessage: string;
8345 * Returns a ValidityState object that represents the validity states of an element.
8347 readonly validity: ValidityState;
8349 * Sets or retrieves the value which is returned to the server when the form control is submitted.
8353 * Returns whether an element will successfully validate based on forms validation rules and constraints.
8355 readonly willValidate: boolean;
8357 * Adds an element to the areas, controlRange, or options collection.
8358 * @param element Variant of type Number that specifies the index position in the collection where the element is placed. If no value is given, the method places the element at the end of the collection.
8359 * @param before Variant of type Object that specifies an element to insert before, or null to append the object to the collection.
8361 add(element: HTMLOptionElement | HTMLOptGroupElement, before?: HTMLElement | number | null): void;
8363 * Returns whether a form will validate when it is submitted, without having to submit it.
8365 checkValidity(): boolean;
8367 * Retrieves a select object or an object from an options collection.
8368 * @param name Variant of type Number or String that specifies the object or collection to retrieve. If this parameter is an integer, it is the zero-based index of the object. If this parameter is a string, all objects with matching name or id properties are retrieved, and a collection is returned if more than one match is made.
8369 * @param index Variant of type Number that specifies the zero-based index of the object to retrieve when a collection is returned.
8371 item(index: number): Element | null;
8373 * Retrieves a select object or an object from an options collection.
8374 * @param namedItem A String that specifies the name or id property of the object to retrieve. A collection is returned if more than one match is made.
8376 namedItem(name: string): HTMLOptionElement | null;
8378 * Removes an element from the collection.
8379 * @param index Number that specifies the zero-based index of the element to remove from the collection.
8382 remove(index: number): void;
8383 reportValidity(): boolean;
8385 * Sets a custom error message that is displayed when a form is submitted.
8386 * @param error Sets a custom error message that is displayed when a form is submitted.
8388 setCustomValidity(error: string): void;
8389 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLSelectElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8390 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8391 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLSelectElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8392 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8393 [name: number]: HTMLOptionElement | HTMLOptGroupElement;
8396 declare var HTMLSelectElement: {
8397 prototype: HTMLSelectElement;
8398 new(): HTMLSelectElement;
8401 interface HTMLSlotElement extends HTMLElement {
8403 assignedElements(options?: AssignedNodesOptions): Element[];
8404 assignedNodes(options?: AssignedNodesOptions): Node[];
8405 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLSlotElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8406 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8407 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLSlotElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8408 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8411 declare var HTMLSlotElement: {
8412 prototype: HTMLSlotElement;
8413 new(): HTMLSlotElement;
8416 /** Provides special properties (beyond the regular HTMLElement object interface it also has available to it by inheritance) for manipulating <source> elements. */
8417 interface HTMLSourceElement extends HTMLElement {
8419 * Gets or sets the intended media type of the media source.
8424 * The address or URL of the a media resource that is to be considered.
8429 * Gets or sets the MIME type of a media resource.
8432 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLSourceElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8433 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8434 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLSourceElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8435 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8438 declare var HTMLSourceElement: {
8439 prototype: HTMLSourceElement;
8440 new(): HTMLSourceElement;
8443 /** A <span> element and derives from the HTMLElement interface, but without implementing any additional properties or methods. */
8444 interface HTMLSpanElement extends HTMLElement {
8445 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLSpanElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8446 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8447 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLSpanElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8448 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8451 declare var HTMLSpanElement: {
8452 prototype: HTMLSpanElement;
8453 new(): HTMLSpanElement;
8456 /** A <style> element. It inherits properties and methods from its parent, HTMLElement, and from LinkStyle. */
8457 interface HTMLStyleElement extends HTMLElement, LinkStyle {
8459 * Sets or retrieves the media type.
8463 * Retrieves the CSS language in which the style sheet is written.
8467 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLStyleElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8468 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8469 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLStyleElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8470 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8473 declare var HTMLStyleElement: {
8474 prototype: HTMLStyleElement;
8475 new(): HTMLStyleElement;
8478 /** Special properties (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating table caption elements. */
8479 interface HTMLTableCaptionElement extends HTMLElement {
8481 * Sets or retrieves the alignment of the caption or legend.
8485 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableCaptionElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8486 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8487 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableCaptionElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8488 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8491 declare var HTMLTableCaptionElement: {
8492 prototype: HTMLTableCaptionElement;
8493 new(): HTMLTableCaptionElement;
8496 /** Provides special properties and methods (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating the layout and presentation of table cells, either header or data cells, in an HTML document. */
8497 interface HTMLTableCellElement extends HTMLElement {
8499 * Sets or retrieves abbreviated text for the object.
8503 * Sets or retrieves how the object is aligned with adjacent text.
8508 * Sets or retrieves a comma-delimited list of conceptual categories associated with the object.
8515 * Retrieves the position of the object in the cells collection of a row.
8517 readonly cellIndex: number;
8523 * Sets or retrieves the number columns in the table that the object should span.
8527 * Sets or retrieves a list of header cells that provide information for the object.
8531 * Sets or retrieves the height of the object.
8536 * Sets or retrieves whether the browser automatically performs wordwrap.
8541 * Sets or retrieves how many rows in a table the cell should span.
8545 * Sets or retrieves the group of cells in a table to which the object's information applies.
8551 * Sets or retrieves the width of the object.
8555 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableCellElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8556 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8557 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableCellElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8558 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8561 declare var HTMLTableCellElement: {
8562 prototype: HTMLTableCellElement;
8563 new(): HTMLTableCellElement;
8566 /** Provides special properties (beyond the HTMLElement interface it also has available to it inheritance) for manipulating single or grouped table column elements. */
8567 interface HTMLTableColElement extends HTMLElement {
8569 * Sets or retrieves the alignment of the object relative to the display or table.
8578 * Sets or retrieves the number of columns in the group.
8584 * Sets or retrieves the width of the object.
8588 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableColElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8589 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8590 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableColElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8591 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8594 declare var HTMLTableColElement: {
8595 prototype: HTMLTableColElement;
8596 new(): HTMLTableColElement;
8599 interface HTMLTableDataCellElement extends HTMLTableCellElement {
8600 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableDataCellElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8601 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8602 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableDataCellElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8603 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8606 declare var HTMLTableDataCellElement: {
8607 prototype: HTMLTableDataCellElement;
8608 new(): HTMLTableDataCellElement;
8611 /** Provides special properties and methods (beyond the regular HTMLElement object interface it also has available to it by inheritance) for manipulating the layout and presentation of tables in an HTML document. */
8612 interface HTMLTableElement extends HTMLElement {
8614 * Sets or retrieves a value that indicates the table alignment.
8621 * Sets or retrieves the width of the border to draw around the object.
8626 * Retrieves the caption object of a table.
8628 caption: HTMLTableCaptionElement | null;
8630 * Sets or retrieves the amount of space between the border of the cell and the content of the cell.
8633 cellPadding: string;
8635 * Sets or retrieves the amount of space between cells in a table.
8638 cellSpacing: string;
8640 * Sets or retrieves the way the border frame around the table is displayed.
8645 * Sets or retrieves the number of horizontal rows contained in the object.
8647 readonly rows: HTMLCollectionOf<HTMLTableRowElement>;
8649 * Sets or retrieves which dividing lines (inner borders) are displayed.
8654 * Sets or retrieves a description and/or structure of the object.
8659 * Retrieves a collection of all tBody objects in the table. Objects in this collection are in source order.
8661 readonly tBodies: HTMLCollectionOf<HTMLTableSectionElement>;
8663 * Retrieves the tFoot object of the table.
8665 tFoot: HTMLTableSectionElement | null;
8667 * Retrieves the tHead object of the table.
8669 tHead: HTMLTableSectionElement | null;
8671 * Sets or retrieves the width of the object.
8676 * Creates an empty caption element in the table.
8678 createCaption(): HTMLTableCaptionElement;
8680 * Creates an empty tBody element in the table.
8682 createTBody(): HTMLTableSectionElement;
8684 * Creates an empty tFoot element in the table.
8686 createTFoot(): HTMLTableSectionElement;
8688 * Returns the tHead element object if successful, or null otherwise.
8690 createTHead(): HTMLTableSectionElement;
8692 * Deletes the caption element and its contents from the table.
8694 deleteCaption(): void;
8696 * Removes the specified row (tr) from the element and from the rows collection.
8697 * @param index Number that specifies the zero-based position in the rows collection of the row to remove.
8699 deleteRow(index: number): void;
8701 * Deletes the tFoot element and its contents from the table.
8703 deleteTFoot(): void;
8705 * Deletes the tHead element and its contents from the table.
8707 deleteTHead(): void;
8709 * Creates a new row (tr) in the table, and adds the row to the rows collection.
8710 * @param index Number that specifies where to insert the row in the rows collection. The default value is -1, which appends the new row to the end of the rows collection.
8712 insertRow(index?: number): HTMLTableRowElement;
8713 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8714 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8715 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8716 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8719 declare var HTMLTableElement: {
8720 prototype: HTMLTableElement;
8721 new(): HTMLTableElement;
8724 interface HTMLTableHeaderCellElement extends HTMLTableCellElement {
8725 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableHeaderCellElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8726 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8727 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableHeaderCellElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8728 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8731 declare var HTMLTableHeaderCellElement: {
8732 prototype: HTMLTableHeaderCellElement;
8733 new(): HTMLTableHeaderCellElement;
8736 /** Provides special properties and methods (beyond the HTMLElement interface it also has available to it by inheritance) for manipulating the layout and presentation of rows in an HTML table. */
8737 interface HTMLTableRowElement extends HTMLElement {
8739 * Sets or retrieves how the object is aligned with adjacent text.
8746 * Retrieves a collection of all cells in the table row.
8748 readonly cells: HTMLCollectionOf<HTMLTableDataCellElement | HTMLTableHeaderCellElement>;
8754 * Retrieves the position of the object in the rows collection for the table.
8756 readonly rowIndex: number;
8758 * Retrieves the position of the object in the collection.
8760 readonly sectionRowIndex: number;
8764 * Removes the specified cell from the table row, as well as from the cells collection.
8765 * @param index Number that specifies the zero-based position of the cell to remove from the table row. If no value is provided, the last cell in the cells collection is deleted.
8767 deleteCell(index: number): void;
8769 * Creates a new cell in the table row, and adds the cell to the cells collection.
8770 * @param index Number that specifies where to insert the cell in the tr. The default value is -1, which appends the new cell to the end of the cells collection.
8772 insertCell(index?: number): HTMLTableDataCellElement;
8773 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableRowElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8774 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8775 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableRowElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8776 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8779 declare var HTMLTableRowElement: {
8780 prototype: HTMLTableRowElement;
8781 new(): HTMLTableRowElement;
8784 /** Provides special properties and methods (beyond the HTMLElement interface it also has available to it by inheritance) for manipulating the layout and presentation of sections, that is headers, footers and bodies, in an HTML table. */
8785 interface HTMLTableSectionElement extends HTMLElement {
8787 * Sets or retrieves a value that indicates the table alignment.
8796 * Sets or retrieves the number of horizontal rows contained in the object.
8798 readonly rows: HTMLCollectionOf<HTMLTableRowElement>;
8802 * Removes the specified row (tr) from the element and from the rows collection.
8803 * @param index Number that specifies the zero-based position in the rows collection of the row to remove.
8805 deleteRow(index: number): void;
8807 * Creates a new row (tr) in the table, and adds the row to the rows collection.
8808 * @param index Number that specifies where to insert the row in the rows collection. The default value is -1, which appends the new row to the end of the rows collection.
8810 insertRow(index?: number): HTMLTableRowElement;
8811 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableSectionElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8812 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8813 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableSectionElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8814 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8817 declare var HTMLTableSectionElement: {
8818 prototype: HTMLTableSectionElement;
8819 new(): HTMLTableSectionElement;
8822 /** Enables access to the contents of an HTML <template> element. */
8823 interface HTMLTemplateElement extends HTMLElement {
8824 readonly content: DocumentFragment;
8825 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTemplateElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8826 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8827 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTemplateElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8828 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8831 declare var HTMLTemplateElement: {
8832 prototype: HTMLTemplateElement;
8833 new(): HTMLTemplateElement;
8836 /** Provides special properties and methods for manipulating the layout and presentation of <textarea> elements. */
8837 interface HTMLTextAreaElement extends HTMLElement {
8838 autocomplete: string;
8840 * Sets or retrieves the width of the object.
8844 * Sets or retrieves the initial contents of the object.
8846 defaultValue: string;
8850 * Retrieves a reference to the form that the object is embedded in.
8852 readonly form: HTMLFormElement | null;
8853 readonly labels: NodeListOf<HTMLLabelElement>;
8855 * Sets or retrieves the maximum number of characters that the user can enter in a text control.
8860 * Sets or retrieves the name of the object.
8864 * Gets or sets a text string that is displayed in an input field as a hint or prompt to users as the format or type of information they need to enter.The text appears in an input field until the user puts focus on the field.
8866 placeholder: string;
8868 * Sets or retrieves the value indicated whether the content of the object is read-only.
8872 * When present, marks an element that can't be submitted without a value.
8876 * Sets or retrieves the number of horizontal rows contained in the object.
8879 selectionDirection: "forward" | "backward" | "none";
8881 * Gets or sets the end position or offset of a text selection.
8883 selectionEnd: number;
8885 * Gets or sets the starting position or offset of a text selection.
8887 selectionStart: number;
8888 readonly textLength: number;
8890 * Retrieves the type of control.
8892 readonly type: string;
8894 * Returns the error message that would be displayed if the user submits the form, or an empty string if no error message. It also triggers the standard error message, such as "this is a required field". The result is that the user sees validation messages without actually submitting.
8896 readonly validationMessage: string;
8898 * Returns a ValidityState object that represents the validity states of an element.
8900 readonly validity: ValidityState;
8902 * Retrieves or sets the text in the entry field of the textArea element.
8906 * Returns whether an element will successfully validate based on forms validation rules and constraints.
8908 readonly willValidate: boolean;
8910 * Sets or retrieves how to handle wordwrapping in the object.
8914 * Returns whether a form will validate when it is submitted, without having to submit it.
8916 checkValidity(): boolean;
8917 reportValidity(): boolean;
8919 * Highlights the input area of a form element.
8923 * Sets a custom error message that is displayed when a form is submitted.
8924 * @param error Sets a custom error message that is displayed when a form is submitted.
8926 setCustomValidity(error: string): void;
8927 setRangeText(replacement: string): void;
8928 setRangeText(replacement: string, start: number, end: number, selectionMode?: SelectionMode): void;
8930 * Sets the start and end positions of a selection in a text field.
8931 * @param start The offset into the text field for the start of the selection.
8932 * @param end The offset into the text field for the end of the selection.
8933 * @param direction The direction in which the selection is performed.
8935 setSelectionRange(start: number | null, end: number | null, direction?: "forward" | "backward" | "none"): void;
8936 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTextAreaElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8937 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8938 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTextAreaElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8939 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8942 declare var HTMLTextAreaElement: {
8943 prototype: HTMLTextAreaElement;
8944 new(): HTMLTextAreaElement;
8947 /** Provides special properties (beyond the regular HTMLElement interface it also has available to it by inheritance) for manipulating <time> elements. */
8948 interface HTMLTimeElement extends HTMLElement {
8950 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTimeElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8951 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8952 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTimeElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8953 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8956 declare var HTMLTimeElement: {
8957 prototype: HTMLTimeElement;
8958 new(): HTMLTimeElement;
8961 /** Contains the title for a document. This element inherits all of the properties and methods of the HTMLElement interface. */
8962 interface HTMLTitleElement extends HTMLElement {
8964 * Retrieves or sets the text of the object as a string.
8967 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTitleElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8968 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8969 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTitleElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8970 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8973 declare var HTMLTitleElement: {
8974 prototype: HTMLTitleElement;
8975 new(): HTMLTitleElement;
8978 /** The HTMLTrackElement */
8979 interface HTMLTrackElement extends HTMLElement {
8983 readonly readyState: number;
8986 readonly track: TextTrack;
8987 readonly ERROR: number;
8988 readonly LOADED: number;
8989 readonly LOADING: number;
8990 readonly NONE: number;
8991 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTrackElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8992 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8993 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTrackElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8994 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8997 declare var HTMLTrackElement: {
8998 prototype: HTMLTrackElement;
8999 new(): HTMLTrackElement;
9000 readonly ERROR: number;
9001 readonly LOADED: number;
9002 readonly LOADING: number;
9003 readonly NONE: number;
9006 /** Provides special properties (beyond those defined on the regular HTMLElement interface it also has available to it by inheritance) for manipulating unordered list elements. */
9007 interface HTMLUListElement extends HTMLElement {
9012 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLUListElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9013 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9014 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLUListElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9015 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9018 declare var HTMLUListElement: {
9019 prototype: HTMLUListElement;
9020 new(): HTMLUListElement;
9023 /** An invalid HTML element and derives from the HTMLElement interface, but without implementing any additional properties or methods. */
9024 interface HTMLUnknownElement extends HTMLElement {
9025 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLUnknownElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9026 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9027 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLUnknownElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9028 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9031 declare var HTMLUnknownElement: {
9032 prototype: HTMLUnknownElement;
9033 new(): HTMLUnknownElement;
9036 /** Provides special properties and methods for manipulating video objects. It also inherits properties and methods of HTMLMediaElement and HTMLElement. */
9037 interface HTMLVideoElement extends HTMLMediaElement {
9039 * Gets or sets the height of the video element.
9043 * Gets or sets the playsinline of the video element. for example, On iPhone, video elements will now be allowed to play inline, and will not automatically enter fullscreen mode when playback begins.
9045 playsInline: boolean;
9047 * Gets or sets a URL of an image to display, for example, like a movie poster. This can be a still frame from the video, or another image if no video data is available.
9051 * Gets the intrinsic height of a video in CSS pixels, or zero if the dimensions are not known.
9053 readonly videoHeight: number;
9055 * Gets the intrinsic width of a video in CSS pixels, or zero if the dimensions are not known.
9057 readonly videoWidth: number;
9059 * Gets or sets the width of the video element.
9062 getVideoPlaybackQuality(): VideoPlaybackQuality;
9063 addEventListener<K extends keyof HTMLMediaElementEventMap>(type: K, listener: (this: HTMLVideoElement, ev: HTMLMediaElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9064 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9065 removeEventListener<K extends keyof HTMLMediaElementEventMap>(type: K, listener: (this: HTMLVideoElement, ev: HTMLMediaElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9066 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9069 declare var HTMLVideoElement: {
9070 prototype: HTMLVideoElement;
9071 new(): HTMLVideoElement;
9074 /** Events that fire when the fragment identifier of the URL has changed. */
9075 interface HashChangeEvent extends Event {
9077 * Returns the URL of the session history entry that is now current.
9079 readonly newURL: string;
9081 * Returns the URL of the session history entry that was previously current.
9083 readonly oldURL: string;
9086 declare var HashChangeEvent: {
9087 prototype: HashChangeEvent;
9088 new(type: string, eventInitDict?: HashChangeEventInit): HashChangeEvent;
9091 /** This Fetch API interface allows you to perform various actions on HTTP request and response headers. These actions include retrieving, setting, adding to, and removing. A Headers object has an associated header list, which is initially empty and consists of zero or more name and value pairs.  You can add to this using methods like append() (see Examples.) In all methods of this interface, header names are matched by case-insensitive byte sequence. */
9093 append(name: string, value: string): void;
9094 delete(name: string): void;
9095 get(name: string): string | null;
9096 has(name: string): boolean;
9097 set(name: string, value: string): void;
9098 forEach(callbackfn: (value: string, key: string, parent: Headers) => void, thisArg?: any): void;
9101 declare var Headers: {
9103 new(init?: HeadersInit): Headers;
9106 /** Allows manipulation of the browser session history, that is the pages visited in the tab or frame that the current page is loaded in. */
9108 readonly length: number;
9109 scrollRestoration: ScrollRestoration;
9110 readonly state: any;
9113 go(delta?: number): void;
9114 pushState(data: any, title: string, url?: string | null): void;
9115 replaceState(data: any, title: string, url?: string | null): void;
9118 declare var History: {
9123 interface IDBArrayKey extends Array<IDBValidKey> {
9126 /** This IndexedDB API interface represents a cursor for traversing or iterating over multiple records in a database. */
9127 interface IDBCursor {
9129 * Returns the direction ("next", "nextunique", "prev" or "prevunique") of the cursor.
9131 readonly direction: IDBCursorDirection;
9133 * Returns the key of the cursor. Throws a "InvalidStateError" DOMException if the cursor is advancing or is finished.
9135 readonly key: IDBValidKey;
9137 * Returns the effective key of the cursor. Throws a "InvalidStateError" DOMException if the cursor is advancing or is finished.
9139 readonly primaryKey: IDBValidKey;
9141 * Returns the IDBObjectStore or IDBIndex the cursor was opened from.
9143 readonly source: IDBObjectStore | IDBIndex;
9145 * Advances the cursor through the next count records in range.
9147 advance(count: number): void;
9149 * Advances the cursor to the next record in range.
9151 continue(key?: IDBValidKey): void;
9153 * Advances the cursor to the next record in range matching or after key and primaryKey. Throws an "InvalidAccessError" DOMException if the source is not an index.
9155 continuePrimaryKey(key: IDBValidKey, primaryKey: IDBValidKey): void;
9157 * Delete the record pointed at by the cursor with a new value.
9159 * If successful, request's result will be undefined.
9161 delete(): IDBRequest<undefined>;
9163 * Updated the record pointed at by the cursor with a new value.
9165 * Throws a "DataError" DOMException if the effective object store uses in-line keys and the key would have changed.
9167 * If successful, request's result will be the record's key.
9169 update(value: any): IDBRequest<IDBValidKey>;
9172 declare var IDBCursor: {
9173 prototype: IDBCursor;
9177 /** This IndexedDB API interface represents a cursor for traversing or iterating over multiple records in a database. It is the same as the IDBCursor, except that it includes the value property. */
9178 interface IDBCursorWithValue extends IDBCursor {
9180 * Returns the cursor's current value.
9182 readonly value: any;
9185 declare var IDBCursorWithValue: {
9186 prototype: IDBCursorWithValue;
9187 new(): IDBCursorWithValue;
9190 interface IDBDatabaseEventMap {
9194 "versionchange": IDBVersionChangeEvent;
9197 /** This IndexedDB API interface provides a connection to a database; you can use an IDBDatabase object to open a transaction on your database then create, manipulate, and delete objects (data) in that database. The interface provides the only way to get and manage versions of the database. */
9198 interface IDBDatabase extends EventTarget {
9200 * Returns the name of the database.
9202 readonly name: string;
9204 * Returns a list of the names of object stores in the database.
9206 readonly objectStoreNames: DOMStringList;
9207 onabort: ((this: IDBDatabase, ev: Event) => any) | null;
9208 onclose: ((this: IDBDatabase, ev: Event) => any) | null;
9209 onerror: ((this: IDBDatabase, ev: Event) => any) | null;
9210 onversionchange: ((this: IDBDatabase, ev: IDBVersionChangeEvent) => any) | null;
9212 * Returns the version of the database.
9214 readonly version: number;
9216 * Closes the connection once all running transactions have finished.
9220 * Creates a new object store with the given name and options and returns a new IDBObjectStore.
9222 * Throws a "InvalidStateError" DOMException if not called within an upgrade transaction.
9224 createObjectStore(name: string, options?: IDBObjectStoreParameters): IDBObjectStore;
9226 * Deletes the object store with the given name.
9228 * Throws a "InvalidStateError" DOMException if not called within an upgrade transaction.
9230 deleteObjectStore(name: string): void;
9232 * Returns a new transaction with the given mode ("readonly" or "readwrite") and scope which can be a single object store name or an array of names.
9234 transaction(storeNames: string | string[], mode?: IDBTransactionMode): IDBTransaction;
9235 addEventListener<K extends keyof IDBDatabaseEventMap>(type: K, listener: (this: IDBDatabase, ev: IDBDatabaseEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9236 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9237 removeEventListener<K extends keyof IDBDatabaseEventMap>(type: K, listener: (this: IDBDatabase, ev: IDBDatabaseEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9238 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9241 declare var IDBDatabase: {
9242 prototype: IDBDatabase;
9246 /** In the following code snippet, we make a request to open a database, and include handlers for the success and error cases. For a full working example, see our To-do Notifications app (view example live.) */
9247 interface IDBFactory {
9249 * Compares two values as keys. Returns -1 if key1 precedes key2, 1 if key2 precedes key1, and 0 if the keys are equal.
9251 * Throws a "DataError" DOMException if either input is not a valid key.
9253 cmp(first: any, second: any): number;
9255 * Attempts to delete the named database. If the database already exists and there are open connections that don't close in response to a versionchange event, the request will be blocked until all they close. If the request is successful request's result will be null.
9257 deleteDatabase(name: string): IDBOpenDBRequest;
9259 * Attempts to open a connection to the named database with the current version, or 1 if it does not already exist. If the request is successful request's result will be the connection.
9261 open(name: string, version?: number): IDBOpenDBRequest;
9264 declare var IDBFactory: {
9265 prototype: IDBFactory;
9269 /** IDBIndex interface of the IndexedDB API provides asynchronous access to an index in a database. An index is a kind of object store for looking up records in another object store, called the referenced object store. You use this interface to retrieve data. */
9270 interface IDBIndex {
9271 readonly keyPath: string | string[];
9272 readonly multiEntry: boolean;
9274 * Returns the name of the index.
9278 * Returns the IDBObjectStore the index belongs to.
9280 readonly objectStore: IDBObjectStore;
9281 readonly unique: boolean;
9283 * Retrieves the number of records matching the given key or key range in query.
9285 * If successful, request's result will be the count.
9287 count(key?: IDBValidKey | IDBKeyRange): IDBRequest<number>;
9289 * Retrieves the value of the first record matching the given key or key range in query.
9291 * If successful, request's result will be the value, or undefined if there was no matching record.
9293 get(key: IDBValidKey | IDBKeyRange): IDBRequest<any | undefined>;
9295 * Retrieves the values of the records matching the given key or key range in query (up to count if given).
9297 * If successful, request's result will be an Array of the values.
9299 getAll(query?: IDBValidKey | IDBKeyRange | null, count?: number): IDBRequest<any[]>;
9301 * Retrieves the keys of records matching the given key or key range in query (up to count if given).
9303 * If successful, request's result will be an Array of the keys.
9305 getAllKeys(query?: IDBValidKey | IDBKeyRange | null, count?: number): IDBRequest<IDBValidKey[]>;
9307 * Retrieves the key of the first record matching the given key or key range in query.
9309 * If successful, request's result will be the key, or undefined if there was no matching record.
9311 getKey(key: IDBValidKey | IDBKeyRange): IDBRequest<IDBValidKey | undefined>;
9313 * Opens a cursor over the records matching query, ordered by direction. If query is null, all records in index are matched.
9315 * If successful, request's result will be an IDBCursorWithValue, or null if there were no matching records.
9317 openCursor(query?: IDBValidKey | IDBKeyRange | null, direction?: IDBCursorDirection): IDBRequest<IDBCursorWithValue | null>;
9319 * Opens a cursor with key only flag set over the records matching query, ordered by direction. If query is null, all records in index are matched.
9321 * If successful, request's result will be an IDBCursor, or null if there were no matching records.
9323 openKeyCursor(query?: IDBValidKey | IDBKeyRange | null, direction?: IDBCursorDirection): IDBRequest<IDBCursor | null>;
9326 declare var IDBIndex: {
9327 prototype: IDBIndex;
9331 /** A key range can be a single value or a range with upper and lower bounds or endpoints. If the key range has both upper and lower bounds, then it is bounded; if it has no bounds, it is unbounded. A bounded key range can either be open (the endpoints are excluded) or closed (the endpoints are included). To retrieve all keys within a certain range, you can use the following code constructs: */
9332 interface IDBKeyRange {
9334 * Returns lower bound, or undefined if none.
9336 readonly lower: any;
9338 * Returns true if the lower open flag is set, and false otherwise.
9340 readonly lowerOpen: boolean;
9342 * Returns upper bound, or undefined if none.
9344 readonly upper: any;
9346 * Returns true if the upper open flag is set, and false otherwise.
9348 readonly upperOpen: boolean;
9350 * Returns true if key is included in the range, and false otherwise.
9352 includes(key: any): boolean;
9355 declare var IDBKeyRange: {
9356 prototype: IDBKeyRange;
9359 * Returns a new IDBKeyRange spanning from lower to upper. If lowerOpen is true, lower is not included in the range. If upperOpen is true, upper is not included in the range.
9361 bound(lower: any, upper: any, lowerOpen?: boolean, upperOpen?: boolean): IDBKeyRange;
9363 * Returns a new IDBKeyRange starting at key with no upper bound. If open is true, key is not included in the range.
9365 lowerBound(lower: any, open?: boolean): IDBKeyRange;
9367 * Returns a new IDBKeyRange spanning only key.
9369 only(value: any): IDBKeyRange;
9371 * Returns a new IDBKeyRange with no lower bound and ending at key. If open is true, key is not included in the range.
9373 upperBound(upper: any, open?: boolean): IDBKeyRange;
9376 /** This example shows a variety of different uses of object stores, from updating the data structure with IDBObjectStore.createIndex inside an onupgradeneeded function, to adding a new item to our object store with IDBObjectStore.add. For a full working example, see our To-do Notifications app (view example live.) */
9377 interface IDBObjectStore {
9379 * Returns true if the store has a key generator, and false otherwise.
9381 readonly autoIncrement: boolean;
9383 * Returns a list of the names of indexes in the store.
9385 readonly indexNames: DOMStringList;
9387 * Returns the key path of the store, or null if none.
9389 readonly keyPath: string | string[];
9391 * Returns the name of the store.
9395 * Returns the associated transaction.
9397 readonly transaction: IDBTransaction;
9399 * Adds or updates a record in store with the given value and key.
9401 * If the store uses in-line keys and key is specified a "DataError" DOMException will be thrown.
9403 * If put() is used, any existing record with the key will be replaced. If add() is used, and if a record with the key already exists the request will fail, with request's error set to a "ConstraintError" DOMException.
9405 * If successful, request's result will be the record's key.
9407 add(value: any, key?: IDBValidKey): IDBRequest<IDBValidKey>;
9409 * Deletes all records in store.
9411 * If successful, request's result will be undefined.
9413 clear(): IDBRequest<undefined>;
9415 * Retrieves the number of records matching the given key or key range in query.
9417 * If successful, request's result will be the count.
9419 count(key?: IDBValidKey | IDBKeyRange): IDBRequest<number>;
9421 * Creates a new index in store with the given name, keyPath and options and returns a new IDBIndex. If the keyPath and options define constraints that cannot be satisfied with the data already in store the upgrade transaction will abort with a "ConstraintError" DOMException.
9423 * Throws an "InvalidStateError" DOMException if not called within an upgrade transaction.
9425 createIndex(name: string, keyPath: string | string[], options?: IDBIndexParameters): IDBIndex;
9427 * Deletes records in store with the given key or in the given key range in query.
9429 * If successful, request's result will be undefined.
9431 delete(key: IDBValidKey | IDBKeyRange): IDBRequest<undefined>;
9433 * Deletes the index in store with the given name.
9435 * Throws an "InvalidStateError" DOMException if not called within an upgrade transaction.
9437 deleteIndex(name: string): void;
9439 * Retrieves the value of the first record matching the given key or key range in query.
9441 * If successful, request's result will be the value, or undefined if there was no matching record.
9443 get(query: IDBValidKey | IDBKeyRange): IDBRequest<any | undefined>;
9445 * Retrieves the values of the records matching the given key or key range in query (up to count if given).
9447 * If successful, request's result will be an Array of the values.
9449 getAll(query?: IDBValidKey | IDBKeyRange | null, count?: number): IDBRequest<any[]>;
9451 * Retrieves the keys of records matching the given key or key range in query (up to count if given).
9453 * If successful, request's result will be an Array of the keys.
9455 getAllKeys(query?: IDBValidKey | IDBKeyRange | null, count?: number): IDBRequest<IDBValidKey[]>;
9457 * Retrieves the key of the first record matching the given key or key range in query.
9459 * If successful, request's result will be the key, or undefined if there was no matching record.
9461 getKey(query: IDBValidKey | IDBKeyRange): IDBRequest<IDBValidKey | undefined>;
9462 index(name: string): IDBIndex;
9464 * Opens a cursor over the records matching query, ordered by direction. If query is null, all records in store are matched.
9466 * If successful, request's result will be an IDBCursorWithValue pointing at the first matching record, or null if there were no matching records.
9468 openCursor(query?: IDBValidKey | IDBKeyRange | null, direction?: IDBCursorDirection): IDBRequest<IDBCursorWithValue | null>;
9470 * Opens a cursor with key only flag set over the records matching query, ordered by direction. If query is null, all records in store are matched.
9472 * If successful, request's result will be an IDBCursor pointing at the first matching record, or null if there were no matching records.
9474 openKeyCursor(query?: IDBValidKey | IDBKeyRange | null, direction?: IDBCursorDirection): IDBRequest<IDBCursor | null>;
9476 * Adds or updates a record in store with the given value and key.
9478 * If the store uses in-line keys and key is specified a "DataError" DOMException will be thrown.
9480 * If put() is used, any existing record with the key will be replaced. If add() is used, and if a record with the key already exists the request will fail, with request's error set to a "ConstraintError" DOMException.
9482 * If successful, request's result will be the record's key.
9484 put(value: any, key?: IDBValidKey): IDBRequest<IDBValidKey>;
9487 declare var IDBObjectStore: {
9488 prototype: IDBObjectStore;
9489 new(): IDBObjectStore;
9492 interface IDBOpenDBRequestEventMap extends IDBRequestEventMap {
9494 "upgradeneeded": IDBVersionChangeEvent;
9497 /** Also inherits methods from its parents IDBRequest and EventTarget. */
9498 interface IDBOpenDBRequest extends IDBRequest<IDBDatabase> {
9499 onblocked: ((this: IDBOpenDBRequest, ev: Event) => any) | null;
9500 onupgradeneeded: ((this: IDBOpenDBRequest, ev: IDBVersionChangeEvent) => any) | null;
9501 addEventListener<K extends keyof IDBOpenDBRequestEventMap>(type: K, listener: (this: IDBOpenDBRequest, ev: IDBOpenDBRequestEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9502 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9503 removeEventListener<K extends keyof IDBOpenDBRequestEventMap>(type: K, listener: (this: IDBOpenDBRequest, ev: IDBOpenDBRequestEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9504 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9507 declare var IDBOpenDBRequest: {
9508 prototype: IDBOpenDBRequest;
9509 new(): IDBOpenDBRequest;
9512 interface IDBRequestEventMap {
9517 /** The request object does not initially contain any information about the result of the operation, but once information becomes available, an event is fired on the request, and the information becomes available through the properties of the IDBRequest instance. */
9518 interface IDBRequest<T = any> extends EventTarget {
9520 * When a request is completed, returns the error (a DOMException), or null if the request succeeded. Throws a "InvalidStateError" DOMException if the request is still pending.
9522 readonly error: DOMException | null;
9523 onerror: ((this: IDBRequest<T>, ev: Event) => any) | null;
9524 onsuccess: ((this: IDBRequest<T>, ev: Event) => any) | null;
9526 * Returns "pending" until a request is complete, then returns "done".
9528 readonly readyState: IDBRequestReadyState;
9530 * When a request is completed, returns the result, or undefined if the request failed. Throws a "InvalidStateError" DOMException if the request is still pending.
9534 * Returns the IDBObjectStore, IDBIndex, or IDBCursor the request was made against, or null if is was an open request.
9536 readonly source: IDBObjectStore | IDBIndex | IDBCursor;
9538 * Returns the IDBTransaction the request was made within. If this as an open request, then it returns an upgrade transaction while it is running, or null otherwise.
9540 readonly transaction: IDBTransaction | null;
9541 addEventListener<K extends keyof IDBRequestEventMap>(type: K, listener: (this: IDBRequest<T>, ev: IDBRequestEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9542 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9543 removeEventListener<K extends keyof IDBRequestEventMap>(type: K, listener: (this: IDBRequest<T>, ev: IDBRequestEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9544 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9547 declare var IDBRequest: {
9548 prototype: IDBRequest;
9552 interface IDBTransactionEventMap {
9558 interface IDBTransaction extends EventTarget {
9560 * Returns the transaction's connection.
9562 readonly db: IDBDatabase;
9564 * If the transaction was aborted, returns the error (a DOMException) providing the reason.
9566 readonly error: DOMException;
9568 * Returns the mode the transaction was created with ("readonly" or "readwrite"), or "versionchange" for an upgrade transaction.
9570 readonly mode: IDBTransactionMode;
9572 * Returns a list of the names of object stores in the transaction's scope. For an upgrade transaction this is all object stores in the database.
9574 readonly objectStoreNames: DOMStringList;
9575 onabort: ((this: IDBTransaction, ev: Event) => any) | null;
9576 oncomplete: ((this: IDBTransaction, ev: Event) => any) | null;
9577 onerror: ((this: IDBTransaction, ev: Event) => any) | null;
9579 * Aborts the transaction. All pending requests will fail with a "AbortError" DOMException and all changes made to the database will be reverted.
9583 * Returns an IDBObjectStore in the transaction's scope.
9585 objectStore(name: string): IDBObjectStore;
9586 addEventListener<K extends keyof IDBTransactionEventMap>(type: K, listener: (this: IDBTransaction, ev: IDBTransactionEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9587 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9588 removeEventListener<K extends keyof IDBTransactionEventMap>(type: K, listener: (this: IDBTransaction, ev: IDBTransactionEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9589 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9592 declare var IDBTransaction: {
9593 prototype: IDBTransaction;
9594 new(): IDBTransaction;
9597 /** This IndexedDB API interface indicates that the version of the database has changed, as the result of an IDBOpenDBRequest.onupgradeneeded event handler function. */
9598 interface IDBVersionChangeEvent extends Event {
9599 readonly newVersion: number | null;
9600 readonly oldVersion: number;
9603 declare var IDBVersionChangeEvent: {
9604 prototype: IDBVersionChangeEvent;
9605 new(type: string, eventInitDict?: IDBVersionChangeEventInit): IDBVersionChangeEvent;
9608 /** The IIRFilterNode interface of the Web Audio API is a AudioNode processor which implements a general infinite impulse response (IIR) filter; this type of filter can be used to implement tone control devices and graphic equalizers as well. It lets the parameters of the filter response be specified, so that it can be tuned as needed. */
9609 interface IIRFilterNode extends AudioNode {
9610 getFrequencyResponse(frequencyHz: Float32Array, magResponse: Float32Array, phaseResponse: Float32Array): void;
9613 declare var IIRFilterNode: {
9614 prototype: IIRFilterNode;
9615 new(context: BaseAudioContext, options: IIRFilterOptions): IIRFilterNode;
9618 interface ImageBitmap {
9620 * Returns the intrinsic height of the image, in CSS pixels.
9622 readonly height: number;
9624 * Returns the intrinsic width of the image, in CSS pixels.
9626 readonly width: number;
9628 * Releases imageBitmap's underlying bitmap data.
9633 declare var ImageBitmap: {
9634 prototype: ImageBitmap;
9638 interface ImageBitmapRenderingContext {
9640 * Returns the canvas element that the context is bound to.
9642 readonly canvas: HTMLCanvasElement | OffscreenCanvas;
9644 * Transfers the underlying bitmap data from imageBitmap to context, and the bitmap becomes the contents of the canvas element to which context is bound.
9646 transferFromImageBitmap(bitmap: ImageBitmap | null): void;
9649 declare var ImageBitmapRenderingContext: {
9650 prototype: ImageBitmapRenderingContext;
9651 new(): ImageBitmapRenderingContext;
9654 /** The underlying pixel data of an area of a <canvas> element. It is created using the ImageData() constructor or creator methods on the CanvasRenderingContext2D object associated with a canvas: createImageData() and getImageData(). It can also be used to set a part of the canvas by using putImageData(). */
9655 interface ImageData {
9657 * Returns the one-dimensional array containing the data in RGBA order, as integers in the range 0 to 255.
9659 readonly data: Uint8ClampedArray;
9661 * Returns the actual dimensions of the data in the ImageData object, in pixels.
9663 readonly height: number;
9665 * Returns the actual dimensions of the data in the ImageData object, in pixels.
9667 readonly width: number;
9670 declare var ImageData: {
9671 prototype: ImageData;
9672 new(sw: number, sh: number): ImageData;
9673 new(data: Uint8ClampedArray, sw: number, sh?: number): ImageData;
9676 interface InnerHTML {
9680 interface InputDeviceInfo extends MediaDeviceInfo {
9681 getCapabilities(): MediaTrackCapabilities;
9684 declare var InputDeviceInfo: {
9685 prototype: InputDeviceInfo;
9686 new(): InputDeviceInfo;
9689 interface InputEvent extends UIEvent {
9690 readonly data: string | null;
9691 readonly inputType: string;
9692 readonly isComposing: boolean;
9695 declare var InputEvent: {
9696 prototype: InputEvent;
9697 new(type: string, eventInitDict?: InputEventInit): InputEvent;
9700 /** provides a way to asynchronously observe changes in the intersection of a target element with an ancestor element or with a top-level document's viewport. */
9701 interface IntersectionObserver {
9702 readonly root: Element | Document | null;
9703 readonly rootMargin: string;
9704 readonly thresholds: ReadonlyArray<number>;
9706 observe(target: Element): void;
9707 takeRecords(): IntersectionObserverEntry[];
9708 unobserve(target: Element): void;
9711 declare var IntersectionObserver: {
9712 prototype: IntersectionObserver;
9713 new(callback: IntersectionObserverCallback, options?: IntersectionObserverInit): IntersectionObserver;
9716 /** This Intersection Observer API interface describes the intersection between the target element and its root container at a specific moment of transition. */
9717 interface IntersectionObserverEntry {
9718 readonly boundingClientRect: DOMRectReadOnly;
9719 readonly intersectionRatio: number;
9720 readonly intersectionRect: DOMRectReadOnly;
9721 readonly isIntersecting: boolean;
9722 readonly rootBounds: DOMRectReadOnly | null;
9723 readonly target: Element;
9724 readonly time: number;
9727 declare var IntersectionObserverEntry: {
9728 prototype: IntersectionObserverEntry;
9729 new(intersectionObserverEntryInit: IntersectionObserverEntryInit): IntersectionObserverEntry;
9732 /** KeyboardEvent objects describe a user interaction with the keyboard; each event describes a single interaction between the user and a key (or combination of a key with modifier keys) on the keyboard. */
9733 interface KeyboardEvent extends UIEvent {
9734 readonly altKey: boolean;
9738 readonly charCode: number;
9739 readonly code: string;
9740 readonly ctrlKey: boolean;
9741 readonly isComposing: boolean;
9742 readonly key: string;
9744 readonly keyCode: number;
9745 readonly location: number;
9746 readonly metaKey: boolean;
9747 readonly repeat: boolean;
9748 readonly shiftKey: boolean;
9749 getModifierState(keyArg: string): boolean;
9750 readonly DOM_KEY_LOCATION_LEFT: number;
9751 readonly DOM_KEY_LOCATION_NUMPAD: number;
9752 readonly DOM_KEY_LOCATION_RIGHT: number;
9753 readonly DOM_KEY_LOCATION_STANDARD: number;
9756 declare var KeyboardEvent: {
9757 prototype: KeyboardEvent;
9758 new(type: string, eventInitDict?: KeyboardEventInit): KeyboardEvent;
9759 readonly DOM_KEY_LOCATION_LEFT: number;
9760 readonly DOM_KEY_LOCATION_NUMPAD: number;
9761 readonly DOM_KEY_LOCATION_RIGHT: number;
9762 readonly DOM_KEY_LOCATION_STANDARD: number;
9765 interface KeyframeEffect extends AnimationEffect {
9766 composite: CompositeOperation;
9767 iterationComposite: IterationCompositeOperation;
9768 target: Element | null;
9769 getKeyframes(): ComputedKeyframe[];
9770 setKeyframes(keyframes: Keyframe[] | PropertyIndexedKeyframes | null): void;
9773 declare var KeyframeEffect: {
9774 prototype: KeyframeEffect;
9775 new(target: Element | null, keyframes: Keyframe[] | PropertyIndexedKeyframes | null, options?: number | KeyframeEffectOptions): KeyframeEffect;
9776 new(source: KeyframeEffect): KeyframeEffect;
9779 interface LinkStyle {
9780 readonly sheet: CSSStyleSheet | null;
9783 interface ListeningStateChangedEvent extends Event {
9784 readonly label: string;
9785 readonly state: ListeningState;
9788 declare var ListeningStateChangedEvent: {
9789 prototype: ListeningStateChangedEvent;
9790 new(): ListeningStateChangedEvent;
9793 /** The location (URL) of the object it is linked to. Changes done on it are reflected on the object it relates to. Both the Document and Window interface have such a linked Location, accessible via Document.location and Window.location respectively. */
9794 interface Location {
9796 * Returns a DOMStringList object listing the origins of the ancestor browsing contexts, from the parent browsing context to the top-level browsing context.
9798 readonly ancestorOrigins: DOMStringList;
9800 * Returns the Location object's URL's fragment (includes leading "#" if non-empty).
9802 * Can be set, to navigate to the same URL with a changed fragment (ignores leading "#").
9806 * Returns the Location object's URL's host and port (if different from the default port for the scheme).
9808 * Can be set, to navigate to the same URL with a changed host and port.
9812 * Returns the Location object's URL's host.
9814 * Can be set, to navigate to the same URL with a changed host.
9818 * Returns the Location object's URL.
9820 * Can be set, to navigate to the given URL.
9825 * Returns the Location object's URL's origin.
9827 readonly origin: string;
9829 * Returns the Location object's URL's path.
9831 * Can be set, to navigate to the same URL with a changed path.
9835 * Returns the Location object's URL's port.
9837 * Can be set, to navigate to the same URL with a changed port.
9841 * Returns the Location object's URL's scheme.
9843 * Can be set, to navigate to the same URL with a changed scheme.
9847 * Returns the Location object's URL's query (includes leading "?" if non-empty).
9849 * Can be set, to navigate to the same URL with a changed query (ignores leading "?").
9853 * Navigates to the given URL.
9855 assign(url: string): void;
9857 * Reloads the current page.
9861 reload(forcedReload: boolean): void;
9863 * Removes the current page from the session history and navigates to the given URL.
9865 replace(url: string): void;
9868 declare var Location: {
9869 prototype: Location;
9873 interface MSAssertion {
9874 readonly id: string;
9875 readonly type: MSCredentialType;
9878 declare var MSAssertion: {
9879 prototype: MSAssertion;
9883 interface MSBlobBuilder {
9884 append(data: any, endings?: string): void;
9885 getBlob(contentType?: string): Blob;
9888 declare var MSBlobBuilder: {
9889 prototype: MSBlobBuilder;
9890 new(): MSBlobBuilder;
9893 interface MSFIDOCredentialAssertion extends MSAssertion {
9894 readonly algorithm: string | Algorithm;
9895 readonly attestation: any;
9896 readonly publicKey: string;
9897 readonly transportHints: MSTransportType[];
9900 declare var MSFIDOCredentialAssertion: {
9901 prototype: MSFIDOCredentialAssertion;
9902 new(): MSFIDOCredentialAssertion;
9905 interface MSFIDOSignature {
9906 readonly authnrData: string;
9907 readonly clientData: string;
9908 readonly signature: string;
9911 declare var MSFIDOSignature: {
9912 prototype: MSFIDOSignature;
9913 new(): MSFIDOSignature;
9916 interface MSFIDOSignatureAssertion extends MSAssertion {
9917 readonly signature: MSFIDOSignature;
9920 declare var MSFIDOSignatureAssertion: {
9921 prototype: MSFIDOSignatureAssertion;
9922 new(): MSFIDOSignatureAssertion;
9925 interface MSFileSaver {
9926 msSaveBlob(blob: any, defaultName?: string): boolean;
9927 msSaveOrOpenBlob(blob: any, defaultName?: string): boolean;
9930 interface MSGesture {
9932 addPointer(pointerId: number): void;
9936 declare var MSGesture: {
9937 prototype: MSGesture;
9941 /** The MSGestureEvent is a proprietary interface specific to Internet Explorer and Microsoft Edge which represents events that occur due to touch gestures. Events using this interface include MSGestureStart, MSGestureEnd, MSGestureTap, MSGestureHold, MSGestureChange, and MSInertiaStart. */
9942 interface MSGestureEvent extends UIEvent {
9943 readonly clientX: number;
9944 readonly clientY: number;
9945 readonly expansion: number;
9946 readonly gestureObject: any;
9947 readonly hwTimestamp: number;
9948 readonly offsetX: number;
9949 readonly offsetY: number;
9950 readonly rotation: number;
9951 readonly scale: number;
9952 readonly screenX: number;
9953 readonly screenY: number;
9954 readonly translationX: number;
9955 readonly translationY: number;
9956 readonly velocityAngular: number;
9957 readonly velocityExpansion: number;
9958 readonly velocityX: number;
9959 readonly velocityY: number;
9960 initGestureEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, viewArg: Window, detailArg: number, screenXArg: number, screenYArg: number, clientXArg: number, clientYArg: number, offsetXArg: number, offsetYArg: number, translationXArg: number, translationYArg: number, scaleArg: number, expansionArg: number, rotationArg: number, velocityXArg: number, velocityYArg: number, velocityExpansionArg: number, velocityAngularArg: number, hwTimestampArg: number): void;
9961 readonly MSGESTURE_FLAG_BEGIN: number;
9962 readonly MSGESTURE_FLAG_CANCEL: number;
9963 readonly MSGESTURE_FLAG_END: number;
9964 readonly MSGESTURE_FLAG_INERTIA: number;
9965 readonly MSGESTURE_FLAG_NONE: number;
9968 declare var MSGestureEvent: {
9969 prototype: MSGestureEvent;
9970 new(): MSGestureEvent;
9971 readonly MSGESTURE_FLAG_BEGIN: number;
9972 readonly MSGESTURE_FLAG_CANCEL: number;
9973 readonly MSGESTURE_FLAG_END: number;
9974 readonly MSGESTURE_FLAG_INERTIA: number;
9975 readonly MSGESTURE_FLAG_NONE: number;
9978 /** The msGraphicsTrust() constructor returns an object that provides properties for info on protected video playback. */
9979 interface MSGraphicsTrust {
9980 readonly constrictionActive: boolean;
9981 readonly status: string;
9984 declare var MSGraphicsTrust: {
9985 prototype: MSGraphicsTrust;
9986 new(): MSGraphicsTrust;
9989 interface MSInputMethodContextEventMap {
9990 "MSCandidateWindowHide": Event;
9991 "MSCandidateWindowShow": Event;
9992 "MSCandidateWindowUpdate": Event;
9995 interface MSInputMethodContext extends EventTarget {
9996 readonly compositionEndOffset: number;
9997 readonly compositionStartOffset: number;
9998 oncandidatewindowhide: ((this: MSInputMethodContext, ev: Event) => any) | null;
9999 oncandidatewindowshow: ((this: MSInputMethodContext, ev: Event) => any) | null;
10000 oncandidatewindowupdate: ((this: MSInputMethodContext, ev: Event) => any) | null;
10001 readonly target: HTMLElement;
10002 getCandidateWindowClientRect(): ClientRect;
10003 getCompositionAlternatives(): string[];
10004 hasComposition(): boolean;
10005 isCandidateWindowVisible(): boolean;
10006 addEventListener<K extends keyof MSInputMethodContextEventMap>(type: K, listener: (this: MSInputMethodContext, ev: MSInputMethodContextEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10007 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10008 removeEventListener<K extends keyof MSInputMethodContextEventMap>(type: K, listener: (this: MSInputMethodContext, ev: MSInputMethodContextEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10009 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10012 declare var MSInputMethodContext: {
10013 prototype: MSInputMethodContext;
10014 new(): MSInputMethodContext;
10017 interface MSMediaKeyError {
10018 readonly code: number;
10019 readonly systemCode: number;
10020 readonly MS_MEDIA_KEYERR_CLIENT: number;
10021 readonly MS_MEDIA_KEYERR_DOMAIN: number;
10022 readonly MS_MEDIA_KEYERR_HARDWARECHANGE: number;
10023 readonly MS_MEDIA_KEYERR_OUTPUT: number;
10024 readonly MS_MEDIA_KEYERR_SERVICE: number;
10025 readonly MS_MEDIA_KEYERR_UNKNOWN: number;
10028 declare var MSMediaKeyError: {
10029 prototype: MSMediaKeyError;
10030 new(): MSMediaKeyError;
10031 readonly MS_MEDIA_KEYERR_CLIENT: number;
10032 readonly MS_MEDIA_KEYERR_DOMAIN: number;
10033 readonly MS_MEDIA_KEYERR_HARDWARECHANGE: number;
10034 readonly MS_MEDIA_KEYERR_OUTPUT: number;
10035 readonly MS_MEDIA_KEYERR_SERVICE: number;
10036 readonly MS_MEDIA_KEYERR_UNKNOWN: number;
10039 interface MSMediaKeyMessageEvent extends Event {
10040 readonly destinationURL: string | null;
10041 readonly message: Uint8Array;
10044 declare var MSMediaKeyMessageEvent: {
10045 prototype: MSMediaKeyMessageEvent;
10046 new(): MSMediaKeyMessageEvent;
10049 interface MSMediaKeyNeededEvent extends Event {
10050 readonly initData: Uint8Array | null;
10053 declare var MSMediaKeyNeededEvent: {
10054 prototype: MSMediaKeyNeededEvent;
10055 new(): MSMediaKeyNeededEvent;
10058 interface MSMediaKeySession extends EventTarget {
10059 readonly error: MSMediaKeyError | null;
10060 readonly keySystem: string;
10061 readonly sessionId: string;
10063 update(key: Uint8Array): void;
10066 declare var MSMediaKeySession: {
10067 prototype: MSMediaKeySession;
10068 new(): MSMediaKeySession;
10071 interface MSMediaKeys {
10072 readonly keySystem: string;
10073 createSession(type: string, initData: Uint8Array, cdmData?: Uint8Array | null): MSMediaKeySession;
10076 declare var MSMediaKeys: {
10077 prototype: MSMediaKeys;
10078 new(keySystem: string): MSMediaKeys;
10079 isTypeSupported(keySystem: string, type?: string | null): boolean;
10080 isTypeSupportedWithFeatures(keySystem: string, type?: string | null): string;
10083 interface MSNavigatorDoNotTrack {
10084 confirmSiteSpecificTrackingException(args: ConfirmSiteSpecificExceptionsInformation): boolean;
10085 confirmWebWideTrackingException(args: ExceptionInformation): boolean;
10086 removeSiteSpecificTrackingException(args: ExceptionInformation): void;
10087 removeWebWideTrackingException(args: ExceptionInformation): void;
10088 storeSiteSpecificTrackingException(args: StoreSiteSpecificExceptionsInformation): void;
10089 storeWebWideTrackingException(args: StoreExceptionsInformation): void;
10092 interface MSPointerEvent extends MouseEvent {
10093 readonly currentPoint: any;
10094 readonly height: number;
10095 readonly hwTimestamp: number;
10096 readonly intermediatePoints: any;
10097 readonly isPrimary: boolean;
10098 readonly pointerId: number;
10099 readonly pointerType: any;
10100 readonly pressure: number;
10101 readonly rotation: number;
10102 readonly tiltX: number;
10103 readonly tiltY: number;
10104 readonly width: number;
10105 getCurrentPoint(element: Element): void;
10106 getIntermediatePoints(element: Element): void;
10107 initPointerEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, viewArg: Window, detailArg: number, screenXArg: number, screenYArg: number, clientXArg: number, clientYArg: number, ctrlKeyArg: boolean, altKeyArg: boolean, shiftKeyArg: boolean, metaKeyArg: boolean, buttonArg: number, relatedTargetArg: EventTarget, offsetXArg: number, offsetYArg: number, widthArg: number, heightArg: number, pressure: number, rotation: number, tiltX: number, tiltY: number, pointerIdArg: number, pointerType: any, hwTimestampArg: number, isPrimary: boolean): void;
10110 declare var MSPointerEvent: {
10111 prototype: MSPointerEvent;
10112 new(typeArg: string, eventInitDict?: PointerEventInit): MSPointerEvent;
10115 interface MSStream {
10116 readonly type: string;
10118 msDetachStream(): any;
10121 declare var MSStream: {
10122 prototype: MSStream;
10126 /** The MediaDevicesInfo interface contains information that describes a single media input or output device. */
10127 interface MediaDeviceInfo {
10128 readonly deviceId: string;
10129 readonly groupId: string;
10130 readonly kind: MediaDeviceKind;
10131 readonly label: string;
10135 declare var MediaDeviceInfo: {
10136 prototype: MediaDeviceInfo;
10137 new(): MediaDeviceInfo;
10140 interface MediaDevicesEventMap {
10141 "devicechange": Event;
10144 /** Provides access to connected media input devices like cameras and microphones, as well as screen sharing. In essence, it lets you obtain access to any hardware source of media data. */
10145 interface MediaDevices extends EventTarget {
10146 ondevicechange: ((this: MediaDevices, ev: Event) => any) | null;
10147 enumerateDevices(): Promise<MediaDeviceInfo[]>;
10148 getSupportedConstraints(): MediaTrackSupportedConstraints;
10149 getUserMedia(constraints?: MediaStreamConstraints): Promise<MediaStream>;
10150 addEventListener<K extends keyof MediaDevicesEventMap>(type: K, listener: (this: MediaDevices, ev: MediaDevicesEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10151 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10152 removeEventListener<K extends keyof MediaDevicesEventMap>(type: K, listener: (this: MediaDevices, ev: MediaDevicesEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10153 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10156 declare var MediaDevices: {
10157 prototype: MediaDevices;
10158 new(): MediaDevices;
10161 /** A MediaElementSourceNode has no inputs and exactly one output, and is created using the AudioContext.createMediaElementSource method. The amount of channels in the output equals the number of channels of the audio referenced by the HTMLMediaElement used in the creation of the node, or is 1 if the HTMLMediaElement has no audio. */
10162 interface MediaElementAudioSourceNode extends AudioNode {
10163 readonly mediaElement: HTMLMediaElement;
10166 declare var MediaElementAudioSourceNode: {
10167 prototype: MediaElementAudioSourceNode;
10168 new(context: AudioContext, options: MediaElementAudioSourceOptions): MediaElementAudioSourceNode;
10171 interface MediaEncryptedEvent extends Event {
10172 readonly initData: ArrayBuffer | null;
10173 readonly initDataType: string;
10176 declare var MediaEncryptedEvent: {
10177 prototype: MediaEncryptedEvent;
10178 new(type: string, eventInitDict?: MediaEncryptedEventInit): MediaEncryptedEvent;
10181 /** An error which occurred while handling media in an HTML media element based on HTMLMediaElement, such as <audio> or <video>. */
10182 interface MediaError {
10183 readonly code: number;
10184 readonly message: string;
10185 readonly MEDIA_ERR_ABORTED: number;
10186 readonly MEDIA_ERR_DECODE: number;
10187 readonly MEDIA_ERR_NETWORK: number;
10188 readonly MEDIA_ERR_SRC_NOT_SUPPORTED: number;
10191 declare var MediaError: {
10192 prototype: MediaError;
10194 readonly MEDIA_ERR_ABORTED: number;
10195 readonly MEDIA_ERR_DECODE: number;
10196 readonly MEDIA_ERR_NETWORK: number;
10197 readonly MEDIA_ERR_SRC_NOT_SUPPORTED: number;
10200 /** This EncryptedMediaExtensions API interface contains the content and related data when the content decryption module generates a message for the session. */
10201 interface MediaKeyMessageEvent extends Event {
10202 readonly message: ArrayBuffer;
10203 readonly messageType: MediaKeyMessageType;
10206 declare var MediaKeyMessageEvent: {
10207 prototype: MediaKeyMessageEvent;
10208 new(type: string, eventInitDict: MediaKeyMessageEventInit): MediaKeyMessageEvent;
10211 interface MediaKeySessionEventMap {
10212 "keystatuseschange": Event;
10213 "message": MediaKeyMessageEvent;
10216 /** This EncryptedMediaExtensions API interface represents a context for message exchange with a content decryption module (CDM). */
10217 interface MediaKeySession extends EventTarget {
10218 readonly closed: Promise<void>;
10219 readonly expiration: number;
10220 readonly keyStatuses: MediaKeyStatusMap;
10221 onkeystatuseschange: ((this: MediaKeySession, ev: Event) => any) | null;
10222 onmessage: ((this: MediaKeySession, ev: MediaKeyMessageEvent) => any) | null;
10223 readonly sessionId: string;
10224 close(): Promise<void>;
10225 generateRequest(initDataType: string, initData: BufferSource): Promise<void>;
10226 load(sessionId: string): Promise<boolean>;
10227 remove(): Promise<void>;
10228 update(response: BufferSource): Promise<void>;
10229 addEventListener<K extends keyof MediaKeySessionEventMap>(type: K, listener: (this: MediaKeySession, ev: MediaKeySessionEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10230 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10231 removeEventListener<K extends keyof MediaKeySessionEventMap>(type: K, listener: (this: MediaKeySession, ev: MediaKeySessionEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10232 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10235 declare var MediaKeySession: {
10236 prototype: MediaKeySession;
10237 new(): MediaKeySession;
10240 /** This EncryptedMediaExtensions API interface is a read-only map of media key statuses by key IDs. */
10241 interface MediaKeyStatusMap {
10242 readonly size: number;
10243 get(keyId: BufferSource): MediaKeyStatus | undefined;
10244 has(keyId: BufferSource): boolean;
10245 forEach(callbackfn: (value: MediaKeyStatus, key: BufferSource, parent: MediaKeyStatusMap) => void, thisArg?: any): void;
10248 declare var MediaKeyStatusMap: {
10249 prototype: MediaKeyStatusMap;
10250 new(): MediaKeyStatusMap;
10253 /** This EncryptedMediaExtensions API interface provides access to a Key System for decryption and/or a content protection provider. You can request an instance of this object using the Navigator.requestMediaKeySystemAccess method. */
10254 interface MediaKeySystemAccess {
10255 readonly keySystem: string;
10256 createMediaKeys(): Promise<MediaKeys>;
10257 getConfiguration(): MediaKeySystemConfiguration;
10260 declare var MediaKeySystemAccess: {
10261 prototype: MediaKeySystemAccess;
10262 new(): MediaKeySystemAccess;
10265 /** This EncryptedMediaExtensions API interface the represents a set of keys that an associated HTMLMediaElement can use for decryption of media data during playback. */
10266 interface MediaKeys {
10267 createSession(sessionType?: MediaKeySessionType): MediaKeySession;
10268 setServerCertificate(serverCertificate: BufferSource): Promise<boolean>;
10271 declare var MediaKeys: {
10272 prototype: MediaKeys;
10276 interface MediaList {
10277 readonly length: number;
10279 toString(): string;
10280 appendMedium(medium: string): void;
10281 deleteMedium(medium: string): void;
10282 item(index: number): string | null;
10283 [index: number]: string;
10286 declare var MediaList: {
10287 prototype: MediaList;
10291 interface MediaQueryListEventMap {
10292 "change": MediaQueryListEvent;
10295 /** Stores information on a media query applied to a document, and handles sending notifications to listeners when the media query state change (i.e. when the media query test starts or stops evaluating to true). */
10296 interface MediaQueryList extends EventTarget {
10297 readonly matches: boolean;
10298 readonly media: string;
10299 onchange: ((this: MediaQueryList, ev: MediaQueryListEvent) => any) | null;
10301 addListener(listener: ((this: MediaQueryList, ev: MediaQueryListEvent) => any) | null): void;
10303 removeListener(listener: ((this: MediaQueryList, ev: MediaQueryListEvent) => any) | null): void;
10304 addEventListener<K extends keyof MediaQueryListEventMap>(type: K, listener: (this: MediaQueryList, ev: MediaQueryListEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10305 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10306 removeEventListener<K extends keyof MediaQueryListEventMap>(type: K, listener: (this: MediaQueryList, ev: MediaQueryListEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10307 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10310 declare var MediaQueryList: {
10311 prototype: MediaQueryList;
10312 new(): MediaQueryList;
10315 interface MediaQueryListEvent extends Event {
10316 readonly matches: boolean;
10317 readonly media: string;
10320 declare var MediaQueryListEvent: {
10321 prototype: MediaQueryListEvent;
10322 new(type: string, eventInitDict?: MediaQueryListEventInit): MediaQueryListEvent;
10325 interface MediaSourceEventMap {
10326 "sourceclose": Event;
10327 "sourceended": Event;
10328 "sourceopen": Event;
10331 /** This Media Source Extensions API interface represents a source of media data for an HTMLMediaElement object. A MediaSource object can be attached to a HTMLMediaElement to be played in the user agent. */
10332 interface MediaSource extends EventTarget {
10333 readonly activeSourceBuffers: SourceBufferList;
10335 onsourceclose: ((this: MediaSource, ev: Event) => any) | null;
10336 onsourceended: ((this: MediaSource, ev: Event) => any) | null;
10337 onsourceopen: ((this: MediaSource, ev: Event) => any) | null;
10338 readonly readyState: ReadyState;
10339 readonly sourceBuffers: SourceBufferList;
10340 addSourceBuffer(type: string): SourceBuffer;
10341 clearLiveSeekableRange(): void;
10342 endOfStream(error?: EndOfStreamError): void;
10343 removeSourceBuffer(sourceBuffer: SourceBuffer): void;
10344 setLiveSeekableRange(start: number, end: number): void;
10345 addEventListener<K extends keyof MediaSourceEventMap>(type: K, listener: (this: MediaSource, ev: MediaSourceEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10346 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10347 removeEventListener<K extends keyof MediaSourceEventMap>(type: K, listener: (this: MediaSource, ev: MediaSourceEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10348 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10351 declare var MediaSource: {
10352 prototype: MediaSource;
10353 new(): MediaSource;
10354 isTypeSupported(type: string): boolean;
10357 interface MediaStreamEventMap {
10358 "addtrack": MediaStreamTrackEvent;
10359 "removetrack": MediaStreamTrackEvent;
10362 /** A stream of media content. A stream consists of several tracks such as video or audio tracks. Each track is specified as an instance of MediaStreamTrack. */
10363 interface MediaStream extends EventTarget {
10364 readonly active: boolean;
10365 readonly id: string;
10366 onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
10367 onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
10368 addTrack(track: MediaStreamTrack): void;
10369 clone(): MediaStream;
10370 getAudioTracks(): MediaStreamTrack[];
10371 getTrackById(trackId: string): MediaStreamTrack | null;
10372 getTracks(): MediaStreamTrack[];
10373 getVideoTracks(): MediaStreamTrack[];
10374 removeTrack(track: MediaStreamTrack): void;
10375 addEventListener<K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10376 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10377 removeEventListener<K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10378 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10381 declare var MediaStream: {
10382 prototype: MediaStream;
10383 new(): MediaStream;
10384 new(stream: MediaStream): MediaStream;
10385 new(tracks: MediaStreamTrack[]): MediaStream;
10388 interface MediaStreamAudioDestinationNode extends AudioNode {
10389 readonly stream: MediaStream;
10392 declare var MediaStreamAudioDestinationNode: {
10393 prototype: MediaStreamAudioDestinationNode;
10394 new(context: AudioContext, options?: AudioNodeOptions): MediaStreamAudioDestinationNode;
10397 /** A type of AudioNode which operates as an audio source whose media is received from a MediaStream obtained using the WebRTC or Media Capture and Streams APIs. */
10398 interface MediaStreamAudioSourceNode extends AudioNode {
10399 readonly mediaStream: MediaStream;
10402 declare var MediaStreamAudioSourceNode: {
10403 prototype: MediaStreamAudioSourceNode;
10404 new(context: AudioContext, options: MediaStreamAudioSourceOptions): MediaStreamAudioSourceNode;
10407 interface MediaStreamError {
10408 readonly constraintName: string | null;
10409 readonly message: string | null;
10410 readonly name: string;
10413 declare var MediaStreamError: {
10414 prototype: MediaStreamError;
10415 new(): MediaStreamError;
10418 interface MediaStreamErrorEvent extends Event {
10419 readonly error: MediaStreamError | null;
10422 declare var MediaStreamErrorEvent: {
10423 prototype: MediaStreamErrorEvent;
10424 new(typeArg: string, eventInitDict?: MediaStreamErrorEventInit): MediaStreamErrorEvent;
10427 /** Events that occurs in relation to a MediaStream. Two events of this type can be thrown: addstream and removestream. */
10428 interface MediaStreamEvent extends Event {
10429 readonly stream: MediaStream | null;
10432 declare var MediaStreamEvent: {
10433 prototype: MediaStreamEvent;
10434 new(type: string, eventInitDict: MediaStreamEventInit): MediaStreamEvent;
10437 interface MediaStreamTrackEventMap {
10439 "isolationchange": Event;
10444 /** A single media track within a stream; typically, these are audio or video tracks, but other track types may exist as well. */
10445 interface MediaStreamTrack extends EventTarget {
10447 readonly id: string;
10448 readonly isolated: boolean;
10449 readonly kind: string;
10450 readonly label: string;
10451 readonly muted: boolean;
10452 onended: ((this: MediaStreamTrack, ev: Event) => any) | null;
10453 onisolationchange: ((this: MediaStreamTrack, ev: Event) => any) | null;
10454 onmute: ((this: MediaStreamTrack, ev: Event) => any) | null;
10455 onunmute: ((this: MediaStreamTrack, ev: Event) => any) | null;
10456 readonly readyState: MediaStreamTrackState;
10457 applyConstraints(constraints?: MediaTrackConstraints): Promise<void>;
10458 clone(): MediaStreamTrack;
10459 getCapabilities(): MediaTrackCapabilities;
10460 getConstraints(): MediaTrackConstraints;
10461 getSettings(): MediaTrackSettings;
10463 addEventListener<K extends keyof MediaStreamTrackEventMap>(type: K, listener: (this: MediaStreamTrack, ev: MediaStreamTrackEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10464 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10465 removeEventListener<K extends keyof MediaStreamTrackEventMap>(type: K, listener: (this: MediaStreamTrack, ev: MediaStreamTrackEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10466 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10469 declare var MediaStreamTrack: {
10470 prototype: MediaStreamTrack;
10471 new(): MediaStreamTrack;
10474 interface MediaStreamTrackAudioSourceNode extends AudioNode {
10477 declare var MediaStreamTrackAudioSourceNode: {
10478 prototype: MediaStreamTrackAudioSourceNode;
10479 new(context: AudioContext, options: MediaStreamTrackAudioSourceOptions): MediaStreamTrackAudioSourceNode;
10482 /** Events which indicate that a MediaStream has had tracks added to or removed from the stream through calls to Media Stream API methods. These events are sent to the stream when these changes occur. */
10483 interface MediaStreamTrackEvent extends Event {
10484 readonly track: MediaStreamTrack;
10487 declare var MediaStreamTrackEvent: {
10488 prototype: MediaStreamTrackEvent;
10489 new(type: string, eventInitDict: MediaStreamTrackEventInit): MediaStreamTrackEvent;
10492 /** This Channel Messaging API interface allows us to create a new message channel and send data through it via its two MessagePort properties. */
10493 interface MessageChannel {
10495 * Returns the first MessagePort object.
10497 readonly port1: MessagePort;
10499 * Returns the second MessagePort object.
10501 readonly port2: MessagePort;
10504 declare var MessageChannel: {
10505 prototype: MessageChannel;
10506 new(): MessageChannel;
10509 /** A message received by a target object. */
10510 interface MessageEvent<T = any> extends Event {
10512 * Returns the data of the message.
10516 * Returns the last event ID string, for server-sent events.
10518 readonly lastEventId: string;
10520 * Returns the origin of the message, for server-sent events and cross-document messaging.
10522 readonly origin: string;
10524 * Returns the MessagePort array sent with the message, for cross-document messaging and channel messaging.
10526 readonly ports: ReadonlyArray<MessagePort>;
10528 * Returns the WindowProxy of the source window, for cross-document messaging, and the MessagePort being attached, in the connect event fired at SharedWorkerGlobalScope objects.
10530 readonly source: MessageEventSource | null;
10533 declare var MessageEvent: {
10534 prototype: MessageEvent;
10535 new<T>(type: string, eventInitDict?: MessageEventInit<T>): MessageEvent<T>;
10538 interface MessagePortEventMap {
10539 "message": MessageEvent;
10540 "messageerror": MessageEvent;
10543 /** This Channel Messaging API interface represents one of the two ports of a MessageChannel, allowing messages to be sent from one port and listening out for them arriving at the other. */
10544 interface MessagePort extends EventTarget {
10545 onmessage: ((this: MessagePort, ev: MessageEvent) => any) | null;
10546 onmessageerror: ((this: MessagePort, ev: MessageEvent) => any) | null;
10548 * Disconnects the port, so that it is no longer active.
10552 * Posts a message through the channel. Objects listed in transfer are transferred, not just cloned, meaning that they are no longer usable on the sending side.
10554 * Throws a "DataCloneError" DOMException if transfer contains duplicate objects or port, or if message could not be cloned.
10556 postMessage(message: any, transfer: Transferable[]): void;
10557 postMessage(message: any, options?: PostMessageOptions): void;
10559 * Begins dispatching messages received on the port.
10562 addEventListener<K extends keyof MessagePortEventMap>(type: K, listener: (this: MessagePort, ev: MessagePortEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10563 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10564 removeEventListener<K extends keyof MessagePortEventMap>(type: K, listener: (this: MessagePort, ev: MessagePortEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10565 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10568 declare var MessagePort: {
10569 prototype: MessagePort;
10570 new(): MessagePort;
10573 /** Provides contains information about a MIME type associated with a particular plugin. NavigatorPlugins.mimeTypes returns an array of this object. */
10574 interface MimeType {
10576 * Returns the MIME type's description.
10578 readonly description: string;
10580 * Returns the Plugin object that implements this MIME type.
10582 readonly enabledPlugin: Plugin;
10584 * Returns the MIME type's typical file extensions, in a comma-separated list.
10586 readonly suffixes: string;
10588 * Returns the MIME type.
10590 readonly type: string;
10593 declare var MimeType: {
10594 prototype: MimeType;
10598 /** Returns an array of MimeType instances, each of which contains information about a supported browser plugins. This object is returned by NavigatorPlugins.mimeTypes. */
10599 interface MimeTypeArray {
10600 readonly length: number;
10601 item(index: number): MimeType | null;
10602 namedItem(name: string): MimeType | null;
10603 [index: number]: MimeType;
10606 declare var MimeTypeArray: {
10607 prototype: MimeTypeArray;
10608 new(): MimeTypeArray;
10611 /** Events that occur due to the user interacting with a pointing device (such as a mouse). Common events using this interface include click, dblclick, mouseup, mousedown. */
10612 interface MouseEvent extends UIEvent {
10613 readonly altKey: boolean;
10614 readonly button: number;
10615 readonly buttons: number;
10616 readonly clientX: number;
10617 readonly clientY: number;
10618 readonly ctrlKey: boolean;
10619 readonly metaKey: boolean;
10620 readonly movementX: number;
10621 readonly movementY: number;
10622 readonly offsetX: number;
10623 readonly offsetY: number;
10624 readonly pageX: number;
10625 readonly pageY: number;
10626 readonly relatedTarget: EventTarget | null;
10627 readonly screenX: number;
10628 readonly screenY: number;
10629 readonly shiftKey: boolean;
10630 readonly x: number;
10631 readonly y: number;
10632 getModifierState(keyArg: string): boolean;
10633 initMouseEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, viewArg: Window, detailArg: number, screenXArg: number, screenYArg: number, clientXArg: number, clientYArg: number, ctrlKeyArg: boolean, altKeyArg: boolean, shiftKeyArg: boolean, metaKeyArg: boolean, buttonArg: number, relatedTargetArg: EventTarget | null): void;
10636 declare var MouseEvent: {
10637 prototype: MouseEvent;
10638 new(type: string, eventInitDict?: MouseEventInit): MouseEvent;
10641 /** Provides event properties that are specific to modifications to the Document Object Model (DOM) hierarchy and nodes.
10642 * @deprecated DOM4 [DOM] provides a new mechanism using a MutationObserver interface which addresses the use cases that mutation events solve, but in a more performant manner. Thus, this specification describes mutation events for reference and completeness of legacy behavior, but deprecates the use of the MutationEvent interface. */
10643 interface MutationEvent extends Event {
10644 readonly attrChange: number;
10645 readonly attrName: string;
10646 readonly newValue: string;
10647 readonly prevValue: string;
10648 readonly relatedNode: Node;
10649 initMutationEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, relatedNodeArg: Node, prevValueArg: string, newValueArg: string, attrNameArg: string, attrChangeArg: number): void;
10650 readonly ADDITION: number;
10651 readonly MODIFICATION: number;
10652 readonly REMOVAL: number;
10655 declare var MutationEvent: {
10656 prototype: MutationEvent;
10657 new(): MutationEvent;
10658 readonly ADDITION: number;
10659 readonly MODIFICATION: number;
10660 readonly REMOVAL: number;
10663 /** Provides the ability to watch for changes being made to the DOM tree. It is designed as a replacement for the older Mutation Events feature which was part of the DOM3 Events specification. */
10664 interface MutationObserver {
10666 * Stops observer from observing any mutations. Until the observe() method is used again, observer's callback will not be invoked.
10668 disconnect(): void;
10670 * Instructs the user agent to observe a given target (a node) and report any mutations based on the criteria given by options (an object).
10672 * The options argument allows for setting mutation observation options via object members.
10674 observe(target: Node, options?: MutationObserverInit): void;
10676 * Empties the record queue and returns what was in there.
10678 takeRecords(): MutationRecord[];
10681 declare var MutationObserver: {
10682 prototype: MutationObserver;
10683 new(callback: MutationCallback): MutationObserver;
10686 /** A MutationRecord represents an individual DOM mutation. It is the object that is passed to MutationObserver's callback. */
10687 interface MutationRecord {
10689 * Return the nodes added and removed respectively.
10691 readonly addedNodes: NodeList;
10693 * Returns the local name of the changed attribute, and null otherwise.
10695 readonly attributeName: string | null;
10697 * Returns the namespace of the changed attribute, and null otherwise.
10699 readonly attributeNamespace: string | null;
10701 * Return the previous and next sibling respectively of the added or removed nodes, and null otherwise.
10703 readonly nextSibling: Node | null;
10705 * The return value depends on type. For "attributes", it is the value of the changed attribute before the change. For "characterData", it is the data of the changed node before the change. For "childList", it is null.
10707 readonly oldValue: string | null;
10709 * Return the previous and next sibling respectively of the added or removed nodes, and null otherwise.
10711 readonly previousSibling: Node | null;
10713 * Return the nodes added and removed respectively.
10715 readonly removedNodes: NodeList;
10717 * Returns the node the mutation affected, depending on the type. For "attributes", it is the element whose attribute changed. For "characterData", it is the CharacterData node. For "childList", it is the node whose children changed.
10719 readonly target: Node;
10721 * Returns "attributes" if it was an attribute mutation. "characterData" if it was a mutation to a CharacterData node. And "childList" if it was a mutation to the tree of nodes.
10723 readonly type: MutationRecordType;
10726 declare var MutationRecord: {
10727 prototype: MutationRecord;
10728 new(): MutationRecord;
10731 /** A collection of Attr objects. Objects inside a NamedNodeMap are not in any particular order, unlike NodeList, although they may be accessed by an index as in an array. */
10732 interface NamedNodeMap {
10733 readonly length: number;
10734 getNamedItem(qualifiedName: string): Attr | null;
10735 getNamedItemNS(namespace: string | null, localName: string): Attr | null;
10736 item(index: number): Attr | null;
10737 removeNamedItem(qualifiedName: string): Attr;
10738 removeNamedItemNS(namespace: string | null, localName: string): Attr;
10739 setNamedItem(attr: Attr): Attr | null;
10740 setNamedItemNS(attr: Attr): Attr | null;
10741 [index: number]: Attr;
10744 declare var NamedNodeMap: {
10745 prototype: NamedNodeMap;
10746 new(): NamedNodeMap;
10749 interface NavigationPreloadManager {
10750 disable(): Promise<void>;
10751 enable(): Promise<void>;
10752 getState(): Promise<NavigationPreloadState>;
10753 setHeaderValue(value: string): Promise<void>;
10756 declare var NavigationPreloadManager: {
10757 prototype: NavigationPreloadManager;
10758 new(): NavigationPreloadManager;
10761 /** The state and the identity of the user agent. It allows scripts to query it and to register themselves to carry on some activities. */
10762 interface Navigator extends MSFileSaver, MSNavigatorDoNotTrack, NavigatorAutomationInformation, NavigatorBeacon, NavigatorConcurrentHardware, NavigatorContentUtils, NavigatorCookies, NavigatorID, NavigatorLanguage, NavigatorOnLine, NavigatorPlugins, NavigatorStorage {
10763 readonly activeVRDisplays: ReadonlyArray<VRDisplay>;
10764 readonly clipboard: Clipboard;
10765 readonly credentials: CredentialsContainer;
10766 readonly doNotTrack: string | null;
10767 readonly geolocation: Geolocation;
10768 readonly maxTouchPoints: number;
10769 readonly mediaDevices: MediaDevices;
10770 readonly msManipulationViewsEnabled: boolean;
10771 readonly msMaxTouchPoints: number;
10772 readonly msPointerEnabled: boolean;
10773 readonly permissions: Permissions;
10774 readonly pointerEnabled: boolean;
10775 readonly serviceWorker: ServiceWorkerContainer;
10776 getGamepads(): (Gamepad | null)[];
10777 getUserMedia(constraints: MediaStreamConstraints, successCallback: NavigatorUserMediaSuccessCallback, errorCallback: NavigatorUserMediaErrorCallback): void;
10778 getVRDisplays(): Promise<VRDisplay[]>;
10779 msLaunchUri(uri: string, successCallback?: MSLaunchUriCallback, noHandlerCallback?: MSLaunchUriCallback): void;
10780 requestMediaKeySystemAccess(keySystem: string, supportedConfigurations: MediaKeySystemConfiguration[]): Promise<MediaKeySystemAccess>;
10781 sendBeacon(url: string, data?: BodyInit | null): boolean;
10782 share(data?: ShareData): Promise<void>;
10783 vibrate(pattern: number | number[]): boolean;
10786 declare var Navigator: {
10787 prototype: Navigator;
10791 interface NavigatorAutomationInformation {
10792 readonly webdriver: boolean;
10795 interface NavigatorBeacon {
10796 sendBeacon(url: string, data?: Blob | Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer | FormData | string | null): boolean;
10799 interface NavigatorConcurrentHardware {
10800 readonly hardwareConcurrency: number;
10803 interface NavigatorContentUtils {
10804 registerProtocolHandler(scheme: string, url: string, title: string): void;
10805 unregisterProtocolHandler(scheme: string, url: string): void;
10808 interface NavigatorCookies {
10809 readonly cookieEnabled: boolean;
10812 interface NavigatorID {
10813 readonly appCodeName: string;
10814 readonly appName: string;
10815 readonly appVersion: string;
10816 readonly platform: string;
10817 readonly product: string;
10818 readonly productSub: string;
10819 readonly userAgent: string;
10820 readonly vendor: string;
10821 readonly vendorSub: string;
10824 interface NavigatorLanguage {
10825 readonly language: string;
10826 readonly languages: ReadonlyArray<string>;
10829 interface NavigatorOnLine {
10830 readonly onLine: boolean;
10833 interface NavigatorPlugins {
10834 readonly mimeTypes: MimeTypeArray;
10835 readonly plugins: PluginArray;
10836 javaEnabled(): boolean;
10839 interface NavigatorStorage {
10840 readonly storage: StorageManager;
10843 /** Node is an interface from which a number of DOM API object types inherit. It allows those types to be treated similarly; for example, inheriting the same set of methods, or being tested in the same way. */
10844 interface Node extends EventTarget {
10846 * Returns node's node document's document base URL.
10848 readonly baseURI: string;
10850 * Returns the children.
10852 readonly childNodes: NodeListOf<ChildNode>;
10854 * Returns the first child.
10856 readonly firstChild: ChildNode | null;
10858 * Returns true if node is connected and false otherwise.
10860 readonly isConnected: boolean;
10862 * Returns the last child.
10864 readonly lastChild: ChildNode | null;
10866 readonly namespaceURI: string | null;
10868 * Returns the next sibling.
10870 readonly nextSibling: ChildNode | null;
10872 * Returns a string appropriate for the type of node.
10874 readonly nodeName: string;
10876 * Returns the type of node.
10878 readonly nodeType: number;
10879 nodeValue: string | null;
10881 * Returns the node document. Returns null for documents.
10883 readonly ownerDocument: Document | null;
10885 * Returns the parent element.
10887 readonly parentElement: HTMLElement | null;
10889 * Returns the parent.
10891 readonly parentNode: Node & ParentNode | null;
10893 * Returns the previous sibling.
10895 readonly previousSibling: ChildNode | null;
10896 textContent: string | null;
10897 appendChild<T extends Node>(newChild: T): T;
10899 * Returns a copy of node. If deep is true, the copy also includes the node's descendants.
10901 cloneNode(deep?: boolean): Node;
10903 * Returns a bitmask indicating the position of other relative to node.
10905 compareDocumentPosition(other: Node): number;
10907 * Returns true if other is an inclusive descendant of node, and false otherwise.
10909 contains(other: Node | null): boolean;
10911 * Returns node's root.
10913 getRootNode(options?: GetRootNodeOptions): Node;
10915 * Returns whether node has children.
10917 hasChildNodes(): boolean;
10918 insertBefore<T extends Node>(newChild: T, refChild: Node | null): T;
10919 isDefaultNamespace(namespace: string | null): boolean;
10921 * Returns whether node and otherNode have the same properties.
10923 isEqualNode(otherNode: Node | null): boolean;
10924 isSameNode(otherNode: Node | null): boolean;
10925 lookupNamespaceURI(prefix: string | null): string | null;
10926 lookupPrefix(namespace: string | null): string | null;
10928 * Removes empty exclusive Text nodes and concatenates the data of remaining contiguous exclusive Text nodes into the first of their nodes.
10931 removeChild<T extends Node>(oldChild: T): T;
10932 replaceChild<T extends Node>(newChild: Node, oldChild: T): T;
10933 readonly ATTRIBUTE_NODE: number;
10935 * node is a CDATASection node.
10937 readonly CDATA_SECTION_NODE: number;
10939 * node is a Comment node.
10941 readonly COMMENT_NODE: number;
10943 * node is a DocumentFragment node.
10945 readonly DOCUMENT_FRAGMENT_NODE: number;
10947 * node is a document.
10949 readonly DOCUMENT_NODE: number;
10951 * Set when other is a descendant of node.
10953 readonly DOCUMENT_POSITION_CONTAINED_BY: number;
10955 * Set when other is an ancestor of node.
10957 readonly DOCUMENT_POSITION_CONTAINS: number;
10959 * Set when node and other are not in the same tree.
10961 readonly DOCUMENT_POSITION_DISCONNECTED: number;
10963 * Set when other is following node.
10965 readonly DOCUMENT_POSITION_FOLLOWING: number;
10966 readonly DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC: number;
10968 * Set when other is preceding node.
10970 readonly DOCUMENT_POSITION_PRECEDING: number;
10972 * node is a doctype.
10974 readonly DOCUMENT_TYPE_NODE: number;
10976 * node is an element.
10978 readonly ELEMENT_NODE: number;
10979 readonly ENTITY_NODE: number;
10980 readonly ENTITY_REFERENCE_NODE: number;
10981 readonly NOTATION_NODE: number;
10983 * node is a ProcessingInstruction node.
10985 readonly PROCESSING_INSTRUCTION_NODE: number;
10987 * node is a Text node.
10989 readonly TEXT_NODE: number;
10992 declare var Node: {
10995 readonly ATTRIBUTE_NODE: number;
10997 * node is a CDATASection node.
10999 readonly CDATA_SECTION_NODE: number;
11001 * node is a Comment node.
11003 readonly COMMENT_NODE: number;
11005 * node is a DocumentFragment node.
11007 readonly DOCUMENT_FRAGMENT_NODE: number;
11009 * node is a document.
11011 readonly DOCUMENT_NODE: number;
11013 * Set when other is a descendant of node.
11015 readonly DOCUMENT_POSITION_CONTAINED_BY: number;
11017 * Set when other is an ancestor of node.
11019 readonly DOCUMENT_POSITION_CONTAINS: number;
11021 * Set when node and other are not in the same tree.
11023 readonly DOCUMENT_POSITION_DISCONNECTED: number;
11025 * Set when other is following node.
11027 readonly DOCUMENT_POSITION_FOLLOWING: number;
11028 readonly DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC: number;
11030 * Set when other is preceding node.
11032 readonly DOCUMENT_POSITION_PRECEDING: number;
11034 * node is a doctype.
11036 readonly DOCUMENT_TYPE_NODE: number;
11038 * node is an element.
11040 readonly ELEMENT_NODE: number;
11041 readonly ENTITY_NODE: number;
11042 readonly ENTITY_REFERENCE_NODE: number;
11043 readonly NOTATION_NODE: number;
11045 * node is a ProcessingInstruction node.
11047 readonly PROCESSING_INSTRUCTION_NODE: number;
11049 * node is a Text node.
11051 readonly TEXT_NODE: number;
11054 /** An object used to filter the nodes in a NodeIterator or TreeWalker. They don't know anything about the DOM or how to traverse nodes; they just know how to evaluate a single node against the provided filter. */
11055 interface NodeFilter {
11056 acceptNode(node: Node): number;
11059 declare var NodeFilter: {
11060 readonly FILTER_ACCEPT: number;
11061 readonly FILTER_REJECT: number;
11062 readonly FILTER_SKIP: number;
11063 readonly SHOW_ALL: number;
11064 readonly SHOW_ATTRIBUTE: number;
11065 readonly SHOW_CDATA_SECTION: number;
11066 readonly SHOW_COMMENT: number;
11067 readonly SHOW_DOCUMENT: number;
11068 readonly SHOW_DOCUMENT_FRAGMENT: number;
11069 readonly SHOW_DOCUMENT_TYPE: number;
11070 readonly SHOW_ELEMENT: number;
11071 readonly SHOW_ENTITY: number;
11072 readonly SHOW_ENTITY_REFERENCE: number;
11073 readonly SHOW_NOTATION: number;
11074 readonly SHOW_PROCESSING_INSTRUCTION: number;
11075 readonly SHOW_TEXT: number;
11078 /** An iterator over the members of a list of the nodes in a subtree of the DOM. The nodes will be returned in document order. */
11079 interface NodeIterator {
11080 readonly filter: NodeFilter | null;
11081 readonly pointerBeforeReferenceNode: boolean;
11082 readonly referenceNode: Node;
11083 readonly root: Node;
11084 readonly whatToShow: number;
11086 nextNode(): Node | null;
11087 previousNode(): Node | null;
11090 declare var NodeIterator: {
11091 prototype: NodeIterator;
11092 new(): NodeIterator;
11095 /** NodeList objects are collections of nodes, usually returned by properties such as Node.childNodes and methods such as document.querySelectorAll(). */
11096 interface NodeList {
11098 * Returns the number of nodes in the collection.
11100 readonly length: number;
11102 * Returns the node with index index from the collection. The nodes are sorted in tree order.
11104 item(index: number): Node | null;
11106 * Performs the specified action for each node in an list.
11107 * @param callbackfn A function that accepts up to three arguments. forEach calls the callbackfn function one time for each element in the list.
11108 * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
11110 forEach(callbackfn: (value: Node, key: number, parent: NodeList) => void, thisArg?: any): void;
11111 [index: number]: Node;
11114 declare var NodeList: {
11115 prototype: NodeList;
11119 interface NodeListOf<TNode extends Node> extends NodeList {
11120 item(index: number): TNode;
11122 * Performs the specified action for each node in an list.
11123 * @param callbackfn A function that accepts up to three arguments. forEach calls the callbackfn function one time for each element in the list.
11124 * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
11126 forEach(callbackfn: (value: TNode, key: number, parent: NodeListOf<TNode>) => void, thisArg?: any): void;
11127 [index: number]: TNode;
11130 interface NonDocumentTypeChildNode {
11132 * Returns the first following sibling that is an element, and null otherwise.
11134 readonly nextElementSibling: Element | null;
11136 * Returns the first preceding sibling that is an element, and null otherwise.
11138 readonly previousElementSibling: Element | null;
11141 interface NonElementParentNode {
11143 * Returns the first element within node's descendants whose ID is elementId.
11145 getElementById(elementId: string): Element | null;
11148 interface NotificationEventMap {
11155 /** This Notifications API interface is used to configure and display desktop notifications to the user. */
11156 interface Notification extends EventTarget {
11157 readonly actions: ReadonlyArray<NotificationAction>;
11158 readonly badge: string;
11159 readonly body: string;
11160 readonly data: any;
11161 readonly dir: NotificationDirection;
11162 readonly icon: string;
11163 readonly image: string;
11164 readonly lang: string;
11165 onclick: ((this: Notification, ev: Event) => any) | null;
11166 onclose: ((this: Notification, ev: Event) => any) | null;
11167 onerror: ((this: Notification, ev: Event) => any) | null;
11168 onshow: ((this: Notification, ev: Event) => any) | null;
11169 readonly renotify: boolean;
11170 readonly requireInteraction: boolean;
11171 readonly silent: boolean;
11172 readonly tag: string;
11173 readonly timestamp: number;
11174 readonly title: string;
11175 readonly vibrate: ReadonlyArray<number>;
11177 addEventListener<K extends keyof NotificationEventMap>(type: K, listener: (this: Notification, ev: NotificationEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11178 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11179 removeEventListener<K extends keyof NotificationEventMap>(type: K, listener: (this: Notification, ev: NotificationEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11180 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11183 declare var Notification: {
11184 prototype: Notification;
11185 new(title: string, options?: NotificationOptions): Notification;
11186 readonly maxActions: number;
11187 readonly permission: NotificationPermission;
11188 requestPermission(deprecatedCallback?: NotificationPermissionCallback): Promise<NotificationPermission>;
11191 /** The OES_element_index_uint extension is part of the WebGL API and adds support for gl.UNSIGNED_INT types to WebGLRenderingContext.drawElements(). */
11192 interface OES_element_index_uint {
11195 /** The OES_standard_derivatives extension is part of the WebGL API and adds the GLSL derivative functions dFdx, dFdy, and fwidth. */
11196 interface OES_standard_derivatives {
11197 readonly FRAGMENT_SHADER_DERIVATIVE_HINT_OES: GLenum;
11200 /** The OES_texture_float extension is part of the WebGL API and exposes floating-point pixel types for textures. */
11201 interface OES_texture_float {
11204 /** The OES_texture_float_linear extension is part of the WebGL API and allows linear filtering with floating-point pixel types for textures. */
11205 interface OES_texture_float_linear {
11208 /** The OES_texture_half_float extension is part of the WebGL API and adds texture formats with 16- (aka half float) and 32-bit floating-point components. */
11209 interface OES_texture_half_float {
11210 readonly HALF_FLOAT_OES: GLenum;
11213 /** The OES_texture_half_float_linear extension is part of the WebGL API and allows linear filtering with half floating-point pixel types for textures. */
11214 interface OES_texture_half_float_linear {
11217 interface OES_vertex_array_object {
11218 bindVertexArrayOES(arrayObject: WebGLVertexArrayObjectOES | null): void;
11219 createVertexArrayOES(): WebGLVertexArrayObjectOES | null;
11220 deleteVertexArrayOES(arrayObject: WebGLVertexArrayObjectOES | null): void;
11221 isVertexArrayOES(arrayObject: WebGLVertexArrayObjectOES | null): GLboolean;
11222 readonly VERTEX_ARRAY_BINDING_OES: GLenum;
11225 /** The Web Audio API OfflineAudioCompletionEvent interface represents events that occur when the processing of an OfflineAudioContext is terminated. The complete event implements this interface. */
11226 interface OfflineAudioCompletionEvent extends Event {
11227 readonly renderedBuffer: AudioBuffer;
11230 declare var OfflineAudioCompletionEvent: {
11231 prototype: OfflineAudioCompletionEvent;
11232 new(type: string, eventInitDict: OfflineAudioCompletionEventInit): OfflineAudioCompletionEvent;
11235 interface OfflineAudioContextEventMap extends BaseAudioContextEventMap {
11236 "complete": OfflineAudioCompletionEvent;
11239 /** An AudioContext interface representing an audio-processing graph built from linked together AudioNodes. In contrast with a standard AudioContext, an OfflineAudioContext doesn't render the audio to the device hardware; instead, it generates it, as fast as it can, and outputs the result to an AudioBuffer. */
11240 interface OfflineAudioContext extends BaseAudioContext {
11241 readonly length: number;
11242 oncomplete: ((this: OfflineAudioContext, ev: OfflineAudioCompletionEvent) => any) | null;
11243 resume(): Promise<void>;
11244 startRendering(): Promise<AudioBuffer>;
11245 suspend(suspendTime: number): Promise<void>;
11246 addEventListener<K extends keyof OfflineAudioContextEventMap>(type: K, listener: (this: OfflineAudioContext, ev: OfflineAudioContextEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11247 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11248 removeEventListener<K extends keyof OfflineAudioContextEventMap>(type: K, listener: (this: OfflineAudioContext, ev: OfflineAudioContextEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11249 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11252 declare var OfflineAudioContext: {
11253 prototype: OfflineAudioContext;
11254 new(contextOptions: OfflineAudioContextOptions): OfflineAudioContext;
11255 new(numberOfChannels: number, length: number, sampleRate: number): OfflineAudioContext;
11258 interface OffscreenCanvas extends EventTarget {
11260 * These attributes return the dimensions of the OffscreenCanvas object's bitmap.
11262 * They can be set, to replace the bitmap with a new, transparent black bitmap of the specified dimensions (effectively resizing it).
11266 * These attributes return the dimensions of the OffscreenCanvas object's bitmap.
11268 * They can be set, to replace the bitmap with a new, transparent black bitmap of the specified dimensions (effectively resizing it).
11272 * Returns a promise that will fulfill with a new Blob object representing a file containing the image in the OffscreenCanvas object.
11274 * The argument, if provided, is a dictionary that controls the encoding options of the image file to be created. The type field specifies the file format and has a default value of "image/png"; that type is also used if the requested type isn't supported. If the image format supports variable quality (such as "image/jpeg"), then the quality field is a number in the range 0.0 to 1.0 inclusive indicating the desired quality level for the resulting image.
11276 convertToBlob(options?: ImageEncodeOptions): Promise<Blob>;
11278 * Returns an object that exposes an API for drawing on the OffscreenCanvas object. contextId specifies the desired API: "2d", "bitmaprenderer", "webgl", or "webgl2". options is handled by that API.
11280 * This specification defines the "2d" context below, which is similar but distinct from the "2d" context that is created from a canvas element. The WebGL specifications define the "webgl" and "webgl2" contexts. [WEBGL]
11282 * Returns null if the canvas has already been initialized with another context type (e.g., trying to get a "2d" context after getting a "webgl" context).
11284 getContext(contextId: "2d", options?: CanvasRenderingContext2DSettings): OffscreenCanvasRenderingContext2D | null;
11285 getContext(contextId: "bitmaprenderer", options?: ImageBitmapRenderingContextSettings): ImageBitmapRenderingContext | null;
11286 getContext(contextId: "webgl", options?: WebGLContextAttributes): WebGLRenderingContext | null;
11287 getContext(contextId: "webgl2", options?: WebGLContextAttributes): WebGL2RenderingContext | null;
11288 getContext(contextId: OffscreenRenderingContextId, options?: any): OffscreenRenderingContext | null;
11290 * Returns a newly created ImageBitmap object with the image in the OffscreenCanvas object. The image in the OffscreenCanvas object is replaced with a new blank image.
11292 transferToImageBitmap(): ImageBitmap;
11295 declare var OffscreenCanvas: {
11296 prototype: OffscreenCanvas;
11297 new(width: number, height: number): OffscreenCanvas;
11300 interface OffscreenCanvasRenderingContext2D extends CanvasCompositing, CanvasDrawImage, CanvasDrawPath, CanvasFillStrokeStyles, CanvasFilters, CanvasImageData, CanvasImageSmoothing, CanvasPath, CanvasPathDrawingStyles, CanvasRect, CanvasShadowStyles, CanvasState, CanvasText, CanvasTextDrawingStyles, CanvasTransform {
11301 readonly canvas: OffscreenCanvas;
11305 declare var OffscreenCanvasRenderingContext2D: {
11306 prototype: OffscreenCanvasRenderingContext2D;
11307 new(): OffscreenCanvasRenderingContext2D;
11310 /** The OscillatorNode interface represents a periodic waveform, such as a sine wave. It is an AudioScheduledSourceNode audio-processing module that causes a specified frequency of a given wave to be created—in effect, a constant tone. */
11311 interface OscillatorNode extends AudioScheduledSourceNode {
11312 readonly detune: AudioParam;
11313 readonly frequency: AudioParam;
11314 type: OscillatorType;
11315 setPeriodicWave(periodicWave: PeriodicWave): void;
11316 addEventListener<K extends keyof AudioScheduledSourceNodeEventMap>(type: K, listener: (this: OscillatorNode, ev: AudioScheduledSourceNodeEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11317 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11318 removeEventListener<K extends keyof AudioScheduledSourceNodeEventMap>(type: K, listener: (this: OscillatorNode, ev: AudioScheduledSourceNodeEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11319 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11322 declare var OscillatorNode: {
11323 prototype: OscillatorNode;
11324 new(context: BaseAudioContext, options?: OscillatorOptions): OscillatorNode;
11327 interface OverconstrainedError extends Error {
11328 constraint: string;
11331 declare var OverconstrainedError: {
11332 prototype: OverconstrainedError;
11333 new(): OverconstrainedError;
11336 interface OverflowEvent extends UIEvent {
11337 readonly horizontalOverflow: boolean;
11338 readonly orient: number;
11339 readonly verticalOverflow: boolean;
11340 readonly BOTH: number;
11341 readonly HORIZONTAL: number;
11342 readonly VERTICAL: number;
11345 declare var OverflowEvent: {
11346 prototype: OverflowEvent;
11347 new(): OverflowEvent;
11348 readonly BOTH: number;
11349 readonly HORIZONTAL: number;
11350 readonly VERTICAL: number;
11353 /** The PageTransitionEvent is fired when a document is being loaded or unloaded. */
11354 interface PageTransitionEvent extends Event {
11356 * For the pageshow event, returns false if the page is newly being loaded (and the load event will fire). Otherwise, returns true.
11358 * For the pagehide event, returns false if the page is going away for the last time. Otherwise, returns true, meaning that (if nothing conspires to make the page unsalvageable) the page might be reused if the user navigates back to this page.
11360 * Things that can cause the page to be unsalvageable include:
11362 * Listening for beforeunload events
11363 * Listening for unload events
11364 * Having iframes that are not salvageable
11365 * Active WebSocket objects
11366 * Aborting a Document
11368 readonly persisted: boolean;
11371 declare var PageTransitionEvent: {
11372 prototype: PageTransitionEvent;
11373 new(type: string, eventInitDict?: PageTransitionEventInit): PageTransitionEvent;
11376 /** A PannerNode always has exactly one input and one output: the input can be mono or stereo but the output is always stereo (2 channels); you can't have panning effects without at least two audio channels! */
11377 interface PannerNode extends AudioNode {
11378 coneInnerAngle: number;
11379 coneOuterAngle: number;
11380 coneOuterGain: number;
11381 distanceModel: DistanceModelType;
11382 maxDistance: number;
11383 readonly orientationX: AudioParam;
11384 readonly orientationY: AudioParam;
11385 readonly orientationZ: AudioParam;
11386 panningModel: PanningModelType;
11387 readonly positionX: AudioParam;
11388 readonly positionY: AudioParam;
11389 readonly positionZ: AudioParam;
11390 refDistance: number;
11391 rolloffFactor: number;
11393 setOrientation(x: number, y: number, z: number): void;
11395 setPosition(x: number, y: number, z: number): void;
11398 declare var PannerNode: {
11399 prototype: PannerNode;
11400 new(context: BaseAudioContext, options?: PannerOptions): PannerNode;
11403 interface ParentNode {
11404 readonly childElementCount: number;
11406 * Returns the child elements.
11408 readonly children: HTMLCollection;
11410 * Returns the first child that is an element, and null otherwise.
11412 readonly firstElementChild: Element | null;
11414 * Returns the last child that is an element, and null otherwise.
11416 readonly lastElementChild: Element | null;
11418 * Inserts nodes after the last child of node, while replacing strings in nodes with equivalent Text nodes.
11420 * Throws a "HierarchyRequestError" DOMException if the constraints of the node tree are violated.
11422 append(...nodes: (Node | string)[]): void;
11424 * Inserts nodes before the first child of node, while replacing strings in nodes with equivalent Text nodes.
11426 * Throws a "HierarchyRequestError" DOMException if the constraints of the node tree are violated.
11428 prepend(...nodes: (Node | string)[]): void;
11430 * Returns the first element that is a descendant of node that matches selectors.
11432 querySelector<K extends keyof HTMLElementTagNameMap>(selectors: K): HTMLElementTagNameMap[K] | null;
11433 querySelector<K extends keyof SVGElementTagNameMap>(selectors: K): SVGElementTagNameMap[K] | null;
11434 querySelector<E extends Element = Element>(selectors: string): E | null;
11436 * Returns all element descendants of node that match selectors.
11438 querySelectorAll<K extends keyof HTMLElementTagNameMap>(selectors: K): NodeListOf<HTMLElementTagNameMap[K]>;
11439 querySelectorAll<K extends keyof SVGElementTagNameMap>(selectors: K): NodeListOf<SVGElementTagNameMap[K]>;
11440 querySelectorAll<E extends Element = Element>(selectors: string): NodeListOf<E>;
11443 /** This Canvas 2D API interface is used to declare a path that can then be used on a CanvasRenderingContext2D object. The path methods of the CanvasRenderingContext2D interface are also present on this interface, which gives you the convenience of being able to retain and replay your path whenever desired. */
11444 interface Path2D extends CanvasPath {
11446 * Adds to the path the path given by the argument.
11448 addPath(path: Path2D, transform?: DOMMatrix2DInit): void;
11451 declare var Path2D: {
11453 new(path?: Path2D | string): Path2D;
11456 /** This Payment Request API interface is used to store shipping or payment address information. */
11457 interface PaymentAddress {
11458 readonly addressLine: string[];
11459 readonly city: string;
11460 readonly country: string;
11461 readonly dependentLocality: string;
11462 readonly languageCode: string;
11463 readonly organization: string;
11464 readonly phone: string;
11465 readonly postalCode: string;
11466 readonly recipient: string;
11467 readonly region: string;
11468 readonly sortingCode: string;
11472 declare var PaymentAddress: {
11473 prototype: PaymentAddress;
11474 new(): PaymentAddress;
11477 interface PaymentRequestEventMap {
11478 "shippingaddresschange": Event;
11479 "shippingoptionchange": Event;
11482 /** This Payment Request API interface is the primary access point into the API, and lets web content and apps accept payments from the end user. */
11483 interface PaymentRequest extends EventTarget {
11484 readonly id: string;
11485 onshippingaddresschange: ((this: PaymentRequest, ev: Event) => any) | null;
11486 onshippingoptionchange: ((this: PaymentRequest, ev: Event) => any) | null;
11487 readonly shippingAddress: PaymentAddress | null;
11488 readonly shippingOption: string | null;
11489 readonly shippingType: PaymentShippingType | null;
11490 abort(): Promise<void>;
11491 canMakePayment(): Promise<boolean>;
11492 show(): Promise<PaymentResponse>;
11493 addEventListener<K extends keyof PaymentRequestEventMap>(type: K, listener: (this: PaymentRequest, ev: PaymentRequestEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11494 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11495 removeEventListener<K extends keyof PaymentRequestEventMap>(type: K, listener: (this: PaymentRequest, ev: PaymentRequestEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11496 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11499 declare var PaymentRequest: {
11500 prototype: PaymentRequest;
11501 new(methodData: PaymentMethodData[], details: PaymentDetailsInit, options?: PaymentOptions): PaymentRequest;
11504 /** This Payment Request API interface enables a web page to update the details of a PaymentRequest in response to a user action. */
11505 interface PaymentRequestUpdateEvent extends Event {
11506 updateWith(detailsPromise: PaymentDetailsUpdate | Promise<PaymentDetailsUpdate>): void;
11509 declare var PaymentRequestUpdateEvent: {
11510 prototype: PaymentRequestUpdateEvent;
11511 new(type: string, eventInitDict?: PaymentRequestUpdateEventInit): PaymentRequestUpdateEvent;
11514 /** This Payment Request API interface is returned after a user selects a payment method and approves a payment request. */
11515 interface PaymentResponse {
11516 readonly details: any;
11517 readonly methodName: string;
11518 readonly payerEmail: string | null;
11519 readonly payerName: string | null;
11520 readonly payerPhone: string | null;
11521 readonly requestId: string;
11522 readonly shippingAddress: PaymentAddress | null;
11523 readonly shippingOption: string | null;
11524 complete(result?: PaymentComplete): Promise<void>;
11528 declare var PaymentResponse: {
11529 prototype: PaymentResponse;
11530 new(): PaymentResponse;
11533 interface PerfWidgetExternal {
11534 readonly activeNetworkRequestCount: number;
11535 readonly averageFrameTime: number;
11536 readonly averagePaintTime: number;
11537 readonly extraInformationEnabled: boolean;
11538 readonly independentRenderingEnabled: boolean;
11539 readonly irDisablingContentString: string;
11540 readonly irStatusAvailable: boolean;
11541 readonly maxCpuSpeed: number;
11542 readonly paintRequestsPerSecond: number;
11543 readonly performanceCounter: number;
11544 readonly performanceCounterFrequency: number;
11545 addEventListener(eventType: string, callback: Function): void;
11546 getMemoryUsage(): number;
11547 getProcessCpuUsage(): number;
11548 getRecentCpuUsage(last: number | null): any;
11549 getRecentFrames(last: number | null): any;
11550 getRecentMemoryUsage(last: number | null): any;
11551 getRecentPaintRequests(last: number | null): any;
11552 removeEventListener(eventType: string, callback: Function): void;
11553 repositionWindow(x: number, y: number): void;
11554 resizeWindow(width: number, height: number): void;
11557 declare var PerfWidgetExternal: {
11558 prototype: PerfWidgetExternal;
11559 new(): PerfWidgetExternal;
11562 interface PerformanceEventMap {
11563 "resourcetimingbufferfull": Event;
11566 /** Provides access to performance-related information for the current page. It's part of the High Resolution Time API, but is enhanced by the Performance Timeline API, the Navigation Timing API, the User Timing API, and the Resource Timing API. */
11567 interface Performance extends EventTarget {
11569 readonly navigation: PerformanceNavigation;
11570 onresourcetimingbufferfull: ((this: Performance, ev: Event) => any) | null;
11571 readonly timeOrigin: number;
11573 readonly timing: PerformanceTiming;
11574 clearMarks(markName?: string): void;
11575 clearMeasures(measureName?: string): void;
11576 clearResourceTimings(): void;
11577 getEntries(): PerformanceEntryList;
11578 getEntriesByName(name: string, type?: string): PerformanceEntryList;
11579 getEntriesByType(type: string): PerformanceEntryList;
11580 mark(markName: string): void;
11581 measure(measureName: string, startMark?: string, endMark?: string): void;
11583 setResourceTimingBufferSize(maxSize: number): void;
11585 addEventListener<K extends keyof PerformanceEventMap>(type: K, listener: (this: Performance, ev: PerformanceEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11586 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11587 removeEventListener<K extends keyof PerformanceEventMap>(type: K, listener: (this: Performance, ev: PerformanceEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11588 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11591 declare var Performance: {
11592 prototype: Performance;
11593 new(): Performance;
11596 /** Encapsulates a single performance metric that is part of the performance timeline. A performance entry can be directly created by making a performance mark or measure (for example by calling the mark() method) at an explicit point in an application. Performance entries are also created in indirect ways such as loading a resource (such as an image). */
11597 interface PerformanceEntry {
11598 readonly duration: number;
11599 readonly entryType: string;
11600 readonly name: string;
11601 readonly startTime: number;
11605 declare var PerformanceEntry: {
11606 prototype: PerformanceEntry;
11607 new(): PerformanceEntry;
11610 /** PerformanceMark is an abstract interface for PerformanceEntry objects with an entryType of "mark". Entries of this type are created by calling performance.mark() to add a named DOMHighResTimeStamp (the mark) to the browser's performance timeline. */
11611 interface PerformanceMark extends PerformanceEntry {
11614 declare var PerformanceMark: {
11615 prototype: PerformanceMark;
11616 new(): PerformanceMark;
11619 /** PerformanceMeasure is an abstract interface for PerformanceEntry objects with an entryType of "measure". Entries of this type are created by calling performance.measure() to add a named DOMHighResTimeStamp (the measure) between two marks to the browser's performance timeline. */
11620 interface PerformanceMeasure extends PerformanceEntry {
11623 declare var PerformanceMeasure: {
11624 prototype: PerformanceMeasure;
11625 new(): PerformanceMeasure;
11628 /** The legacy PerformanceNavigation interface represents information about how the navigation to the current document was done.
11629 * @deprecated This interface is deprecated in the Navigation Timing Level 2 specification. Please use the PerformanceNavigationTiming interface instead.
11631 interface PerformanceNavigation {
11632 readonly redirectCount: number;
11633 readonly type: number;
11635 readonly TYPE_BACK_FORWARD: number;
11636 readonly TYPE_NAVIGATE: number;
11637 readonly TYPE_RELOAD: number;
11638 readonly TYPE_RESERVED: number;
11641 declare var PerformanceNavigation: {
11642 prototype: PerformanceNavigation;
11643 new(): PerformanceNavigation;
11644 readonly TYPE_BACK_FORWARD: number;
11645 readonly TYPE_NAVIGATE: number;
11646 readonly TYPE_RELOAD: number;
11647 readonly TYPE_RESERVED: number;
11650 /** Provides methods and properties to store and retrieve metrics regarding the browser's document navigation events. For example, this interface can be used to determine how much time it takes to load or unload a document. */
11651 interface PerformanceNavigationTiming extends PerformanceResourceTiming {
11652 readonly domComplete: number;
11653 readonly domContentLoadedEventEnd: number;
11654 readonly domContentLoadedEventStart: number;
11655 readonly domInteractive: number;
11656 readonly loadEventEnd: number;
11657 readonly loadEventStart: number;
11658 readonly redirectCount: number;
11659 readonly type: NavigationType;
11660 readonly unloadEventEnd: number;
11661 readonly unloadEventStart: number;
11665 declare var PerformanceNavigationTiming: {
11666 prototype: PerformanceNavigationTiming;
11667 new(): PerformanceNavigationTiming;
11670 interface PerformanceObserver {
11671 disconnect(): void;
11672 observe(options?: PerformanceObserverInit): void;
11673 takeRecords(): PerformanceEntryList;
11676 declare var PerformanceObserver: {
11677 prototype: PerformanceObserver;
11678 new(callback: PerformanceObserverCallback): PerformanceObserver;
11679 readonly supportedEntryTypes: ReadonlyArray<string>;
11682 interface PerformanceObserverEntryList {
11683 getEntries(): PerformanceEntryList;
11684 getEntriesByName(name: string, type?: string): PerformanceEntryList;
11685 getEntriesByType(type: string): PerformanceEntryList;
11688 declare var PerformanceObserverEntryList: {
11689 prototype: PerformanceObserverEntryList;
11690 new(): PerformanceObserverEntryList;
11693 /** Enables retrieval and analysis of detailed network timing data regarding the loading of an application's resources. An application can use the timing metrics to determine, for example, the length of time it takes to fetch a specific resource, such as an XMLHttpRequest, <SVG>, image, or script. */
11694 interface PerformanceResourceTiming extends PerformanceEntry {
11695 readonly connectEnd: number;
11696 readonly connectStart: number;
11697 readonly decodedBodySize: number;
11698 readonly domainLookupEnd: number;
11699 readonly domainLookupStart: number;
11700 readonly encodedBodySize: number;
11701 readonly fetchStart: number;
11702 readonly initiatorType: string;
11703 readonly nextHopProtocol: string;
11704 readonly redirectEnd: number;
11705 readonly redirectStart: number;
11706 readonly requestStart: number;
11707 readonly responseEnd: number;
11708 readonly responseStart: number;
11709 readonly secureConnectionStart: number;
11710 readonly transferSize: number;
11711 readonly workerStart: number;
11715 declare var PerformanceResourceTiming: {
11716 prototype: PerformanceResourceTiming;
11717 new(): PerformanceResourceTiming;
11720 /** A legacy interface kept for backwards compatibility and contains properties that offer performance timing information for various events which occur during the loading and use of the current page. You get a PerformanceTiming object describing your page using the window.performance.timing property.
11721 * @deprecated This interface is deprecated in the Navigation Timing Level 2 specification. Please use the PerformanceNavigationTiming interface instead.
11723 interface PerformanceTiming {
11724 readonly connectEnd: number;
11725 readonly connectStart: number;
11726 readonly domComplete: number;
11727 readonly domContentLoadedEventEnd: number;
11728 readonly domContentLoadedEventStart: number;
11729 readonly domInteractive: number;
11730 readonly domLoading: number;
11731 readonly domainLookupEnd: number;
11732 readonly domainLookupStart: number;
11733 readonly fetchStart: number;
11734 readonly loadEventEnd: number;
11735 readonly loadEventStart: number;
11736 readonly navigationStart: number;
11737 readonly redirectEnd: number;
11738 readonly redirectStart: number;
11739 readonly requestStart: number;
11740 readonly responseEnd: number;
11741 readonly responseStart: number;
11742 readonly secureConnectionStart: number;
11743 readonly unloadEventEnd: number;
11744 readonly unloadEventStart: number;
11748 declare var PerformanceTiming: {
11749 prototype: PerformanceTiming;
11750 new(): PerformanceTiming;
11753 /** PeriodicWave has no inputs or outputs; it is used to define custom oscillators when calling OscillatorNode.setPeriodicWave(). The PeriodicWave itself is created/returned by AudioContext.createPeriodicWave(). */
11754 interface PeriodicWave {
11757 declare var PeriodicWave: {
11758 prototype: PeriodicWave;
11759 new(context: BaseAudioContext, options?: PeriodicWaveOptions): PeriodicWave;
11762 interface PermissionRequest extends DeferredPermissionRequest {
11763 readonly state: MSWebViewPermissionState;
11767 declare var PermissionRequest: {
11768 prototype: PermissionRequest;
11769 new(): PermissionRequest;
11772 interface PermissionRequestedEvent extends Event {
11773 readonly permissionRequest: PermissionRequest;
11776 declare var PermissionRequestedEvent: {
11777 prototype: PermissionRequestedEvent;
11778 new(): PermissionRequestedEvent;
11781 interface PermissionStatusEventMap {
11785 interface PermissionStatus extends EventTarget {
11786 onchange: ((this: PermissionStatus, ev: Event) => any) | null;
11787 readonly state: PermissionState;
11788 addEventListener<K extends keyof PermissionStatusEventMap>(type: K, listener: (this: PermissionStatus, ev: PermissionStatusEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11789 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11790 removeEventListener<K extends keyof PermissionStatusEventMap>(type: K, listener: (this: PermissionStatus, ev: PermissionStatusEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11791 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11794 declare var PermissionStatus: {
11795 prototype: PermissionStatus;
11796 new(): PermissionStatus;
11799 interface Permissions {
11800 query(permissionDesc: PermissionDescriptor | DevicePermissionDescriptor | MidiPermissionDescriptor | PushPermissionDescriptor): Promise<PermissionStatus>;
11803 declare var Permissions: {
11804 prototype: Permissions;
11805 new(): Permissions;
11808 /** Provides information about a browser plugin. */
11811 * Returns the plugin's description.
11813 readonly description: string;
11815 * Returns the plugin library's filename, if applicable on the current platform.
11817 readonly filename: string;
11819 * Returns the number of MIME types, represented by MimeType objects, supported by the plugin.
11821 readonly length: number;
11823 * Returns the plugin's name.
11825 readonly name: string;
11827 * Returns the specified MimeType object.
11829 item(index: number): MimeType | null;
11830 namedItem(name: string): MimeType | null;
11831 [index: number]: MimeType;
11834 declare var Plugin: {
11839 /** Used to store a list of Plugin objects describing the available plugins; it's returned by the window.navigator.plugins property. The PluginArray is not a JavaScript array, but has the length property and supports accessing individual items using bracket notation (plugins[2]), as well as via item(index) and namedItem("name") methods. */
11840 interface PluginArray {
11841 readonly length: number;
11842 item(index: number): Plugin | null;
11843 namedItem(name: string): Plugin | null;
11844 refresh(reload?: boolean): void;
11845 [index: number]: Plugin;
11848 declare var PluginArray: {
11849 prototype: PluginArray;
11850 new(): PluginArray;
11853 /** The state of a DOM event produced by a pointer such as the geometry of the contact point, the device type that generated the event, the amount of pressure that was applied on the contact surface, etc. */
11854 interface PointerEvent extends MouseEvent {
11855 readonly height: number;
11856 readonly isPrimary: boolean;
11857 readonly pointerId: number;
11858 readonly pointerType: string;
11859 readonly pressure: number;
11860 readonly tangentialPressure: number;
11861 readonly tiltX: number;
11862 readonly tiltY: number;
11863 readonly twist: number;
11864 readonly width: number;
11865 getCoalescedEvents(): PointerEvent[];
11866 getPredictedEvents(): PointerEvent[];
11869 declare var PointerEvent: {
11870 prototype: PointerEvent;
11871 new(type: string, eventInitDict?: PointerEventInit): PointerEvent;
11874 /** PopStateEvent is an event handler for the popstate event on the window. */
11875 interface PopStateEvent extends Event {
11877 * Returns a copy of the information that was provided to pushState() or replaceState().
11879 readonly state: any;
11882 declare var PopStateEvent: {
11883 prototype: PopStateEvent;
11884 new(type: string, eventInitDict?: PopStateEventInit): PopStateEvent;
11887 /** A processing instruction embeds application-specific instructions in XML which can be ignored by other applications that don't recognize them. */
11888 interface ProcessingInstruction extends CharacterData, LinkStyle {
11889 readonly ownerDocument: Document;
11890 readonly target: string;
11893 declare var ProcessingInstruction: {
11894 prototype: ProcessingInstruction;
11895 new(): ProcessingInstruction;
11898 /** Events measuring progress of an underlying process, like an HTTP request (for an XMLHttpRequest, or the loading of the underlying resource of an <img>, <audio>, <video>, <style> or <link>). */
11899 interface ProgressEvent<T extends EventTarget = EventTarget> extends Event {
11900 readonly lengthComputable: boolean;
11901 readonly loaded: number;
11902 readonly target: T | null;
11903 readonly total: number;
11906 declare var ProgressEvent: {
11907 prototype: ProgressEvent;
11908 new(type: string, eventInitDict?: ProgressEventInit): ProgressEvent;
11911 interface PromiseRejectionEvent extends Event {
11912 readonly promise: Promise<any>;
11913 readonly reason: any;
11916 declare var PromiseRejectionEvent: {
11917 prototype: PromiseRejectionEvent;
11918 new(type: string, eventInitDict: PromiseRejectionEventInit): PromiseRejectionEvent;
11921 interface PublicKeyCredential extends Credential {
11922 readonly rawId: ArrayBuffer;
11923 readonly response: AuthenticatorResponse;
11924 getClientExtensionResults(): AuthenticationExtensionsClientOutputs;
11927 declare var PublicKeyCredential: {
11928 prototype: PublicKeyCredential;
11929 new(): PublicKeyCredential;
11930 isUserVerifyingPlatformAuthenticatorAvailable(): Promise<boolean>;
11933 /** This Push API interface provides a way to receive notifications from third-party servers as well as request URLs for push notifications. */
11934 interface PushManager {
11935 getSubscription(): Promise<PushSubscription | null>;
11936 permissionState(options?: PushSubscriptionOptionsInit): Promise<PushPermissionState>;
11937 subscribe(options?: PushSubscriptionOptionsInit): Promise<PushSubscription>;
11940 declare var PushManager: {
11941 prototype: PushManager;
11942 new(): PushManager;
11943 readonly supportedContentEncodings: ReadonlyArray<string>;
11946 /** This Push API interface provides a subcription's URL endpoint and allows unsubscription from a push service. */
11947 interface PushSubscription {
11948 readonly endpoint: string;
11949 readonly expirationTime: number | null;
11950 readonly options: PushSubscriptionOptions;
11951 getKey(name: PushEncryptionKeyName): ArrayBuffer | null;
11952 toJSON(): PushSubscriptionJSON;
11953 unsubscribe(): Promise<boolean>;
11956 declare var PushSubscription: {
11957 prototype: PushSubscription;
11958 new(): PushSubscription;
11961 interface PushSubscriptionOptions {
11962 readonly applicationServerKey: ArrayBuffer | null;
11963 readonly userVisibleOnly: boolean;
11966 declare var PushSubscriptionOptions: {
11967 prototype: PushSubscriptionOptions;
11968 new(): PushSubscriptionOptions;
11971 interface RTCCertificate {
11972 readonly expires: number;
11973 getFingerprints(): RTCDtlsFingerprint[];
11976 declare var RTCCertificate: {
11977 prototype: RTCCertificate;
11978 new(): RTCCertificate;
11979 getSupportedAlgorithms(): AlgorithmIdentifier[];
11982 interface RTCDTMFSenderEventMap {
11983 "tonechange": RTCDTMFToneChangeEvent;
11986 interface RTCDTMFSender extends EventTarget {
11987 readonly canInsertDTMF: boolean;
11988 ontonechange: ((this: RTCDTMFSender, ev: RTCDTMFToneChangeEvent) => any) | null;
11989 readonly toneBuffer: string;
11990 insertDTMF(tones: string, duration?: number, interToneGap?: number): void;
11991 addEventListener<K extends keyof RTCDTMFSenderEventMap>(type: K, listener: (this: RTCDTMFSender, ev: RTCDTMFSenderEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11992 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11993 removeEventListener<K extends keyof RTCDTMFSenderEventMap>(type: K, listener: (this: RTCDTMFSender, ev: RTCDTMFSenderEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11994 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11997 declare var RTCDTMFSender: {
11998 prototype: RTCDTMFSender;
11999 new(): RTCDTMFSender;
12002 /** Events sent to indicate that DTMF tones have started or finished playing. This interface is used by the tonechange event. */
12003 interface RTCDTMFToneChangeEvent extends Event {
12004 readonly tone: string;
12007 declare var RTCDTMFToneChangeEvent: {
12008 prototype: RTCDTMFToneChangeEvent;
12009 new(type: string, eventInitDict: RTCDTMFToneChangeEventInit): RTCDTMFToneChangeEvent;
12012 interface RTCDataChannelEventMap {
12013 "bufferedamountlow": Event;
12015 "error": RTCErrorEvent;
12016 "message": MessageEvent;
12020 interface RTCDataChannel extends EventTarget {
12021 binaryType: string;
12022 readonly bufferedAmount: number;
12023 bufferedAmountLowThreshold: number;
12024 readonly id: number | null;
12025 readonly label: string;
12026 readonly maxPacketLifeTime: number | null;
12027 readonly maxRetransmits: number | null;
12028 readonly negotiated: boolean;
12029 onbufferedamountlow: ((this: RTCDataChannel, ev: Event) => any) | null;
12030 onclose: ((this: RTCDataChannel, ev: Event) => any) | null;
12031 onerror: ((this: RTCDataChannel, ev: RTCErrorEvent) => any) | null;
12032 onmessage: ((this: RTCDataChannel, ev: MessageEvent) => any) | null;
12033 onopen: ((this: RTCDataChannel, ev: Event) => any) | null;
12034 readonly ordered: boolean;
12035 readonly priority: RTCPriorityType;
12036 readonly protocol: string;
12037 readonly readyState: RTCDataChannelState;
12039 send(data: string): void;
12040 send(data: Blob): void;
12041 send(data: ArrayBuffer): void;
12042 send(data: ArrayBufferView): void;
12043 addEventListener<K extends keyof RTCDataChannelEventMap>(type: K, listener: (this: RTCDataChannel, ev: RTCDataChannelEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12044 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12045 removeEventListener<K extends keyof RTCDataChannelEventMap>(type: K, listener: (this: RTCDataChannel, ev: RTCDataChannelEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12046 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12049 declare var RTCDataChannel: {
12050 prototype: RTCDataChannel;
12051 new(): RTCDataChannel;
12054 interface RTCDataChannelEvent extends Event {
12055 readonly channel: RTCDataChannel;
12058 declare var RTCDataChannelEvent: {
12059 prototype: RTCDataChannelEvent;
12060 new(type: string, eventInitDict: RTCDataChannelEventInit): RTCDataChannelEvent;
12063 interface RTCDtlsTransportEventMap {
12064 "error": RTCErrorEvent;
12065 "statechange": Event;
12068 interface RTCDtlsTransport extends EventTarget {
12069 readonly iceTransport: RTCIceTransport;
12070 onerror: ((this: RTCDtlsTransport, ev: RTCErrorEvent) => any) | null;
12071 onstatechange: ((this: RTCDtlsTransport, ev: Event) => any) | null;
12072 readonly state: RTCDtlsTransportState;
12073 getRemoteCertificates(): ArrayBuffer[];
12074 addEventListener<K extends keyof RTCDtlsTransportEventMap>(type: K, listener: (this: RTCDtlsTransport, ev: RTCDtlsTransportEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12075 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12076 removeEventListener<K extends keyof RTCDtlsTransportEventMap>(type: K, listener: (this: RTCDtlsTransport, ev: RTCDtlsTransportEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12077 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12080 declare var RTCDtlsTransport: {
12081 prototype: RTCDtlsTransport;
12082 new(): RTCDtlsTransport;
12085 interface RTCDtlsTransportStateChangedEvent extends Event {
12086 readonly state: RTCDtlsTransportState;
12089 declare var RTCDtlsTransportStateChangedEvent: {
12090 prototype: RTCDtlsTransportStateChangedEvent;
12091 new(): RTCDtlsTransportStateChangedEvent;
12094 interface RTCDtmfSenderEventMap {
12095 "tonechange": RTCDTMFToneChangeEvent;
12098 interface RTCDtmfSender extends EventTarget {
12099 readonly canInsertDTMF: boolean;
12100 readonly duration: number;
12101 readonly interToneGap: number;
12102 ontonechange: ((this: RTCDtmfSender, ev: RTCDTMFToneChangeEvent) => any) | null;
12103 readonly sender: RTCRtpSender;
12104 readonly toneBuffer: string;
12105 insertDTMF(tones: string, duration?: number, interToneGap?: number): void;
12106 addEventListener<K extends keyof RTCDtmfSenderEventMap>(type: K, listener: (this: RTCDtmfSender, ev: RTCDtmfSenderEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12107 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12108 removeEventListener<K extends keyof RTCDtmfSenderEventMap>(type: K, listener: (this: RTCDtmfSender, ev: RTCDtmfSenderEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12109 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12112 declare var RTCDtmfSender: {
12113 prototype: RTCDtmfSender;
12114 new(sender: RTCRtpSender): RTCDtmfSender;
12117 interface RTCError extends DOMException {
12118 readonly errorDetail: RTCErrorDetailType;
12119 readonly httpRequestStatusCode: number | null;
12120 readonly receivedAlert: number | null;
12121 readonly sctpCauseCode: number | null;
12122 readonly sdpLineNumber: number | null;
12123 readonly sentAlert: number | null;
12126 declare var RTCError: {
12127 prototype: RTCError;
12128 new(init: RTCErrorInit, message?: string): RTCError;
12131 interface RTCErrorEvent extends Event {
12132 readonly error: RTCError;
12135 declare var RTCErrorEvent: {
12136 prototype: RTCErrorEvent;
12137 new(type: string, eventInitDict: RTCErrorEventInit): RTCErrorEvent;
12140 /** The RTCIceCandidate interface—part of the WebRTC API—represents a candidate Internet Connectivity Establishment (ICE) configuration which may be used to establish an RTCPeerConnection. */
12141 interface RTCIceCandidate {
12142 readonly candidate: string;
12143 readonly component: RTCIceComponent | null;
12144 readonly foundation: string | null;
12145 readonly port: number | null;
12146 readonly priority: number | null;
12147 readonly protocol: RTCIceProtocol | null;
12148 readonly relatedAddress: string | null;
12149 readonly relatedPort: number | null;
12150 readonly sdpMLineIndex: number | null;
12151 readonly sdpMid: string | null;
12152 readonly tcpType: RTCIceTcpCandidateType | null;
12153 readonly type: RTCIceCandidateType | null;
12154 readonly usernameFragment: string | null;
12155 toJSON(): RTCIceCandidateInit;
12158 declare var RTCIceCandidate: {
12159 prototype: RTCIceCandidate;
12160 new(candidateInitDict?: RTCIceCandidateInit): RTCIceCandidate;
12163 interface RTCIceCandidatePairChangedEvent extends Event {
12164 readonly pair: RTCIceCandidatePair;
12167 declare var RTCIceCandidatePairChangedEvent: {
12168 prototype: RTCIceCandidatePairChangedEvent;
12169 new(): RTCIceCandidatePairChangedEvent;
12172 interface RTCIceGathererEventMap {
12174 "localcandidate": RTCIceGathererEvent;
12177 interface RTCIceGatherer extends RTCStatsProvider {
12178 readonly component: RTCIceComponent;
12179 onerror: ((this: RTCIceGatherer, ev: Event) => any) | null;
12180 onlocalcandidate: ((this: RTCIceGatherer, ev: RTCIceGathererEvent) => any) | null;
12181 createAssociatedGatherer(): RTCIceGatherer;
12182 getLocalCandidates(): RTCIceCandidateDictionary[];
12183 getLocalParameters(): RTCIceParameters;
12184 addEventListener<K extends keyof RTCIceGathererEventMap>(type: K, listener: (this: RTCIceGatherer, ev: RTCIceGathererEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12185 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12186 removeEventListener<K extends keyof RTCIceGathererEventMap>(type: K, listener: (this: RTCIceGatherer, ev: RTCIceGathererEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12187 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12190 declare var RTCIceGatherer: {
12191 prototype: RTCIceGatherer;
12192 new(options: RTCIceGatherOptions): RTCIceGatherer;
12195 interface RTCIceGathererEvent extends Event {
12196 readonly candidate: RTCIceCandidateDictionary | RTCIceCandidateComplete;
12199 declare var RTCIceGathererEvent: {
12200 prototype: RTCIceGathererEvent;
12201 new(): RTCIceGathererEvent;
12204 interface RTCIceTransportEventMap {
12205 "gatheringstatechange": Event;
12206 "selectedcandidatepairchange": Event;
12207 "statechange": Event;
12210 /** Provides access to information about the ICE transport layer over which the data is being sent and received. */
12211 interface RTCIceTransport extends EventTarget {
12212 readonly component: RTCIceComponent;
12213 readonly gatheringState: RTCIceGathererState;
12214 ongatheringstatechange: ((this: RTCIceTransport, ev: Event) => any) | null;
12215 onselectedcandidatepairchange: ((this: RTCIceTransport, ev: Event) => any) | null;
12216 onstatechange: ((this: RTCIceTransport, ev: Event) => any) | null;
12217 readonly role: RTCIceRole;
12218 readonly state: RTCIceTransportState;
12219 getLocalCandidates(): RTCIceCandidate[];
12220 getLocalParameters(): RTCIceParameters | null;
12221 getRemoteCandidates(): RTCIceCandidate[];
12222 getRemoteParameters(): RTCIceParameters | null;
12223 getSelectedCandidatePair(): RTCIceCandidatePair | null;
12224 addEventListener<K extends keyof RTCIceTransportEventMap>(type: K, listener: (this: RTCIceTransport, ev: RTCIceTransportEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12225 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12226 removeEventListener<K extends keyof RTCIceTransportEventMap>(type: K, listener: (this: RTCIceTransport, ev: RTCIceTransportEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12227 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12230 declare var RTCIceTransport: {
12231 prototype: RTCIceTransport;
12232 new(): RTCIceTransport;
12235 interface RTCIceTransportStateChangedEvent extends Event {
12236 readonly state: RTCIceTransportState;
12239 declare var RTCIceTransportStateChangedEvent: {
12240 prototype: RTCIceTransportStateChangedEvent;
12241 new(): RTCIceTransportStateChangedEvent;
12244 interface RTCIdentityAssertion {
12249 declare var RTCIdentityAssertion: {
12250 prototype: RTCIdentityAssertion;
12251 new(idp: string, name: string): RTCIdentityAssertion;
12254 interface RTCPeerConnectionEventMap {
12255 "connectionstatechange": Event;
12256 "datachannel": RTCDataChannelEvent;
12257 "icecandidate": RTCPeerConnectionIceEvent;
12258 "icecandidateerror": RTCPeerConnectionIceErrorEvent;
12259 "iceconnectionstatechange": Event;
12260 "icegatheringstatechange": Event;
12261 "negotiationneeded": Event;
12262 "signalingstatechange": Event;
12263 "statsended": RTCStatsEvent;
12264 "track": RTCTrackEvent;
12267 /** A WebRTC connection between the local computer and a remote peer. It provides methods to connect to a remote peer, maintain and monitor the connection, and close the connection once it's no longer needed. */
12268 interface RTCPeerConnection extends EventTarget {
12269 readonly canTrickleIceCandidates: boolean | null;
12270 readonly connectionState: RTCPeerConnectionState;
12271 readonly currentLocalDescription: RTCSessionDescription | null;
12272 readonly currentRemoteDescription: RTCSessionDescription | null;
12273 readonly iceConnectionState: RTCIceConnectionState;
12274 readonly iceGatheringState: RTCIceGatheringState;
12275 readonly idpErrorInfo: string | null;
12276 readonly idpLoginUrl: string | null;
12277 readonly localDescription: RTCSessionDescription | null;
12278 onconnectionstatechange: ((this: RTCPeerConnection, ev: Event) => any) | null;
12279 ondatachannel: ((this: RTCPeerConnection, ev: RTCDataChannelEvent) => any) | null;
12280 onicecandidate: ((this: RTCPeerConnection, ev: RTCPeerConnectionIceEvent) => any) | null;
12281 onicecandidateerror: ((this: RTCPeerConnection, ev: RTCPeerConnectionIceErrorEvent) => any) | null;
12282 oniceconnectionstatechange: ((this: RTCPeerConnection, ev: Event) => any) | null;
12283 onicegatheringstatechange: ((this: RTCPeerConnection, ev: Event) => any) | null;
12284 onnegotiationneeded: ((this: RTCPeerConnection, ev: Event) => any) | null;
12285 onsignalingstatechange: ((this: RTCPeerConnection, ev: Event) => any) | null;
12286 onstatsended: ((this: RTCPeerConnection, ev: RTCStatsEvent) => any) | null;
12287 ontrack: ((this: RTCPeerConnection, ev: RTCTrackEvent) => any) | null;
12288 readonly peerIdentity: Promise<RTCIdentityAssertion>;
12289 readonly pendingLocalDescription: RTCSessionDescription | null;
12290 readonly pendingRemoteDescription: RTCSessionDescription | null;
12291 readonly remoteDescription: RTCSessionDescription | null;
12292 readonly sctp: RTCSctpTransport | null;
12293 readonly signalingState: RTCSignalingState;
12294 addIceCandidate(candidate: RTCIceCandidateInit | RTCIceCandidate): Promise<void>;
12295 addTrack(track: MediaStreamTrack, ...streams: MediaStream[]): RTCRtpSender;
12296 addTransceiver(trackOrKind: MediaStreamTrack | string, init?: RTCRtpTransceiverInit): RTCRtpTransceiver;
12298 createAnswer(options?: RTCOfferOptions): Promise<RTCSessionDescriptionInit>;
12299 createDataChannel(label: string, dataChannelDict?: RTCDataChannelInit): RTCDataChannel;
12300 createOffer(options?: RTCOfferOptions): Promise<RTCSessionDescriptionInit>;
12301 getConfiguration(): RTCConfiguration;
12302 getIdentityAssertion(): Promise<string>;
12303 getReceivers(): RTCRtpReceiver[];
12304 getSenders(): RTCRtpSender[];
12305 getStats(selector?: MediaStreamTrack | null): Promise<RTCStatsReport>;
12306 getTransceivers(): RTCRtpTransceiver[];
12307 removeTrack(sender: RTCRtpSender): void;
12308 setConfiguration(configuration: RTCConfiguration): void;
12309 setIdentityProvider(provider: string, options?: RTCIdentityProviderOptions): void;
12310 setLocalDescription(description: RTCSessionDescriptionInit): Promise<void>;
12311 setRemoteDescription(description: RTCSessionDescriptionInit): Promise<void>;
12312 addEventListener<K extends keyof RTCPeerConnectionEventMap>(type: K, listener: (this: RTCPeerConnection, ev: RTCPeerConnectionEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12313 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12314 removeEventListener<K extends keyof RTCPeerConnectionEventMap>(type: K, listener: (this: RTCPeerConnection, ev: RTCPeerConnectionEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12315 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12318 declare var RTCPeerConnection: {
12319 prototype: RTCPeerConnection;
12320 new(configuration?: RTCConfiguration): RTCPeerConnection;
12321 generateCertificate(keygenAlgorithm: AlgorithmIdentifier): Promise<RTCCertificate>;
12322 getDefaultIceServers(): RTCIceServer[];
12325 interface RTCPeerConnectionIceErrorEvent extends Event {
12326 readonly errorCode: number;
12327 readonly errorText: string;
12328 readonly hostCandidate: string;
12329 readonly url: string;
12332 declare var RTCPeerConnectionIceErrorEvent: {
12333 prototype: RTCPeerConnectionIceErrorEvent;
12334 new(type: string, eventInitDict: RTCPeerConnectionIceErrorEventInit): RTCPeerConnectionIceErrorEvent;
12337 /** Events that occurs in relation to ICE candidates with the target, usually an RTCPeerConnection. Only one event is of this type: icecandidate. */
12338 interface RTCPeerConnectionIceEvent extends Event {
12339 readonly candidate: RTCIceCandidate | null;
12340 readonly url: string | null;
12343 declare var RTCPeerConnectionIceEvent: {
12344 prototype: RTCPeerConnectionIceEvent;
12345 new(type: string, eventInitDict?: RTCPeerConnectionIceEventInit): RTCPeerConnectionIceEvent;
12348 /** This WebRTC API interface manages the reception and decoding of data for a MediaStreamTrack on an RTCPeerConnection. */
12349 interface RTCRtpReceiver {
12350 readonly rtcpTransport: RTCDtlsTransport | null;
12351 readonly track: MediaStreamTrack;
12352 readonly transport: RTCDtlsTransport | null;
12353 getContributingSources(): RTCRtpContributingSource[];
12354 getParameters(): RTCRtpReceiveParameters;
12355 getStats(): Promise<RTCStatsReport>;
12356 getSynchronizationSources(): RTCRtpSynchronizationSource[];
12359 declare var RTCRtpReceiver: {
12360 prototype: RTCRtpReceiver;
12361 new(): RTCRtpReceiver;
12362 getCapabilities(kind: string): RTCRtpCapabilities | null;
12365 /** Provides the ability to control and obtain details about how a particular MediaStreamTrack is encoded and sent to a remote peer. */
12366 interface RTCRtpSender {
12367 readonly dtmf: RTCDTMFSender | null;
12368 readonly rtcpTransport: RTCDtlsTransport | null;
12369 readonly track: MediaStreamTrack | null;
12370 readonly transport: RTCDtlsTransport | null;
12371 getParameters(): RTCRtpSendParameters;
12372 getStats(): Promise<RTCStatsReport>;
12373 replaceTrack(withTrack: MediaStreamTrack | null): Promise<void>;
12374 setParameters(parameters: RTCRtpSendParameters): Promise<void>;
12375 setStreams(...streams: MediaStream[]): void;
12378 declare var RTCRtpSender: {
12379 prototype: RTCRtpSender;
12380 new(): RTCRtpSender;
12381 getCapabilities(kind: string): RTCRtpCapabilities | null;
12384 interface RTCRtpTransceiver {
12385 readonly currentDirection: RTCRtpTransceiverDirection | null;
12386 direction: RTCRtpTransceiverDirection;
12387 readonly mid: string | null;
12388 readonly receiver: RTCRtpReceiver;
12389 readonly sender: RTCRtpSender;
12390 setCodecPreferences(codecs: RTCRtpCodecCapability[]): void;
12394 declare var RTCRtpTransceiver: {
12395 prototype: RTCRtpTransceiver;
12396 new(): RTCRtpTransceiver;
12399 interface RTCSctpTransportEventMap {
12400 "statechange": Event;
12403 interface RTCSctpTransport extends EventTarget {
12404 readonly maxChannels: number | null;
12405 readonly maxMessageSize: number;
12406 onstatechange: ((this: RTCSctpTransport, ev: Event) => any) | null;
12407 readonly state: RTCSctpTransportState;
12408 readonly transport: RTCDtlsTransport;
12409 addEventListener<K extends keyof RTCSctpTransportEventMap>(type: K, listener: (this: RTCSctpTransport, ev: RTCSctpTransportEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12410 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12411 removeEventListener<K extends keyof RTCSctpTransportEventMap>(type: K, listener: (this: RTCSctpTransport, ev: RTCSctpTransportEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12412 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12415 declare var RTCSctpTransport: {
12416 prototype: RTCSctpTransport;
12417 new(): RTCSctpTransport;
12420 /** One end of a connection—or potential connection—and how it's configured. Each RTCSessionDescription consists of a description type indicating which part of the offer/answer negotiation process it describes and of the SDP descriptor of the session. */
12421 interface RTCSessionDescription {
12422 readonly sdp: string;
12423 readonly type: RTCSdpType;
12427 declare var RTCSessionDescription: {
12428 prototype: RTCSessionDescription;
12429 new(descriptionInitDict?: RTCSessionDescriptionInit): RTCSessionDescription;
12432 interface RTCSrtpSdesTransportEventMap {
12436 interface RTCSrtpSdesTransport extends EventTarget {
12437 onerror: ((this: RTCSrtpSdesTransport, ev: Event) => any) | null;
12438 readonly transport: RTCIceTransport;
12439 addEventListener<K extends keyof RTCSrtpSdesTransportEventMap>(type: K, listener: (this: RTCSrtpSdesTransport, ev: RTCSrtpSdesTransportEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12440 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12441 removeEventListener<K extends keyof RTCSrtpSdesTransportEventMap>(type: K, listener: (this: RTCSrtpSdesTransport, ev: RTCSrtpSdesTransportEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12442 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12445 declare var RTCSrtpSdesTransport: {
12446 prototype: RTCSrtpSdesTransport;
12447 new(transport: RTCIceTransport, encryptParameters: RTCSrtpSdesParameters, decryptParameters: RTCSrtpSdesParameters): RTCSrtpSdesTransport;
12448 getLocalParameters(): RTCSrtpSdesParameters[];
12451 interface RTCSsrcConflictEvent extends Event {
12452 readonly ssrc: number;
12455 declare var RTCSsrcConflictEvent: {
12456 prototype: RTCSsrcConflictEvent;
12457 new(): RTCSsrcConflictEvent;
12460 interface RTCStatsEvent extends Event {
12461 readonly report: RTCStatsReport;
12464 declare var RTCStatsEvent: {
12465 prototype: RTCStatsEvent;
12466 new(type: string, eventInitDict: RTCStatsEventInit): RTCStatsEvent;
12469 interface RTCStatsProvider extends EventTarget {
12470 getStats(): Promise<RTCStatsReport>;
12471 msGetStats(): Promise<RTCStatsReport>;
12474 declare var RTCStatsProvider: {
12475 prototype: RTCStatsProvider;
12476 new(): RTCStatsProvider;
12479 interface RTCStatsReport {
12480 forEach(callbackfn: (value: any, key: string, parent: RTCStatsReport) => void, thisArg?: any): void;
12483 declare var RTCStatsReport: {
12484 prototype: RTCStatsReport;
12485 new(): RTCStatsReport;
12488 interface RTCTrackEvent extends Event {
12489 readonly receiver: RTCRtpReceiver;
12490 readonly streams: ReadonlyArray<MediaStream>;
12491 readonly track: MediaStreamTrack;
12492 readonly transceiver: RTCRtpTransceiver;
12495 declare var RTCTrackEvent: {
12496 prototype: RTCTrackEvent;
12497 new(type: string, eventInitDict: RTCTrackEventInit): RTCTrackEvent;
12500 interface RadioNodeList extends NodeList {
12504 declare var RadioNodeList: {
12505 prototype: RadioNodeList;
12506 new(): RadioNodeList;
12509 interface RandomSource {
12510 getRandomValues<T extends Int8Array | Uint8ClampedArray | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array>(array: T): T;
12513 declare var RandomSource: {
12514 prototype: RandomSource;
12515 new(): RandomSource;
12518 /** A fragment of a document that can contain nodes and parts of text nodes. */
12519 interface Range extends AbstractRange {
12521 * Returns the node, furthest away from the document, that is an ancestor of both range's start node and end node.
12523 readonly commonAncestorContainer: Node;
12524 cloneContents(): DocumentFragment;
12525 cloneRange(): Range;
12526 collapse(toStart?: boolean): void;
12527 compareBoundaryPoints(how: number, sourceRange: Range): number;
12529 * Returns −1 if the point is before the range, 0 if the point is in the range, and 1 if the point is after the range.
12531 comparePoint(node: Node, offset: number): number;
12532 createContextualFragment(fragment: string): DocumentFragment;
12533 deleteContents(): void;
12535 extractContents(): DocumentFragment;
12536 getBoundingClientRect(): DOMRect;
12537 getClientRects(): DOMRectList;
12538 insertNode(node: Node): void;
12540 * Returns whether range intersects node.
12542 intersectsNode(node: Node): boolean;
12543 isPointInRange(node: Node, offset: number): boolean;
12544 selectNode(node: Node): void;
12545 selectNodeContents(node: Node): void;
12546 setEnd(node: Node, offset: number): void;
12547 setEndAfter(node: Node): void;
12548 setEndBefore(node: Node): void;
12549 setStart(node: Node, offset: number): void;
12550 setStartAfter(node: Node): void;
12551 setStartBefore(node: Node): void;
12552 surroundContents(newParent: Node): void;
12553 toString(): string;
12554 readonly END_TO_END: number;
12555 readonly END_TO_START: number;
12556 readonly START_TO_END: number;
12557 readonly START_TO_START: number;
12560 declare var Range: {
12563 readonly END_TO_END: number;
12564 readonly END_TO_START: number;
12565 readonly START_TO_END: number;
12566 readonly START_TO_START: number;
12567 toString(): string;
12570 /** This Streams API interface represents a readable stream of byte data. The Fetch API offers a concrete instance of a ReadableStream through the body property of a Response object. */
12571 interface ReadableStream<R = any> {
12572 readonly locked: boolean;
12573 cancel(reason?: any): Promise<void>;
12574 getReader(): ReadableStreamDefaultReader<R>;
12575 pipeThrough<T>(transform: ReadableWritablePair<T, R>, options?: StreamPipeOptions): ReadableStream<T>;
12576 pipeTo(dest: WritableStream<R>, options?: StreamPipeOptions): Promise<void>;
12577 tee(): [ReadableStream<R>, ReadableStream<R>];
12580 declare var ReadableStream: {
12581 prototype: ReadableStream;
12582 new<R = any>(underlyingSource?: UnderlyingSource<R>, strategy?: QueuingStrategy<R>): ReadableStream<R>;
12585 interface ReadableStreamDefaultController<R = any> {
12586 readonly desiredSize: number | null;
12588 enqueue(chunk: R): void;
12589 error(e?: any): void;
12592 declare var ReadableStreamDefaultController: {
12593 prototype: ReadableStreamDefaultController;
12594 new(): ReadableStreamDefaultController;
12597 interface ReadableStreamDefaultReader<R = any> extends ReadableStreamGenericReader {
12598 read(): Promise<ReadableStreamDefaultReadResult<R>>;
12599 releaseLock(): void;
12602 declare var ReadableStreamDefaultReader: {
12603 prototype: ReadableStreamDefaultReader;
12604 new<R = any>(stream: ReadableStream<R>): ReadableStreamDefaultReader<R>;
12607 interface ReadableStreamGenericReader {
12608 readonly closed: Promise<undefined>;
12609 cancel(reason?: any): Promise<void>;
12612 /** This Fetch API interface represents a resource request. */
12613 interface Request extends Body {
12615 * Returns the cache mode associated with request, which is a string indicating how the request will interact with the browser's cache when fetching.
12617 readonly cache: RequestCache;
12619 * Returns the credentials mode associated with request, which is a string indicating whether credentials will be sent with the request always, never, or only when sent to a same-origin URL.
12621 readonly credentials: RequestCredentials;
12623 * Returns the kind of resource requested by request, e.g., "document" or "script".
12625 readonly destination: RequestDestination;
12627 * Returns a Headers object consisting of the headers associated with request. Note that headers added in the network layer by the user agent will not be accounted for in this object, e.g., the "Host" header.
12629 readonly headers: Headers;
12631 * Returns request's subresource integrity metadata, which is a cryptographic hash of the resource being fetched. Its value consists of multiple hashes separated by whitespace. [SRI]
12633 readonly integrity: string;
12635 * Returns a boolean indicating whether or not request is for a history navigation (a.k.a. back-foward navigation).
12637 readonly isHistoryNavigation: boolean;
12639 * Returns a boolean indicating whether or not request is for a reload navigation.
12641 readonly isReloadNavigation: boolean;
12643 * Returns a boolean indicating whether or not request can outlive the global in which it was created.
12645 readonly keepalive: boolean;
12647 * Returns request's HTTP method, which is "GET" by default.
12649 readonly method: string;
12651 * Returns the mode associated with request, which is a string indicating whether the request will use CORS, or will be restricted to same-origin URLs.
12653 readonly mode: RequestMode;
12655 * Returns the redirect mode associated with request, which is a string indicating how redirects for the request will be handled during fetching. A request will follow redirects by default.
12657 readonly redirect: RequestRedirect;
12659 * Returns the referrer of request. Its value can be a same-origin URL if explicitly set in init, the empty string to indicate no referrer, and "about:client" when defaulting to the global's default. This is used during fetching to determine the value of the `Referer` header of the request being made.
12661 readonly referrer: string;
12663 * Returns the referrer policy associated with request. This is used during fetching to compute the value of the request's referrer.
12665 readonly referrerPolicy: ReferrerPolicy;
12667 * Returns the signal associated with request, which is an AbortSignal object indicating whether or not request has been aborted, and its abort event handler.
12669 readonly signal: AbortSignal;
12671 * Returns the URL of request as a string.
12673 readonly url: string;
12677 declare var Request: {
12678 prototype: Request;
12679 new(input: RequestInfo, init?: RequestInit): Request;
12682 interface ResizeObserver {
12683 disconnect(): void;
12684 observe(target: Element, options?: ResizeObserverOptions): void;
12685 unobserve(target: Element): void;
12688 declare var ResizeObserver: {
12689 prototype: ResizeObserver;
12690 new(callback: ResizeObserverCallback): ResizeObserver;
12693 interface ResizeObserverEntry {
12694 readonly borderBoxSize: ReadonlyArray<ResizeObserverSize>;
12695 readonly contentBoxSize: ReadonlyArray<ResizeObserverSize>;
12696 readonly contentRect: DOMRectReadOnly;
12697 readonly target: Element;
12700 declare var ResizeObserverEntry: {
12701 prototype: ResizeObserverEntry;
12702 new(): ResizeObserverEntry;
12705 interface ResizeObserverSize {
12706 readonly blockSize: number;
12707 readonly inlineSize: number;
12710 declare var ResizeObserverSize: {
12711 prototype: ResizeObserverSize;
12712 new(): ResizeObserverSize;
12715 /** This Fetch API interface represents the response to a request. */
12716 interface Response extends Body {
12717 readonly headers: Headers;
12718 readonly ok: boolean;
12719 readonly redirected: boolean;
12720 readonly status: number;
12721 readonly statusText: string;
12722 readonly trailer: Promise<Headers>;
12723 readonly type: ResponseType;
12724 readonly url: string;
12728 declare var Response: {
12729 prototype: Response;
12730 new(body?: BodyInit | null, init?: ResponseInit): Response;
12732 redirect(url: string, status?: number): Response;
12735 /** Provides access to the properties of <a> element, as well as methods to manipulate them. */
12736 interface SVGAElement extends SVGGraphicsElement, SVGURIReference {
12737 readonly target: SVGAnimatedString;
12738 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGAElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12739 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12740 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGAElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12741 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12744 declare var SVGAElement: {
12745 prototype: SVGAElement;
12746 new(): SVGAElement;
12749 /** Used to represent a value that can be an <angle> or <number> value. An SVGAngle reflected through the animVal attribute is always read only. */
12750 interface SVGAngle {
12751 readonly unitType: number;
12753 valueAsString: string;
12754 valueInSpecifiedUnits: number;
12755 convertToSpecifiedUnits(unitType: number): void;
12756 newValueSpecifiedUnits(unitType: number, valueInSpecifiedUnits: number): void;
12757 readonly SVG_ANGLETYPE_DEG: number;
12758 readonly SVG_ANGLETYPE_GRAD: number;
12759 readonly SVG_ANGLETYPE_RAD: number;
12760 readonly SVG_ANGLETYPE_UNKNOWN: number;
12761 readonly SVG_ANGLETYPE_UNSPECIFIED: number;
12764 declare var SVGAngle: {
12765 prototype: SVGAngle;
12767 readonly SVG_ANGLETYPE_DEG: number;
12768 readonly SVG_ANGLETYPE_GRAD: number;
12769 readonly SVG_ANGLETYPE_RAD: number;
12770 readonly SVG_ANGLETYPE_UNKNOWN: number;
12771 readonly SVG_ANGLETYPE_UNSPECIFIED: number;
12774 interface SVGAnimateElement extends SVGAnimationElement {
12775 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGAnimateElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12776 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12777 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGAnimateElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12778 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12781 declare var SVGAnimateElement: {
12782 prototype: SVGAnimateElement;
12783 new(): SVGAnimateElement;
12786 interface SVGAnimateMotionElement extends SVGAnimationElement {
12787 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGAnimateMotionElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12788 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12789 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGAnimateMotionElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12790 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12793 declare var SVGAnimateMotionElement: {
12794 prototype: SVGAnimateMotionElement;
12795 new(): SVGAnimateMotionElement;
12798 interface SVGAnimateTransformElement extends SVGAnimationElement {
12799 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGAnimateTransformElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12800 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12801 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGAnimateTransformElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12802 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12805 declare var SVGAnimateTransformElement: {
12806 prototype: SVGAnimateTransformElement;
12807 new(): SVGAnimateTransformElement;
12810 /** Used for attributes of basic type <angle> which can be animated. */
12811 interface SVGAnimatedAngle {
12812 readonly animVal: SVGAngle;
12813 readonly baseVal: SVGAngle;
12816 declare var SVGAnimatedAngle: {
12817 prototype: SVGAnimatedAngle;
12818 new(): SVGAnimatedAngle;
12821 /** Used for attributes of type boolean which can be animated. */
12822 interface SVGAnimatedBoolean {
12823 readonly animVal: boolean;
12827 declare var SVGAnimatedBoolean: {
12828 prototype: SVGAnimatedBoolean;
12829 new(): SVGAnimatedBoolean;
12832 /** Used for attributes whose value must be a constant from a particular enumeration and which can be animated. */
12833 interface SVGAnimatedEnumeration {
12834 readonly animVal: number;
12838 declare var SVGAnimatedEnumeration: {
12839 prototype: SVGAnimatedEnumeration;
12840 new(): SVGAnimatedEnumeration;
12843 /** Used for attributes of basic type <integer> which can be animated. */
12844 interface SVGAnimatedInteger {
12845 readonly animVal: number;
12849 declare var SVGAnimatedInteger: {
12850 prototype: SVGAnimatedInteger;
12851 new(): SVGAnimatedInteger;
12854 /** Used for attributes of basic type <length> which can be animated. */
12855 interface SVGAnimatedLength {
12856 readonly animVal: SVGLength;
12857 readonly baseVal: SVGLength;
12860 declare var SVGAnimatedLength: {
12861 prototype: SVGAnimatedLength;
12862 new(): SVGAnimatedLength;
12865 /** Used for attributes of type SVGLengthList which can be animated. */
12866 interface SVGAnimatedLengthList {
12867 readonly animVal: SVGLengthList;
12868 readonly baseVal: SVGLengthList;
12871 declare var SVGAnimatedLengthList: {
12872 prototype: SVGAnimatedLengthList;
12873 new(): SVGAnimatedLengthList;
12876 /** Used for attributes of basic type <Number> which can be animated. */
12877 interface SVGAnimatedNumber {
12878 readonly animVal: number;
12882 declare var SVGAnimatedNumber: {
12883 prototype: SVGAnimatedNumber;
12884 new(): SVGAnimatedNumber;
12887 /** The SVGAnimatedNumber interface is used for attributes which take a list of numbers and which can be animated. */
12888 interface SVGAnimatedNumberList {
12889 readonly animVal: SVGNumberList;
12890 readonly baseVal: SVGNumberList;
12893 declare var SVGAnimatedNumberList: {
12894 prototype: SVGAnimatedNumberList;
12895 new(): SVGAnimatedNumberList;
12898 interface SVGAnimatedPoints {
12899 readonly animatedPoints: SVGPointList;
12900 readonly points: SVGPointList;
12903 /** Used for attributes of type SVGPreserveAspectRatio which can be animated. */
12904 interface SVGAnimatedPreserveAspectRatio {
12905 readonly animVal: SVGPreserveAspectRatio;
12906 readonly baseVal: SVGPreserveAspectRatio;
12909 declare var SVGAnimatedPreserveAspectRatio: {
12910 prototype: SVGAnimatedPreserveAspectRatio;
12911 new(): SVGAnimatedPreserveAspectRatio;
12914 /** Used for attributes of basic SVGRect which can be animated. */
12915 interface SVGAnimatedRect {
12916 readonly animVal: DOMRectReadOnly;
12917 readonly baseVal: DOMRect;
12920 declare var SVGAnimatedRect: {
12921 prototype: SVGAnimatedRect;
12922 new(): SVGAnimatedRect;
12925 /** The SVGAnimatedString interface represents string attributes which can be animated from each SVG declaration. You need to create SVG attribute before doing anything else, everything should be declared inside this. */
12926 interface SVGAnimatedString {
12927 readonly animVal: string;
12931 declare var SVGAnimatedString: {
12932 prototype: SVGAnimatedString;
12933 new(): SVGAnimatedString;
12936 /** Used for attributes which take a list of numbers and which can be animated. */
12937 interface SVGAnimatedTransformList {
12938 readonly animVal: SVGTransformList;
12939 readonly baseVal: SVGTransformList;
12942 declare var SVGAnimatedTransformList: {
12943 prototype: SVGAnimatedTransformList;
12944 new(): SVGAnimatedTransformList;
12947 interface SVGAnimationElement extends SVGElement {
12948 readonly targetElement: SVGElement;
12949 getCurrentTime(): number;
12950 getSimpleDuration(): number;
12951 getStartTime(): number;
12952 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGAnimationElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12953 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12954 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGAnimationElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12955 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12958 declare var SVGAnimationElement: {
12959 prototype: SVGAnimationElement;
12960 new(): SVGAnimationElement;
12963 /** An interface for the <circle> element. The circle element is defined by the cx and cy attributes that denote the coordinates of the centre of the circle. */
12964 interface SVGCircleElement extends SVGGeometryElement {
12965 readonly cx: SVGAnimatedLength;
12966 readonly cy: SVGAnimatedLength;
12967 readonly r: SVGAnimatedLength;
12968 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGCircleElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12969 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12970 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGCircleElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12971 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12974 declare var SVGCircleElement: {
12975 prototype: SVGCircleElement;
12976 new(): SVGCircleElement;
12979 /** Provides access to the properties of <clipPath> elements, as well as methods to manipulate them. */
12980 interface SVGClipPathElement extends SVGElement {
12981 readonly clipPathUnits: SVGAnimatedEnumeration;
12982 readonly transform: SVGAnimatedTransformList;
12983 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGClipPathElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12984 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12985 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGClipPathElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12986 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12989 declare var SVGClipPathElement: {
12990 prototype: SVGClipPathElement;
12991 new(): SVGClipPathElement;
12994 /** A base interface used by the component transfer function interfaces. */
12995 interface SVGComponentTransferFunctionElement extends SVGElement {
12996 readonly amplitude: SVGAnimatedNumber;
12997 readonly exponent: SVGAnimatedNumber;
12998 readonly intercept: SVGAnimatedNumber;
12999 readonly offset: SVGAnimatedNumber;
13000 readonly slope: SVGAnimatedNumber;
13001 readonly tableValues: SVGAnimatedNumberList;
13002 readonly type: SVGAnimatedEnumeration;
13003 readonly SVG_FECOMPONENTTRANSFER_TYPE_DISCRETE: number;
13004 readonly SVG_FECOMPONENTTRANSFER_TYPE_GAMMA: number;
13005 readonly SVG_FECOMPONENTTRANSFER_TYPE_IDENTITY: number;
13006 readonly SVG_FECOMPONENTTRANSFER_TYPE_LINEAR: number;
13007 readonly SVG_FECOMPONENTTRANSFER_TYPE_TABLE: number;
13008 readonly SVG_FECOMPONENTTRANSFER_TYPE_UNKNOWN: number;
13009 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGComponentTransferFunctionElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13010 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13011 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGComponentTransferFunctionElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13012 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13015 declare var SVGComponentTransferFunctionElement: {
13016 prototype: SVGComponentTransferFunctionElement;
13017 new(): SVGComponentTransferFunctionElement;
13018 readonly SVG_FECOMPONENTTRANSFER_TYPE_DISCRETE: number;
13019 readonly SVG_FECOMPONENTTRANSFER_TYPE_GAMMA: number;
13020 readonly SVG_FECOMPONENTTRANSFER_TYPE_IDENTITY: number;
13021 readonly SVG_FECOMPONENTTRANSFER_TYPE_LINEAR: number;
13022 readonly SVG_FECOMPONENTTRANSFER_TYPE_TABLE: number;
13023 readonly SVG_FECOMPONENTTRANSFER_TYPE_UNKNOWN: number;
13026 interface SVGCursorElement extends SVGElement {
13027 readonly x: SVGAnimatedLength;
13028 readonly y: SVGAnimatedLength;
13029 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGCursorElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13030 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13031 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGCursorElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13032 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13035 declare var SVGCursorElement: {
13036 prototype: SVGCursorElement;
13037 new(): SVGCursorElement;
13040 /** Corresponds to the <defs> element. */
13041 interface SVGDefsElement extends SVGGraphicsElement {
13042 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGDefsElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13043 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13044 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGDefsElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13045 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13048 declare var SVGDefsElement: {
13049 prototype: SVGDefsElement;
13050 new(): SVGDefsElement;
13053 /** Corresponds to the <desc> element. */
13054 interface SVGDescElement extends SVGElement {
13055 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGDescElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13056 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13057 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGDescElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13058 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13061 declare var SVGDescElement: {
13062 prototype: SVGDescElement;
13063 new(): SVGDescElement;
13066 interface SVGElementEventMap extends ElementEventMap, GlobalEventHandlersEventMap, DocumentAndElementEventHandlersEventMap {
13069 /** All of the SVG DOM interfaces that correspond directly to elements in the SVG language derive from the SVGElement interface. */
13070 interface SVGElement extends Element, DocumentAndElementEventHandlers, DocumentAndElementEventHandlers, ElementCSSInlineStyle, GlobalEventHandlers, GlobalEventHandlers, HTMLOrSVGElement, SVGElementInstance {
13072 readonly className: any;
13073 readonly ownerSVGElement: SVGSVGElement | null;
13074 readonly viewportElement: SVGElement | null;
13075 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13076 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13077 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13078 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13081 declare var SVGElement: {
13082 prototype: SVGElement;
13086 interface SVGElementInstance extends EventTarget {
13087 readonly correspondingElement: SVGElement;
13088 readonly correspondingUseElement: SVGUseElement;
13091 declare var SVGElementInstance: {
13092 prototype: SVGElementInstance;
13093 new(): SVGElementInstance;
13096 interface SVGElementInstanceList {
13098 readonly length: number;
13100 item(index: number): SVGElementInstance;
13103 declare var SVGElementInstanceList: {
13104 prototype: SVGElementInstanceList;
13105 new(): SVGElementInstanceList;
13108 /** Provides access to the properties of <ellipse> elements. */
13109 interface SVGEllipseElement extends SVGGeometryElement {
13110 readonly cx: SVGAnimatedLength;
13111 readonly cy: SVGAnimatedLength;
13112 readonly rx: SVGAnimatedLength;
13113 readonly ry: SVGAnimatedLength;
13114 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGEllipseElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13115 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13116 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGEllipseElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13117 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13120 declare var SVGEllipseElement: {
13121 prototype: SVGEllipseElement;
13122 new(): SVGEllipseElement;
13125 /** Corresponds to the <feBlend> element. */
13126 interface SVGFEBlendElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13127 readonly in1: SVGAnimatedString;
13128 readonly in2: SVGAnimatedString;
13129 readonly mode: SVGAnimatedEnumeration;
13130 readonly SVG_FEBLEND_MODE_COLOR: number;
13131 readonly SVG_FEBLEND_MODE_COLOR_BURN: number;
13132 readonly SVG_FEBLEND_MODE_COLOR_DODGE: number;
13133 readonly SVG_FEBLEND_MODE_DARKEN: number;
13134 readonly SVG_FEBLEND_MODE_DIFFERENCE: number;
13135 readonly SVG_FEBLEND_MODE_EXCLUSION: number;
13136 readonly SVG_FEBLEND_MODE_HARD_LIGHT: number;
13137 readonly SVG_FEBLEND_MODE_HUE: number;
13138 readonly SVG_FEBLEND_MODE_LIGHTEN: number;
13139 readonly SVG_FEBLEND_MODE_LUMINOSITY: number;
13140 readonly SVG_FEBLEND_MODE_MULTIPLY: number;
13141 readonly SVG_FEBLEND_MODE_NORMAL: number;
13142 readonly SVG_FEBLEND_MODE_OVERLAY: number;
13143 readonly SVG_FEBLEND_MODE_SATURATION: number;
13144 readonly SVG_FEBLEND_MODE_SCREEN: number;
13145 readonly SVG_FEBLEND_MODE_SOFT_LIGHT: number;
13146 readonly SVG_FEBLEND_MODE_UNKNOWN: number;
13147 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEBlendElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13148 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13149 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEBlendElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13150 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13153 declare var SVGFEBlendElement: {
13154 prototype: SVGFEBlendElement;
13155 new(): SVGFEBlendElement;
13156 readonly SVG_FEBLEND_MODE_COLOR: number;
13157 readonly SVG_FEBLEND_MODE_COLOR_BURN: number;
13158 readonly SVG_FEBLEND_MODE_COLOR_DODGE: number;
13159 readonly SVG_FEBLEND_MODE_DARKEN: number;
13160 readonly SVG_FEBLEND_MODE_DIFFERENCE: number;
13161 readonly SVG_FEBLEND_MODE_EXCLUSION: number;
13162 readonly SVG_FEBLEND_MODE_HARD_LIGHT: number;
13163 readonly SVG_FEBLEND_MODE_HUE: number;
13164 readonly SVG_FEBLEND_MODE_LIGHTEN: number;
13165 readonly SVG_FEBLEND_MODE_LUMINOSITY: number;
13166 readonly SVG_FEBLEND_MODE_MULTIPLY: number;
13167 readonly SVG_FEBLEND_MODE_NORMAL: number;
13168 readonly SVG_FEBLEND_MODE_OVERLAY: number;
13169 readonly SVG_FEBLEND_MODE_SATURATION: number;
13170 readonly SVG_FEBLEND_MODE_SCREEN: number;
13171 readonly SVG_FEBLEND_MODE_SOFT_LIGHT: number;
13172 readonly SVG_FEBLEND_MODE_UNKNOWN: number;
13175 /** Corresponds to the <feColorMatrix> element. */
13176 interface SVGFEColorMatrixElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13177 readonly in1: SVGAnimatedString;
13178 readonly type: SVGAnimatedEnumeration;
13179 readonly values: SVGAnimatedNumberList;
13180 readonly SVG_FECOLORMATRIX_TYPE_HUEROTATE: number;
13181 readonly SVG_FECOLORMATRIX_TYPE_LUMINANCETOALPHA: number;
13182 readonly SVG_FECOLORMATRIX_TYPE_MATRIX: number;
13183 readonly SVG_FECOLORMATRIX_TYPE_SATURATE: number;
13184 readonly SVG_FECOLORMATRIX_TYPE_UNKNOWN: number;
13185 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEColorMatrixElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13186 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13187 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEColorMatrixElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13188 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13191 declare var SVGFEColorMatrixElement: {
13192 prototype: SVGFEColorMatrixElement;
13193 new(): SVGFEColorMatrixElement;
13194 readonly SVG_FECOLORMATRIX_TYPE_HUEROTATE: number;
13195 readonly SVG_FECOLORMATRIX_TYPE_LUMINANCETOALPHA: number;
13196 readonly SVG_FECOLORMATRIX_TYPE_MATRIX: number;
13197 readonly SVG_FECOLORMATRIX_TYPE_SATURATE: number;
13198 readonly SVG_FECOLORMATRIX_TYPE_UNKNOWN: number;
13201 /** Corresponds to the <feComponentTransfer> element. */
13202 interface SVGFEComponentTransferElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13203 readonly in1: SVGAnimatedString;
13204 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEComponentTransferElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13205 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13206 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEComponentTransferElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13207 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13210 declare var SVGFEComponentTransferElement: {
13211 prototype: SVGFEComponentTransferElement;
13212 new(): SVGFEComponentTransferElement;
13215 /** Corresponds to the <feComposite> element. */
13216 interface SVGFECompositeElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13217 readonly in1: SVGAnimatedString;
13218 readonly in2: SVGAnimatedString;
13219 readonly k1: SVGAnimatedNumber;
13220 readonly k2: SVGAnimatedNumber;
13221 readonly k3: SVGAnimatedNumber;
13222 readonly k4: SVGAnimatedNumber;
13223 readonly operator: SVGAnimatedEnumeration;
13224 readonly SVG_FECOMPOSITE_OPERATOR_ARITHMETIC: number;
13225 readonly SVG_FECOMPOSITE_OPERATOR_ATOP: number;
13226 readonly SVG_FECOMPOSITE_OPERATOR_IN: number;
13227 readonly SVG_FECOMPOSITE_OPERATOR_OUT: number;
13228 readonly SVG_FECOMPOSITE_OPERATOR_OVER: number;
13229 readonly SVG_FECOMPOSITE_OPERATOR_UNKNOWN: number;
13230 readonly SVG_FECOMPOSITE_OPERATOR_XOR: number;
13231 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFECompositeElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13232 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13233 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFECompositeElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13234 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13237 declare var SVGFECompositeElement: {
13238 prototype: SVGFECompositeElement;
13239 new(): SVGFECompositeElement;
13240 readonly SVG_FECOMPOSITE_OPERATOR_ARITHMETIC: number;
13241 readonly SVG_FECOMPOSITE_OPERATOR_ATOP: number;
13242 readonly SVG_FECOMPOSITE_OPERATOR_IN: number;
13243 readonly SVG_FECOMPOSITE_OPERATOR_OUT: number;
13244 readonly SVG_FECOMPOSITE_OPERATOR_OVER: number;
13245 readonly SVG_FECOMPOSITE_OPERATOR_UNKNOWN: number;
13246 readonly SVG_FECOMPOSITE_OPERATOR_XOR: number;
13249 /** Corresponds to the <feConvolveMatrix> element. */
13250 interface SVGFEConvolveMatrixElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13251 readonly bias: SVGAnimatedNumber;
13252 readonly divisor: SVGAnimatedNumber;
13253 readonly edgeMode: SVGAnimatedEnumeration;
13254 readonly in1: SVGAnimatedString;
13255 readonly kernelMatrix: SVGAnimatedNumberList;
13256 readonly kernelUnitLengthX: SVGAnimatedNumber;
13257 readonly kernelUnitLengthY: SVGAnimatedNumber;
13258 readonly orderX: SVGAnimatedInteger;
13259 readonly orderY: SVGAnimatedInteger;
13260 readonly preserveAlpha: SVGAnimatedBoolean;
13261 readonly targetX: SVGAnimatedInteger;
13262 readonly targetY: SVGAnimatedInteger;
13263 readonly SVG_EDGEMODE_DUPLICATE: number;
13264 readonly SVG_EDGEMODE_NONE: number;
13265 readonly SVG_EDGEMODE_UNKNOWN: number;
13266 readonly SVG_EDGEMODE_WRAP: number;
13267 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEConvolveMatrixElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13268 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13269 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEConvolveMatrixElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13270 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13273 declare var SVGFEConvolveMatrixElement: {
13274 prototype: SVGFEConvolveMatrixElement;
13275 new(): SVGFEConvolveMatrixElement;
13276 readonly SVG_EDGEMODE_DUPLICATE: number;
13277 readonly SVG_EDGEMODE_NONE: number;
13278 readonly SVG_EDGEMODE_UNKNOWN: number;
13279 readonly SVG_EDGEMODE_WRAP: number;
13282 /** Corresponds to the <feDiffuseLighting> element. */
13283 interface SVGFEDiffuseLightingElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13284 readonly diffuseConstant: SVGAnimatedNumber;
13285 readonly in1: SVGAnimatedString;
13286 readonly kernelUnitLengthX: SVGAnimatedNumber;
13287 readonly kernelUnitLengthY: SVGAnimatedNumber;
13288 readonly surfaceScale: SVGAnimatedNumber;
13289 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEDiffuseLightingElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13290 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13291 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEDiffuseLightingElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13292 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13295 declare var SVGFEDiffuseLightingElement: {
13296 prototype: SVGFEDiffuseLightingElement;
13297 new(): SVGFEDiffuseLightingElement;
13300 /** Corresponds to the <feDisplacementMap> element. */
13301 interface SVGFEDisplacementMapElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13302 readonly in1: SVGAnimatedString;
13303 readonly in2: SVGAnimatedString;
13304 readonly scale: SVGAnimatedNumber;
13305 readonly xChannelSelector: SVGAnimatedEnumeration;
13306 readonly yChannelSelector: SVGAnimatedEnumeration;
13307 readonly SVG_CHANNEL_A: number;
13308 readonly SVG_CHANNEL_B: number;
13309 readonly SVG_CHANNEL_G: number;
13310 readonly SVG_CHANNEL_R: number;
13311 readonly SVG_CHANNEL_UNKNOWN: number;
13312 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEDisplacementMapElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13313 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13314 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEDisplacementMapElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13315 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13318 declare var SVGFEDisplacementMapElement: {
13319 prototype: SVGFEDisplacementMapElement;
13320 new(): SVGFEDisplacementMapElement;
13321 readonly SVG_CHANNEL_A: number;
13322 readonly SVG_CHANNEL_B: number;
13323 readonly SVG_CHANNEL_G: number;
13324 readonly SVG_CHANNEL_R: number;
13325 readonly SVG_CHANNEL_UNKNOWN: number;
13328 /** Corresponds to the <feDistantLight> element. */
13329 interface SVGFEDistantLightElement extends SVGElement {
13330 readonly azimuth: SVGAnimatedNumber;
13331 readonly elevation: SVGAnimatedNumber;
13332 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEDistantLightElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13333 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13334 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEDistantLightElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13335 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13338 declare var SVGFEDistantLightElement: {
13339 prototype: SVGFEDistantLightElement;
13340 new(): SVGFEDistantLightElement;
13343 interface SVGFEDropShadowElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13344 readonly dx: SVGAnimatedNumber;
13345 readonly dy: SVGAnimatedNumber;
13346 readonly in1: SVGAnimatedString;
13347 readonly stdDeviationX: SVGAnimatedNumber;
13348 readonly stdDeviationY: SVGAnimatedNumber;
13349 setStdDeviation(stdDeviationX: number, stdDeviationY: number): void;
13350 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEDropShadowElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13351 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13352 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEDropShadowElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13353 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13356 declare var SVGFEDropShadowElement: {
13357 prototype: SVGFEDropShadowElement;
13358 new(): SVGFEDropShadowElement;
13361 /** Corresponds to the <feFlood> element. */
13362 interface SVGFEFloodElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13363 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEFloodElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13364 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13365 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEFloodElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13366 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13369 declare var SVGFEFloodElement: {
13370 prototype: SVGFEFloodElement;
13371 new(): SVGFEFloodElement;
13374 /** Corresponds to the <feFuncA> element. */
13375 interface SVGFEFuncAElement extends SVGComponentTransferFunctionElement {
13376 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEFuncAElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13377 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13378 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEFuncAElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13379 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13382 declare var SVGFEFuncAElement: {
13383 prototype: SVGFEFuncAElement;
13384 new(): SVGFEFuncAElement;
13387 /** Corresponds to the <feFuncB> element. */
13388 interface SVGFEFuncBElement extends SVGComponentTransferFunctionElement {
13389 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEFuncBElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13390 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13391 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEFuncBElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13392 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13395 declare var SVGFEFuncBElement: {
13396 prototype: SVGFEFuncBElement;
13397 new(): SVGFEFuncBElement;
13400 /** Corresponds to the <feFuncG> element. */
13401 interface SVGFEFuncGElement extends SVGComponentTransferFunctionElement {
13402 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEFuncGElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13403 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13404 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEFuncGElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13405 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13408 declare var SVGFEFuncGElement: {
13409 prototype: SVGFEFuncGElement;
13410 new(): SVGFEFuncGElement;
13413 /** Corresponds to the <feFuncR> element. */
13414 interface SVGFEFuncRElement extends SVGComponentTransferFunctionElement {
13415 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEFuncRElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13416 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13417 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEFuncRElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13418 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13421 declare var SVGFEFuncRElement: {
13422 prototype: SVGFEFuncRElement;
13423 new(): SVGFEFuncRElement;
13426 /** Corresponds to the <feGaussianBlur> element. */
13427 interface SVGFEGaussianBlurElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13428 readonly in1: SVGAnimatedString;
13429 readonly stdDeviationX: SVGAnimatedNumber;
13430 readonly stdDeviationY: SVGAnimatedNumber;
13431 setStdDeviation(stdDeviationX: number, stdDeviationY: number): void;
13432 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEGaussianBlurElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13433 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13434 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEGaussianBlurElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13435 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13438 declare var SVGFEGaussianBlurElement: {
13439 prototype: SVGFEGaussianBlurElement;
13440 new(): SVGFEGaussianBlurElement;
13443 /** Corresponds to the <feImage> element. */
13444 interface SVGFEImageElement extends SVGElement, SVGFilterPrimitiveStandardAttributes, SVGURIReference {
13445 readonly preserveAspectRatio: SVGAnimatedPreserveAspectRatio;
13446 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEImageElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13447 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13448 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEImageElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13449 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13452 declare var SVGFEImageElement: {
13453 prototype: SVGFEImageElement;
13454 new(): SVGFEImageElement;
13457 /** Corresponds to the <feMerge> element. */
13458 interface SVGFEMergeElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13459 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEMergeElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13460 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13461 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEMergeElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13462 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13465 declare var SVGFEMergeElement: {
13466 prototype: SVGFEMergeElement;
13467 new(): SVGFEMergeElement;
13470 /** Corresponds to the <feMergeNode> element. */
13471 interface SVGFEMergeNodeElement extends SVGElement {
13472 readonly in1: SVGAnimatedString;
13473 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEMergeNodeElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13474 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13475 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEMergeNodeElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13476 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13479 declare var SVGFEMergeNodeElement: {
13480 prototype: SVGFEMergeNodeElement;
13481 new(): SVGFEMergeNodeElement;
13484 /** Corresponds to the <feMorphology> element. */
13485 interface SVGFEMorphologyElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13486 readonly in1: SVGAnimatedString;
13487 readonly operator: SVGAnimatedEnumeration;
13488 readonly radiusX: SVGAnimatedNumber;
13489 readonly radiusY: SVGAnimatedNumber;
13490 readonly SVG_MORPHOLOGY_OPERATOR_DILATE: number;
13491 readonly SVG_MORPHOLOGY_OPERATOR_ERODE: number;
13492 readonly SVG_MORPHOLOGY_OPERATOR_UNKNOWN: number;
13493 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEMorphologyElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13494 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13495 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEMorphologyElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13496 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13499 declare var SVGFEMorphologyElement: {
13500 prototype: SVGFEMorphologyElement;
13501 new(): SVGFEMorphologyElement;
13502 readonly SVG_MORPHOLOGY_OPERATOR_DILATE: number;
13503 readonly SVG_MORPHOLOGY_OPERATOR_ERODE: number;
13504 readonly SVG_MORPHOLOGY_OPERATOR_UNKNOWN: number;
13507 /** Corresponds to the <feOffset> element. */
13508 interface SVGFEOffsetElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13509 readonly dx: SVGAnimatedNumber;
13510 readonly dy: SVGAnimatedNumber;
13511 readonly in1: SVGAnimatedString;
13512 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEOffsetElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13513 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13514 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEOffsetElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13515 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13518 declare var SVGFEOffsetElement: {
13519 prototype: SVGFEOffsetElement;
13520 new(): SVGFEOffsetElement;
13523 /** Corresponds to the <fePointLight> element. */
13524 interface SVGFEPointLightElement extends SVGElement {
13525 readonly x: SVGAnimatedNumber;
13526 readonly y: SVGAnimatedNumber;
13527 readonly z: SVGAnimatedNumber;
13528 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEPointLightElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13529 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13530 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEPointLightElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13531 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13534 declare var SVGFEPointLightElement: {
13535 prototype: SVGFEPointLightElement;
13536 new(): SVGFEPointLightElement;
13539 /** Corresponds to the <feSpecularLighting> element. */
13540 interface SVGFESpecularLightingElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13541 readonly in1: SVGAnimatedString;
13542 readonly kernelUnitLengthX: SVGAnimatedNumber;
13543 readonly kernelUnitLengthY: SVGAnimatedNumber;
13544 readonly specularConstant: SVGAnimatedNumber;
13545 readonly specularExponent: SVGAnimatedNumber;
13546 readonly surfaceScale: SVGAnimatedNumber;
13547 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFESpecularLightingElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13548 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13549 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFESpecularLightingElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13550 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13553 declare var SVGFESpecularLightingElement: {
13554 prototype: SVGFESpecularLightingElement;
13555 new(): SVGFESpecularLightingElement;
13558 /** Corresponds to the <feSpotLight> element. */
13559 interface SVGFESpotLightElement extends SVGElement {
13560 readonly limitingConeAngle: SVGAnimatedNumber;
13561 readonly pointsAtX: SVGAnimatedNumber;
13562 readonly pointsAtY: SVGAnimatedNumber;
13563 readonly pointsAtZ: SVGAnimatedNumber;
13564 readonly specularExponent: SVGAnimatedNumber;
13565 readonly x: SVGAnimatedNumber;
13566 readonly y: SVGAnimatedNumber;
13567 readonly z: SVGAnimatedNumber;
13568 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFESpotLightElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13569 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13570 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFESpotLightElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13571 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13574 declare var SVGFESpotLightElement: {
13575 prototype: SVGFESpotLightElement;
13576 new(): SVGFESpotLightElement;
13579 /** Corresponds to the <feTile> element. */
13580 interface SVGFETileElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13581 readonly in1: SVGAnimatedString;
13582 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFETileElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13583 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13584 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFETileElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13585 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13588 declare var SVGFETileElement: {
13589 prototype: SVGFETileElement;
13590 new(): SVGFETileElement;
13593 /** Corresponds to the <feTurbulence> element. */
13594 interface SVGFETurbulenceElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
13595 readonly baseFrequencyX: SVGAnimatedNumber;
13596 readonly baseFrequencyY: SVGAnimatedNumber;
13597 readonly numOctaves: SVGAnimatedInteger;
13598 readonly seed: SVGAnimatedNumber;
13599 readonly stitchTiles: SVGAnimatedEnumeration;
13600 readonly type: SVGAnimatedEnumeration;
13601 readonly SVG_STITCHTYPE_NOSTITCH: number;
13602 readonly SVG_STITCHTYPE_STITCH: number;
13603 readonly SVG_STITCHTYPE_UNKNOWN: number;
13604 readonly SVG_TURBULENCE_TYPE_FRACTALNOISE: number;
13605 readonly SVG_TURBULENCE_TYPE_TURBULENCE: number;
13606 readonly SVG_TURBULENCE_TYPE_UNKNOWN: number;
13607 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFETurbulenceElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13608 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13609 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFETurbulenceElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13610 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13613 declare var SVGFETurbulenceElement: {
13614 prototype: SVGFETurbulenceElement;
13615 new(): SVGFETurbulenceElement;
13616 readonly SVG_STITCHTYPE_NOSTITCH: number;
13617 readonly SVG_STITCHTYPE_STITCH: number;
13618 readonly SVG_STITCHTYPE_UNKNOWN: number;
13619 readonly SVG_TURBULENCE_TYPE_FRACTALNOISE: number;
13620 readonly SVG_TURBULENCE_TYPE_TURBULENCE: number;
13621 readonly SVG_TURBULENCE_TYPE_UNKNOWN: number;
13624 /** Provides access to the properties of <filter> elements, as well as methods to manipulate them. */
13625 interface SVGFilterElement extends SVGElement, SVGURIReference {
13626 readonly filterUnits: SVGAnimatedEnumeration;
13627 readonly height: SVGAnimatedLength;
13628 readonly primitiveUnits: SVGAnimatedEnumeration;
13629 readonly width: SVGAnimatedLength;
13630 readonly x: SVGAnimatedLength;
13631 readonly y: SVGAnimatedLength;
13632 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFilterElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13633 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13634 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFilterElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13635 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13638 declare var SVGFilterElement: {
13639 prototype: SVGFilterElement;
13640 new(): SVGFilterElement;
13643 interface SVGFilterPrimitiveStandardAttributes {
13644 readonly height: SVGAnimatedLength;
13645 readonly result: SVGAnimatedString;
13646 readonly width: SVGAnimatedLength;
13647 readonly x: SVGAnimatedLength;
13648 readonly y: SVGAnimatedLength;
13651 interface SVGFitToViewBox {
13652 readonly preserveAspectRatio: SVGAnimatedPreserveAspectRatio;
13653 readonly viewBox: SVGAnimatedRect;
13656 /** Provides access to the properties of <foreignObject> elements, as well as methods to manipulate them. */
13657 interface SVGForeignObjectElement extends SVGGraphicsElement {
13658 readonly height: SVGAnimatedLength;
13659 readonly width: SVGAnimatedLength;
13660 readonly x: SVGAnimatedLength;
13661 readonly y: SVGAnimatedLength;
13662 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGForeignObjectElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13663 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13664 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGForeignObjectElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13665 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13668 declare var SVGForeignObjectElement: {
13669 prototype: SVGForeignObjectElement;
13670 new(): SVGForeignObjectElement;
13673 /** Corresponds to the <g> element. */
13674 interface SVGGElement extends SVGGraphicsElement {
13675 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGGElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13676 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13677 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGGElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13678 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13681 declare var SVGGElement: {
13682 prototype: SVGGElement;
13683 new(): SVGGElement;
13686 interface SVGGeometryElement extends SVGGraphicsElement {
13687 readonly pathLength: SVGAnimatedNumber;
13688 getPointAtLength(distance: number): DOMPoint;
13689 getTotalLength(): number;
13690 isPointInFill(point?: DOMPointInit): boolean;
13691 isPointInStroke(point?: DOMPointInit): boolean;
13692 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGGeometryElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13693 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13694 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGGeometryElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13695 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13698 declare var SVGGeometryElement: {
13699 prototype: SVGGeometryElement;
13700 new(): SVGGeometryElement;
13703 /** The SVGGradient interface is a base interface used by SVGLinearGradientElement and SVGRadialGradientElement. */
13704 interface SVGGradientElement extends SVGElement, SVGURIReference {
13705 readonly gradientTransform: SVGAnimatedTransformList;
13706 readonly gradientUnits: SVGAnimatedEnumeration;
13707 readonly spreadMethod: SVGAnimatedEnumeration;
13708 readonly SVG_SPREADMETHOD_PAD: number;
13709 readonly SVG_SPREADMETHOD_REFLECT: number;
13710 readonly SVG_SPREADMETHOD_REPEAT: number;
13711 readonly SVG_SPREADMETHOD_UNKNOWN: number;
13712 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGGradientElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13713 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13714 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGGradientElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13715 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13718 declare var SVGGradientElement: {
13719 prototype: SVGGradientElement;
13720 new(): SVGGradientElement;
13721 readonly SVG_SPREADMETHOD_PAD: number;
13722 readonly SVG_SPREADMETHOD_REFLECT: number;
13723 readonly SVG_SPREADMETHOD_REPEAT: number;
13724 readonly SVG_SPREADMETHOD_UNKNOWN: number;
13727 /** SVG elements whose primary purpose is to directly render graphics into a group. */
13728 interface SVGGraphicsElement extends SVGElement, SVGTests {
13729 readonly transform: SVGAnimatedTransformList;
13730 getBBox(options?: SVGBoundingBoxOptions): DOMRect;
13731 getCTM(): DOMMatrix | null;
13732 getScreenCTM(): DOMMatrix | null;
13733 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGGraphicsElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13734 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13735 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGGraphicsElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13736 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13739 declare var SVGGraphicsElement: {
13740 prototype: SVGGraphicsElement;
13741 new(): SVGGraphicsElement;
13744 /** Corresponds to the <image> element. */
13745 interface SVGImageElement extends SVGGraphicsElement, SVGURIReference {
13746 readonly height: SVGAnimatedLength;
13747 readonly preserveAspectRatio: SVGAnimatedPreserveAspectRatio;
13748 readonly width: SVGAnimatedLength;
13749 readonly x: SVGAnimatedLength;
13750 readonly y: SVGAnimatedLength;
13751 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGImageElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13752 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13753 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGImageElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13754 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13757 declare var SVGImageElement: {
13758 prototype: SVGImageElement;
13759 new(): SVGImageElement;
13762 /** Correspond to the <length> basic data type. */
13763 interface SVGLength {
13764 readonly unitType: number;
13766 valueAsString: string;
13767 valueInSpecifiedUnits: number;
13768 convertToSpecifiedUnits(unitType: number): void;
13769 newValueSpecifiedUnits(unitType: number, valueInSpecifiedUnits: number): void;
13770 readonly SVG_LENGTHTYPE_CM: number;
13771 readonly SVG_LENGTHTYPE_EMS: number;
13772 readonly SVG_LENGTHTYPE_EXS: number;
13773 readonly SVG_LENGTHTYPE_IN: number;
13774 readonly SVG_LENGTHTYPE_MM: number;
13775 readonly SVG_LENGTHTYPE_NUMBER: number;
13776 readonly SVG_LENGTHTYPE_PC: number;
13777 readonly SVG_LENGTHTYPE_PERCENTAGE: number;
13778 readonly SVG_LENGTHTYPE_PT: number;
13779 readonly SVG_LENGTHTYPE_PX: number;
13780 readonly SVG_LENGTHTYPE_UNKNOWN: number;
13783 declare var SVGLength: {
13784 prototype: SVGLength;
13786 readonly SVG_LENGTHTYPE_CM: number;
13787 readonly SVG_LENGTHTYPE_EMS: number;
13788 readonly SVG_LENGTHTYPE_EXS: number;
13789 readonly SVG_LENGTHTYPE_IN: number;
13790 readonly SVG_LENGTHTYPE_MM: number;
13791 readonly SVG_LENGTHTYPE_NUMBER: number;
13792 readonly SVG_LENGTHTYPE_PC: number;
13793 readonly SVG_LENGTHTYPE_PERCENTAGE: number;
13794 readonly SVG_LENGTHTYPE_PT: number;
13795 readonly SVG_LENGTHTYPE_PX: number;
13796 readonly SVG_LENGTHTYPE_UNKNOWN: number;
13799 /** The SVGLengthList defines a list of SVGLength objects. */
13800 interface SVGLengthList {
13801 readonly length: number;
13802 readonly numberOfItems: number;
13803 appendItem(newItem: SVGLength): SVGLength;
13805 getItem(index: number): SVGLength;
13806 initialize(newItem: SVGLength): SVGLength;
13807 insertItemBefore(newItem: SVGLength, index: number): SVGLength;
13808 removeItem(index: number): SVGLength;
13809 replaceItem(newItem: SVGLength, index: number): SVGLength;
13810 [index: number]: SVGLength;
13813 declare var SVGLengthList: {
13814 prototype: SVGLengthList;
13815 new(): SVGLengthList;
13818 /** Provides access to the properties of <line> elements, as well as methods to manipulate them. */
13819 interface SVGLineElement extends SVGGeometryElement {
13820 readonly x1: SVGAnimatedLength;
13821 readonly x2: SVGAnimatedLength;
13822 readonly y1: SVGAnimatedLength;
13823 readonly y2: SVGAnimatedLength;
13824 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGLineElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13825 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13826 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGLineElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13827 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13830 declare var SVGLineElement: {
13831 prototype: SVGLineElement;
13832 new(): SVGLineElement;
13835 /** Corresponds to the <linearGradient> element. */
13836 interface SVGLinearGradientElement extends SVGGradientElement {
13837 readonly x1: SVGAnimatedLength;
13838 readonly x2: SVGAnimatedLength;
13839 readonly y1: SVGAnimatedLength;
13840 readonly y2: SVGAnimatedLength;
13841 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGLinearGradientElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13842 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13843 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGLinearGradientElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13844 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13847 declare var SVGLinearGradientElement: {
13848 prototype: SVGLinearGradientElement;
13849 new(): SVGLinearGradientElement;
13852 interface SVGMarkerElement extends SVGElement, SVGFitToViewBox {
13853 readonly markerHeight: SVGAnimatedLength;
13854 readonly markerUnits: SVGAnimatedEnumeration;
13855 readonly markerWidth: SVGAnimatedLength;
13856 readonly orientAngle: SVGAnimatedAngle;
13857 readonly orientType: SVGAnimatedEnumeration;
13858 readonly refX: SVGAnimatedLength;
13859 readonly refY: SVGAnimatedLength;
13860 setOrientToAngle(angle: SVGAngle): void;
13861 setOrientToAuto(): void;
13862 readonly SVG_MARKERUNITS_STROKEWIDTH: number;
13863 readonly SVG_MARKERUNITS_UNKNOWN: number;
13864 readonly SVG_MARKERUNITS_USERSPACEONUSE: number;
13865 readonly SVG_MARKER_ORIENT_ANGLE: number;
13866 readonly SVG_MARKER_ORIENT_AUTO: number;
13867 readonly SVG_MARKER_ORIENT_UNKNOWN: number;
13868 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGMarkerElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13869 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13870 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGMarkerElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13871 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13874 declare var SVGMarkerElement: {
13875 prototype: SVGMarkerElement;
13876 new(): SVGMarkerElement;
13877 readonly SVG_MARKERUNITS_STROKEWIDTH: number;
13878 readonly SVG_MARKERUNITS_UNKNOWN: number;
13879 readonly SVG_MARKERUNITS_USERSPACEONUSE: number;
13880 readonly SVG_MARKER_ORIENT_ANGLE: number;
13881 readonly SVG_MARKER_ORIENT_AUTO: number;
13882 readonly SVG_MARKER_ORIENT_UNKNOWN: number;
13885 /** Provides access to the properties of <mask> elements, as well as methods to manipulate them. */
13886 interface SVGMaskElement extends SVGElement {
13887 readonly height: SVGAnimatedLength;
13888 readonly maskContentUnits: SVGAnimatedEnumeration;
13889 readonly maskUnits: SVGAnimatedEnumeration;
13890 readonly width: SVGAnimatedLength;
13891 readonly x: SVGAnimatedLength;
13892 readonly y: SVGAnimatedLength;
13893 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGMaskElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13894 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13895 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGMaskElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13896 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13899 declare var SVGMaskElement: {
13900 prototype: SVGMaskElement;
13901 new(): SVGMaskElement;
13904 /** Corresponds to the <metadata> element. */
13905 interface SVGMetadataElement extends SVGElement {
13906 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGMetadataElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13907 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13908 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGMetadataElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13909 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13912 declare var SVGMetadataElement: {
13913 prototype: SVGMetadataElement;
13914 new(): SVGMetadataElement;
13917 /** Corresponds to the <number> basic data type. */
13918 interface SVGNumber {
13922 declare var SVGNumber: {
13923 prototype: SVGNumber;
13927 /** The SVGNumberList defines a list of SVGNumber objects. */
13928 interface SVGNumberList {
13929 readonly length: number;
13930 readonly numberOfItems: number;
13931 appendItem(newItem: SVGNumber): SVGNumber;
13933 getItem(index: number): SVGNumber;
13934 initialize(newItem: SVGNumber): SVGNumber;
13935 insertItemBefore(newItem: SVGNumber, index: number): SVGNumber;
13936 removeItem(index: number): SVGNumber;
13937 replaceItem(newItem: SVGNumber, index: number): SVGNumber;
13938 [index: number]: SVGNumber;
13941 declare var SVGNumberList: {
13942 prototype: SVGNumberList;
13943 new(): SVGNumberList;
13946 /** Corresponds to the <path> element. */
13947 interface SVGPathElement extends SVGGraphicsElement {
13949 readonly pathSegList: SVGPathSegList;
13951 createSVGPathSegArcAbs(x: number, y: number, r1: number, r2: number, angle: number, largeArcFlag: boolean, sweepFlag: boolean): SVGPathSegArcAbs;
13953 createSVGPathSegArcRel(x: number, y: number, r1: number, r2: number, angle: number, largeArcFlag: boolean, sweepFlag: boolean): SVGPathSegArcRel;
13955 createSVGPathSegClosePath(): SVGPathSegClosePath;
13957 createSVGPathSegCurvetoCubicAbs(x: number, y: number, x1: number, y1: number, x2: number, y2: number): SVGPathSegCurvetoCubicAbs;
13959 createSVGPathSegCurvetoCubicRel(x: number, y: number, x1: number, y1: number, x2: number, y2: number): SVGPathSegCurvetoCubicRel;
13961 createSVGPathSegCurvetoCubicSmoothAbs(x: number, y: number, x2: number, y2: number): SVGPathSegCurvetoCubicSmoothAbs;
13963 createSVGPathSegCurvetoCubicSmoothRel(x: number, y: number, x2: number, y2: number): SVGPathSegCurvetoCubicSmoothRel;
13965 createSVGPathSegCurvetoQuadraticAbs(x: number, y: number, x1: number, y1: number): SVGPathSegCurvetoQuadraticAbs;
13967 createSVGPathSegCurvetoQuadraticRel(x: number, y: number, x1: number, y1: number): SVGPathSegCurvetoQuadraticRel;
13969 createSVGPathSegCurvetoQuadraticSmoothAbs(x: number, y: number): SVGPathSegCurvetoQuadraticSmoothAbs;
13971 createSVGPathSegCurvetoQuadraticSmoothRel(x: number, y: number): SVGPathSegCurvetoQuadraticSmoothRel;
13973 createSVGPathSegLinetoAbs(x: number, y: number): SVGPathSegLinetoAbs;
13975 createSVGPathSegLinetoHorizontalAbs(x: number): SVGPathSegLinetoHorizontalAbs;
13977 createSVGPathSegLinetoHorizontalRel(x: number): SVGPathSegLinetoHorizontalRel;
13979 createSVGPathSegLinetoRel(x: number, y: number): SVGPathSegLinetoRel;
13981 createSVGPathSegLinetoVerticalAbs(y: number): SVGPathSegLinetoVerticalAbs;
13983 createSVGPathSegLinetoVerticalRel(y: number): SVGPathSegLinetoVerticalRel;
13985 createSVGPathSegMovetoAbs(x: number, y: number): SVGPathSegMovetoAbs;
13987 createSVGPathSegMovetoRel(x: number, y: number): SVGPathSegMovetoRel;
13989 getPathSegAtLength(distance: number): number;
13990 getPointAtLength(distance: number): SVGPoint;
13991 getTotalLength(): number;
13992 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGPathElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13993 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13994 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGPathElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13995 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13998 declare var SVGPathElement: {
13999 prototype: SVGPathElement;
14000 new(): SVGPathElement;
14003 interface SVGPathSeg {
14004 readonly pathSegType: number;
14005 readonly pathSegTypeAsLetter: string;
14006 readonly PATHSEG_ARC_ABS: number;
14007 readonly PATHSEG_ARC_REL: number;
14008 readonly PATHSEG_CLOSEPATH: number;
14009 readonly PATHSEG_CURVETO_CUBIC_ABS: number;
14010 readonly PATHSEG_CURVETO_CUBIC_REL: number;
14011 readonly PATHSEG_CURVETO_CUBIC_SMOOTH_ABS: number;
14012 readonly PATHSEG_CURVETO_CUBIC_SMOOTH_REL: number;
14013 readonly PATHSEG_CURVETO_QUADRATIC_ABS: number;
14014 readonly PATHSEG_CURVETO_QUADRATIC_REL: number;
14015 readonly PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS: number;
14016 readonly PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL: number;
14017 readonly PATHSEG_LINETO_ABS: number;
14018 readonly PATHSEG_LINETO_HORIZONTAL_ABS: number;
14019 readonly PATHSEG_LINETO_HORIZONTAL_REL: number;
14020 readonly PATHSEG_LINETO_REL: number;
14021 readonly PATHSEG_LINETO_VERTICAL_ABS: number;
14022 readonly PATHSEG_LINETO_VERTICAL_REL: number;
14023 readonly PATHSEG_MOVETO_ABS: number;
14024 readonly PATHSEG_MOVETO_REL: number;
14025 readonly PATHSEG_UNKNOWN: number;
14028 declare var SVGPathSeg: {
14029 prototype: SVGPathSeg;
14031 readonly PATHSEG_ARC_ABS: number;
14032 readonly PATHSEG_ARC_REL: number;
14033 readonly PATHSEG_CLOSEPATH: number;
14034 readonly PATHSEG_CURVETO_CUBIC_ABS: number;
14035 readonly PATHSEG_CURVETO_CUBIC_REL: number;
14036 readonly PATHSEG_CURVETO_CUBIC_SMOOTH_ABS: number;
14037 readonly PATHSEG_CURVETO_CUBIC_SMOOTH_REL: number;
14038 readonly PATHSEG_CURVETO_QUADRATIC_ABS: number;
14039 readonly PATHSEG_CURVETO_QUADRATIC_REL: number;
14040 readonly PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS: number;
14041 readonly PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL: number;
14042 readonly PATHSEG_LINETO_ABS: number;
14043 readonly PATHSEG_LINETO_HORIZONTAL_ABS: number;
14044 readonly PATHSEG_LINETO_HORIZONTAL_REL: number;
14045 readonly PATHSEG_LINETO_REL: number;
14046 readonly PATHSEG_LINETO_VERTICAL_ABS: number;
14047 readonly PATHSEG_LINETO_VERTICAL_REL: number;
14048 readonly PATHSEG_MOVETO_ABS: number;
14049 readonly PATHSEG_MOVETO_REL: number;
14050 readonly PATHSEG_UNKNOWN: number;
14053 interface SVGPathSegArcAbs extends SVGPathSeg {
14055 largeArcFlag: boolean;
14058 sweepFlag: boolean;
14063 declare var SVGPathSegArcAbs: {
14064 prototype: SVGPathSegArcAbs;
14065 new(): SVGPathSegArcAbs;
14068 interface SVGPathSegArcRel extends SVGPathSeg {
14070 largeArcFlag: boolean;
14073 sweepFlag: boolean;
14078 declare var SVGPathSegArcRel: {
14079 prototype: SVGPathSegArcRel;
14080 new(): SVGPathSegArcRel;
14083 interface SVGPathSegClosePath extends SVGPathSeg {
14086 declare var SVGPathSegClosePath: {
14087 prototype: SVGPathSegClosePath;
14088 new(): SVGPathSegClosePath;
14091 interface SVGPathSegCurvetoCubicAbs extends SVGPathSeg {
14100 declare var SVGPathSegCurvetoCubicAbs: {
14101 prototype: SVGPathSegCurvetoCubicAbs;
14102 new(): SVGPathSegCurvetoCubicAbs;
14105 interface SVGPathSegCurvetoCubicRel extends SVGPathSeg {
14114 declare var SVGPathSegCurvetoCubicRel: {
14115 prototype: SVGPathSegCurvetoCubicRel;
14116 new(): SVGPathSegCurvetoCubicRel;
14119 interface SVGPathSegCurvetoCubicSmoothAbs extends SVGPathSeg {
14126 declare var SVGPathSegCurvetoCubicSmoothAbs: {
14127 prototype: SVGPathSegCurvetoCubicSmoothAbs;
14128 new(): SVGPathSegCurvetoCubicSmoothAbs;
14131 interface SVGPathSegCurvetoCubicSmoothRel extends SVGPathSeg {
14138 declare var SVGPathSegCurvetoCubicSmoothRel: {
14139 prototype: SVGPathSegCurvetoCubicSmoothRel;
14140 new(): SVGPathSegCurvetoCubicSmoothRel;
14143 interface SVGPathSegCurvetoQuadraticAbs extends SVGPathSeg {
14150 declare var SVGPathSegCurvetoQuadraticAbs: {
14151 prototype: SVGPathSegCurvetoQuadraticAbs;
14152 new(): SVGPathSegCurvetoQuadraticAbs;
14155 interface SVGPathSegCurvetoQuadraticRel extends SVGPathSeg {
14162 declare var SVGPathSegCurvetoQuadraticRel: {
14163 prototype: SVGPathSegCurvetoQuadraticRel;
14164 new(): SVGPathSegCurvetoQuadraticRel;
14167 interface SVGPathSegCurvetoQuadraticSmoothAbs extends SVGPathSeg {
14172 declare var SVGPathSegCurvetoQuadraticSmoothAbs: {
14173 prototype: SVGPathSegCurvetoQuadraticSmoothAbs;
14174 new(): SVGPathSegCurvetoQuadraticSmoothAbs;
14177 interface SVGPathSegCurvetoQuadraticSmoothRel extends SVGPathSeg {
14182 declare var SVGPathSegCurvetoQuadraticSmoothRel: {
14183 prototype: SVGPathSegCurvetoQuadraticSmoothRel;
14184 new(): SVGPathSegCurvetoQuadraticSmoothRel;
14187 interface SVGPathSegLinetoAbs extends SVGPathSeg {
14192 declare var SVGPathSegLinetoAbs: {
14193 prototype: SVGPathSegLinetoAbs;
14194 new(): SVGPathSegLinetoAbs;
14197 interface SVGPathSegLinetoHorizontalAbs extends SVGPathSeg {
14201 declare var SVGPathSegLinetoHorizontalAbs: {
14202 prototype: SVGPathSegLinetoHorizontalAbs;
14203 new(): SVGPathSegLinetoHorizontalAbs;
14206 interface SVGPathSegLinetoHorizontalRel extends SVGPathSeg {
14210 declare var SVGPathSegLinetoHorizontalRel: {
14211 prototype: SVGPathSegLinetoHorizontalRel;
14212 new(): SVGPathSegLinetoHorizontalRel;
14215 interface SVGPathSegLinetoRel extends SVGPathSeg {
14220 declare var SVGPathSegLinetoRel: {
14221 prototype: SVGPathSegLinetoRel;
14222 new(): SVGPathSegLinetoRel;
14225 interface SVGPathSegLinetoVerticalAbs extends SVGPathSeg {
14229 declare var SVGPathSegLinetoVerticalAbs: {
14230 prototype: SVGPathSegLinetoVerticalAbs;
14231 new(): SVGPathSegLinetoVerticalAbs;
14234 interface SVGPathSegLinetoVerticalRel extends SVGPathSeg {
14238 declare var SVGPathSegLinetoVerticalRel: {
14239 prototype: SVGPathSegLinetoVerticalRel;
14240 new(): SVGPathSegLinetoVerticalRel;
14243 interface SVGPathSegList {
14244 readonly numberOfItems: number;
14245 appendItem(newItem: SVGPathSeg): SVGPathSeg;
14247 getItem(index: number): SVGPathSeg;
14248 initialize(newItem: SVGPathSeg): SVGPathSeg;
14249 insertItemBefore(newItem: SVGPathSeg, index: number): SVGPathSeg;
14250 removeItem(index: number): SVGPathSeg;
14251 replaceItem(newItem: SVGPathSeg, index: number): SVGPathSeg;
14254 declare var SVGPathSegList: {
14255 prototype: SVGPathSegList;
14256 new(): SVGPathSegList;
14259 interface SVGPathSegMovetoAbs extends SVGPathSeg {
14264 declare var SVGPathSegMovetoAbs: {
14265 prototype: SVGPathSegMovetoAbs;
14266 new(): SVGPathSegMovetoAbs;
14269 interface SVGPathSegMovetoRel extends SVGPathSeg {
14274 declare var SVGPathSegMovetoRel: {
14275 prototype: SVGPathSegMovetoRel;
14276 new(): SVGPathSegMovetoRel;
14279 /** Corresponds to the <pattern> element. */
14280 interface SVGPatternElement extends SVGElement, SVGFitToViewBox, SVGURIReference {
14281 readonly height: SVGAnimatedLength;
14282 readonly patternContentUnits: SVGAnimatedEnumeration;
14283 readonly patternTransform: SVGAnimatedTransformList;
14284 readonly patternUnits: SVGAnimatedEnumeration;
14285 readonly width: SVGAnimatedLength;
14286 readonly x: SVGAnimatedLength;
14287 readonly y: SVGAnimatedLength;
14288 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGPatternElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14289 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14290 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGPatternElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14291 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14294 declare var SVGPatternElement: {
14295 prototype: SVGPatternElement;
14296 new(): SVGPatternElement;
14299 interface SVGPointList {
14300 readonly length: number;
14301 readonly numberOfItems: number;
14302 appendItem(newItem: DOMPoint): DOMPoint;
14304 getItem(index: number): DOMPoint;
14305 initialize(newItem: DOMPoint): DOMPoint;
14306 insertItemBefore(newItem: DOMPoint, index: number): DOMPoint;
14307 removeItem(index: number): DOMPoint;
14308 replaceItem(newItem: DOMPoint, index: number): DOMPoint;
14309 [index: number]: DOMPoint;
14312 declare var SVGPointList: {
14313 prototype: SVGPointList;
14314 new(): SVGPointList;
14317 /** Provides access to the properties of <polygon> elements, as well as methods to manipulate them. */
14318 interface SVGPolygonElement extends SVGGeometryElement, SVGAnimatedPoints {
14319 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGPolygonElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14320 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14321 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGPolygonElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14322 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14325 declare var SVGPolygonElement: {
14326 prototype: SVGPolygonElement;
14327 new(): SVGPolygonElement;
14330 /** Provides access to the properties of <polyline> elements, as well as methods to manipulate them. */
14331 interface SVGPolylineElement extends SVGGeometryElement, SVGAnimatedPoints {
14332 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGPolylineElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14333 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14334 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGPolylineElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14335 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14338 declare var SVGPolylineElement: {
14339 prototype: SVGPolylineElement;
14340 new(): SVGPolylineElement;
14343 /** Corresponds to the preserveAspectRatio attribute, which is available for some of SVG's elements. */
14344 interface SVGPreserveAspectRatio {
14346 meetOrSlice: number;
14347 readonly SVG_MEETORSLICE_MEET: number;
14348 readonly SVG_MEETORSLICE_SLICE: number;
14349 readonly SVG_MEETORSLICE_UNKNOWN: number;
14350 readonly SVG_PRESERVEASPECTRATIO_NONE: number;
14351 readonly SVG_PRESERVEASPECTRATIO_UNKNOWN: number;
14352 readonly SVG_PRESERVEASPECTRATIO_XMAXYMAX: number;
14353 readonly SVG_PRESERVEASPECTRATIO_XMAXYMID: number;
14354 readonly SVG_PRESERVEASPECTRATIO_XMAXYMIN: number;
14355 readonly SVG_PRESERVEASPECTRATIO_XMIDYMAX: number;
14356 readonly SVG_PRESERVEASPECTRATIO_XMIDYMID: number;
14357 readonly SVG_PRESERVEASPECTRATIO_XMIDYMIN: number;
14358 readonly SVG_PRESERVEASPECTRATIO_XMINYMAX: number;
14359 readonly SVG_PRESERVEASPECTRATIO_XMINYMID: number;
14360 readonly SVG_PRESERVEASPECTRATIO_XMINYMIN: number;
14363 declare var SVGPreserveAspectRatio: {
14364 prototype: SVGPreserveAspectRatio;
14365 new(): SVGPreserveAspectRatio;
14366 readonly SVG_MEETORSLICE_MEET: number;
14367 readonly SVG_MEETORSLICE_SLICE: number;
14368 readonly SVG_MEETORSLICE_UNKNOWN: number;
14369 readonly SVG_PRESERVEASPECTRATIO_NONE: number;
14370 readonly SVG_PRESERVEASPECTRATIO_UNKNOWN: number;
14371 readonly SVG_PRESERVEASPECTRATIO_XMAXYMAX: number;
14372 readonly SVG_PRESERVEASPECTRATIO_XMAXYMID: number;
14373 readonly SVG_PRESERVEASPECTRATIO_XMAXYMIN: number;
14374 readonly SVG_PRESERVEASPECTRATIO_XMIDYMAX: number;
14375 readonly SVG_PRESERVEASPECTRATIO_XMIDYMID: number;
14376 readonly SVG_PRESERVEASPECTRATIO_XMIDYMIN: number;
14377 readonly SVG_PRESERVEASPECTRATIO_XMINYMAX: number;
14378 readonly SVG_PRESERVEASPECTRATIO_XMINYMID: number;
14379 readonly SVG_PRESERVEASPECTRATIO_XMINYMIN: number;
14382 /** Corresponds to the <RadialGradient> element. */
14383 interface SVGRadialGradientElement extends SVGGradientElement {
14384 readonly cx: SVGAnimatedLength;
14385 readonly cy: SVGAnimatedLength;
14386 readonly fr: SVGAnimatedLength;
14387 readonly fx: SVGAnimatedLength;
14388 readonly fy: SVGAnimatedLength;
14389 readonly r: SVGAnimatedLength;
14390 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGRadialGradientElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14391 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14392 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGRadialGradientElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14393 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14396 declare var SVGRadialGradientElement: {
14397 prototype: SVGRadialGradientElement;
14398 new(): SVGRadialGradientElement;
14401 /** Provides access to the properties of <rect> elements, as well as methods to manipulate them. */
14402 interface SVGRectElement extends SVGGeometryElement {
14403 readonly height: SVGAnimatedLength;
14404 readonly rx: SVGAnimatedLength;
14405 readonly ry: SVGAnimatedLength;
14406 readonly width: SVGAnimatedLength;
14407 readonly x: SVGAnimatedLength;
14408 readonly y: SVGAnimatedLength;
14409 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGRectElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14410 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14411 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGRectElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14412 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14415 declare var SVGRectElement: {
14416 prototype: SVGRectElement;
14417 new(): SVGRectElement;
14420 interface SVGSVGElementEventMap extends SVGElementEventMap {
14421 "SVGUnload": Event;
14422 "SVGZoom": SVGZoomEvent;
14425 /** Provides access to the properties of <svg> elements, as well as methods to manipulate them. This interface contains also various miscellaneous commonly-used utility methods, such as matrix operations and the ability to control the time of redraw on visual rendering devices. */
14426 interface SVGSVGElement extends SVGGraphicsElement, DocumentEvent, SVGFitToViewBox, SVGZoomAndPan {
14428 contentScriptType: string;
14430 contentStyleType: string;
14431 currentScale: number;
14432 readonly currentTranslate: SVGPoint;
14433 readonly height: SVGAnimatedLength;
14434 onunload: ((this: SVGSVGElement, ev: Event) => any) | null;
14435 onzoom: ((this: SVGSVGElement, ev: SVGZoomEvent) => any) | null;
14437 readonly pixelUnitToMillimeterX: number;
14439 readonly pixelUnitToMillimeterY: number;
14441 readonly screenPixelToMillimeterX: number;
14443 readonly screenPixelToMillimeterY: number;
14445 readonly viewport: SVGRect;
14446 readonly width: SVGAnimatedLength;
14447 readonly x: SVGAnimatedLength;
14448 readonly y: SVGAnimatedLength;
14449 animationsPaused(): boolean;
14450 checkEnclosure(element: SVGElement, rect: SVGRect): boolean;
14451 checkIntersection(element: SVGElement, rect: SVGRect): boolean;
14452 createSVGAngle(): SVGAngle;
14453 createSVGLength(): SVGLength;
14454 createSVGMatrix(): SVGMatrix;
14455 createSVGNumber(): SVGNumber;
14456 createSVGPoint(): SVGPoint;
14457 createSVGRect(): SVGRect;
14458 createSVGTransform(): SVGTransform;
14459 createSVGTransformFromMatrix(matrix: SVGMatrix): SVGTransform;
14460 deselectAll(): void;
14462 forceRedraw(): void;
14463 getComputedStyle(elt: Element, pseudoElt?: string | null): CSSStyleDeclaration;
14464 getCurrentTime(): number;
14465 getElementById(elementId: string): Element;
14466 getEnclosureList(rect: SVGRect, referenceElement: SVGElement | null): NodeListOf<SVGCircleElement | SVGEllipseElement | SVGImageElement | SVGLineElement | SVGPathElement | SVGPolygonElement | SVGPolylineElement | SVGRectElement | SVGTextElement | SVGUseElement>;
14467 getIntersectionList(rect: SVGRect, referenceElement: SVGElement | null): NodeListOf<SVGCircleElement | SVGEllipseElement | SVGImageElement | SVGLineElement | SVGPathElement | SVGPolygonElement | SVGPolylineElement | SVGRectElement | SVGTextElement | SVGUseElement>;
14468 pauseAnimations(): void;
14469 setCurrentTime(seconds: number): void;
14471 suspendRedraw(maxWaitMilliseconds: number): number;
14472 unpauseAnimations(): void;
14474 unsuspendRedraw(suspendHandleID: number): void;
14476 unsuspendRedrawAll(): void;
14477 addEventListener<K extends keyof SVGSVGElementEventMap>(type: K, listener: (this: SVGSVGElement, ev: SVGSVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14478 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14479 removeEventListener<K extends keyof SVGSVGElementEventMap>(type: K, listener: (this: SVGSVGElement, ev: SVGSVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14480 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14483 declare var SVGSVGElement: {
14484 prototype: SVGSVGElement;
14485 new(): SVGSVGElement;
14486 readonly SVG_ZOOMANDPAN_DISABLE: number;
14487 readonly SVG_ZOOMANDPAN_MAGNIFY: number;
14488 readonly SVG_ZOOMANDPAN_UNKNOWN: number;
14491 /** Corresponds to the SVG <script> element. */
14492 interface SVGScriptElement extends SVGElement, SVGURIReference {
14494 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGScriptElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14495 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14496 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGScriptElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14497 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14500 declare var SVGScriptElement: {
14501 prototype: SVGScriptElement;
14502 new(): SVGScriptElement;
14505 /** Corresponds to the <stop> element. */
14506 interface SVGStopElement extends SVGElement {
14507 readonly offset: SVGAnimatedNumber;
14508 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGStopElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14509 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14510 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGStopElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14511 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14514 declare var SVGStopElement: {
14515 prototype: SVGStopElement;
14516 new(): SVGStopElement;
14519 /** The SVGStringList defines a list of DOMString objects. */
14520 interface SVGStringList {
14521 readonly length: number;
14522 readonly numberOfItems: number;
14523 appendItem(newItem: string): string;
14525 getItem(index: number): string;
14526 initialize(newItem: string): string;
14527 insertItemBefore(newItem: string, index: number): string;
14528 removeItem(index: number): string;
14529 replaceItem(newItem: string, index: number): string;
14530 [index: number]: string;
14533 declare var SVGStringList: {
14534 prototype: SVGStringList;
14535 new(): SVGStringList;
14538 /** Corresponds to the SVG <style> element. */
14539 interface SVGStyleElement extends SVGElement, LinkStyle {
14544 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGStyleElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14545 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14546 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGStyleElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14547 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14550 declare var SVGStyleElement: {
14551 prototype: SVGStyleElement;
14552 new(): SVGStyleElement;
14555 /** Corresponds to the <switch> element. */
14556 interface SVGSwitchElement extends SVGGraphicsElement {
14557 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGSwitchElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14558 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14559 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGSwitchElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14560 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14563 declare var SVGSwitchElement: {
14564 prototype: SVGSwitchElement;
14565 new(): SVGSwitchElement;
14568 /** Corresponds to the <symbol> element. */
14569 interface SVGSymbolElement extends SVGElement, SVGFitToViewBox {
14570 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGSymbolElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14571 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14572 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGSymbolElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14573 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14576 declare var SVGSymbolElement: {
14577 prototype: SVGSymbolElement;
14578 new(): SVGSymbolElement;
14581 /** A <tspan> element. */
14582 interface SVGTSpanElement extends SVGTextPositioningElement {
14583 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTSpanElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14584 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14585 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTSpanElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14586 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14589 declare var SVGTSpanElement: {
14590 prototype: SVGTSpanElement;
14591 new(): SVGTSpanElement;
14594 interface SVGTests {
14595 readonly requiredExtensions: SVGStringList;
14596 readonly systemLanguage: SVGStringList;
14599 /** Implemented by elements that support rendering child text content. It is inherited by various text-related interfaces, such as SVGTextElement, SVGTSpanElement, SVGTRefElement, SVGAltGlyphElement and SVGTextPathElement. */
14600 interface SVGTextContentElement extends SVGGraphicsElement {
14601 readonly lengthAdjust: SVGAnimatedEnumeration;
14602 readonly textLength: SVGAnimatedLength;
14603 getCharNumAtPosition(point?: DOMPointInit): number;
14604 getComputedTextLength(): number;
14605 getEndPositionOfChar(charnum: number): DOMPoint;
14606 getExtentOfChar(charnum: number): DOMRect;
14607 getNumberOfChars(): number;
14608 getRotationOfChar(charnum: number): number;
14609 getStartPositionOfChar(charnum: number): DOMPoint;
14610 getSubStringLength(charnum: number, nchars: number): number;
14611 selectSubString(charnum: number, nchars: number): void;
14612 readonly LENGTHADJUST_SPACING: number;
14613 readonly LENGTHADJUST_SPACINGANDGLYPHS: number;
14614 readonly LENGTHADJUST_UNKNOWN: number;
14615 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTextContentElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14616 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14617 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTextContentElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14618 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14621 declare var SVGTextContentElement: {
14622 prototype: SVGTextContentElement;
14623 new(): SVGTextContentElement;
14624 readonly LENGTHADJUST_SPACING: number;
14625 readonly LENGTHADJUST_SPACINGANDGLYPHS: number;
14626 readonly LENGTHADJUST_UNKNOWN: number;
14629 /** Corresponds to the <text> elements. */
14630 interface SVGTextElement extends SVGTextPositioningElement {
14631 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTextElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14632 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14633 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTextElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14634 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14637 declare var SVGTextElement: {
14638 prototype: SVGTextElement;
14639 new(): SVGTextElement;
14642 /** Corresponds to the <textPath> element. */
14643 interface SVGTextPathElement extends SVGTextContentElement, SVGURIReference {
14644 readonly method: SVGAnimatedEnumeration;
14645 readonly spacing: SVGAnimatedEnumeration;
14646 readonly startOffset: SVGAnimatedLength;
14647 readonly TEXTPATH_METHODTYPE_ALIGN: number;
14648 readonly TEXTPATH_METHODTYPE_STRETCH: number;
14649 readonly TEXTPATH_METHODTYPE_UNKNOWN: number;
14650 readonly TEXTPATH_SPACINGTYPE_AUTO: number;
14651 readonly TEXTPATH_SPACINGTYPE_EXACT: number;
14652 readonly TEXTPATH_SPACINGTYPE_UNKNOWN: number;
14653 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTextPathElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14654 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14655 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTextPathElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14656 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14659 declare var SVGTextPathElement: {
14660 prototype: SVGTextPathElement;
14661 new(): SVGTextPathElement;
14662 readonly TEXTPATH_METHODTYPE_ALIGN: number;
14663 readonly TEXTPATH_METHODTYPE_STRETCH: number;
14664 readonly TEXTPATH_METHODTYPE_UNKNOWN: number;
14665 readonly TEXTPATH_SPACINGTYPE_AUTO: number;
14666 readonly TEXTPATH_SPACINGTYPE_EXACT: number;
14667 readonly TEXTPATH_SPACINGTYPE_UNKNOWN: number;
14670 /** Implemented by elements that support attributes that position individual text glyphs. It is inherited by SVGTextElement, SVGTSpanElement, SVGTRefElement and SVGAltGlyphElement. */
14671 interface SVGTextPositioningElement extends SVGTextContentElement {
14672 readonly dx: SVGAnimatedLengthList;
14673 readonly dy: SVGAnimatedLengthList;
14674 readonly rotate: SVGAnimatedNumberList;
14675 readonly x: SVGAnimatedLengthList;
14676 readonly y: SVGAnimatedLengthList;
14677 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTextPositioningElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14678 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14679 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTextPositioningElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14680 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14683 declare var SVGTextPositioningElement: {
14684 prototype: SVGTextPositioningElement;
14685 new(): SVGTextPositioningElement;
14688 /** Corresponds to the <title> element. */
14689 interface SVGTitleElement extends SVGElement {
14690 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTitleElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14691 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14692 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTitleElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14693 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14696 declare var SVGTitleElement: {
14697 prototype: SVGTitleElement;
14698 new(): SVGTitleElement;
14701 /** SVGTransform is the interface for one of the component transformations within an SVGTransformList; thus, an SVGTransform object corresponds to a single component (e.g., scale(…) or matrix(…)) within a transform attribute. */
14702 interface SVGTransform {
14703 readonly angle: number;
14704 readonly matrix: SVGMatrix;
14705 readonly type: number;
14706 setMatrix(matrix: SVGMatrix): void;
14707 setRotate(angle: number, cx: number, cy: number): void;
14708 setScale(sx: number, sy: number): void;
14709 setSkewX(angle: number): void;
14710 setSkewY(angle: number): void;
14711 setTranslate(tx: number, ty: number): void;
14712 readonly SVG_TRANSFORM_MATRIX: number;
14713 readonly SVG_TRANSFORM_ROTATE: number;
14714 readonly SVG_TRANSFORM_SCALE: number;
14715 readonly SVG_TRANSFORM_SKEWX: number;
14716 readonly SVG_TRANSFORM_SKEWY: number;
14717 readonly SVG_TRANSFORM_TRANSLATE: number;
14718 readonly SVG_TRANSFORM_UNKNOWN: number;
14721 declare var SVGTransform: {
14722 prototype: SVGTransform;
14723 new(): SVGTransform;
14724 readonly SVG_TRANSFORM_MATRIX: number;
14725 readonly SVG_TRANSFORM_ROTATE: number;
14726 readonly SVG_TRANSFORM_SCALE: number;
14727 readonly SVG_TRANSFORM_SKEWX: number;
14728 readonly SVG_TRANSFORM_SKEWY: number;
14729 readonly SVG_TRANSFORM_TRANSLATE: number;
14730 readonly SVG_TRANSFORM_UNKNOWN: number;
14733 /** The SVGTransformList defines a list of SVGTransform objects. */
14734 interface SVGTransformList {
14735 readonly numberOfItems: number;
14736 appendItem(newItem: SVGTransform): SVGTransform;
14738 consolidate(): SVGTransform;
14739 createSVGTransformFromMatrix(matrix: SVGMatrix): SVGTransform;
14740 getItem(index: number): SVGTransform;
14741 initialize(newItem: SVGTransform): SVGTransform;
14742 insertItemBefore(newItem: SVGTransform, index: number): SVGTransform;
14743 removeItem(index: number): SVGTransform;
14744 replaceItem(newItem: SVGTransform, index: number): SVGTransform;
14747 declare var SVGTransformList: {
14748 prototype: SVGTransformList;
14749 new(): SVGTransformList;
14752 interface SVGURIReference {
14753 readonly href: SVGAnimatedString;
14756 /** A commonly used set of constants used for reflecting gradientUnits, patternContentUnits and other similar attributes. */
14757 interface SVGUnitTypes {
14758 readonly SVG_UNIT_TYPE_OBJECTBOUNDINGBOX: number;
14759 readonly SVG_UNIT_TYPE_UNKNOWN: number;
14760 readonly SVG_UNIT_TYPE_USERSPACEONUSE: number;
14763 declare var SVGUnitTypes: {
14764 prototype: SVGUnitTypes;
14765 new(): SVGUnitTypes;
14766 readonly SVG_UNIT_TYPE_OBJECTBOUNDINGBOX: number;
14767 readonly SVG_UNIT_TYPE_UNKNOWN: number;
14768 readonly SVG_UNIT_TYPE_USERSPACEONUSE: number;
14771 /** Corresponds to the <use> element. */
14772 interface SVGUseElement extends SVGGraphicsElement, SVGURIReference {
14773 readonly animatedInstanceRoot: SVGElementInstance | null;
14774 readonly height: SVGAnimatedLength;
14775 readonly instanceRoot: SVGElementInstance | null;
14776 readonly width: SVGAnimatedLength;
14777 readonly x: SVGAnimatedLength;
14778 readonly y: SVGAnimatedLength;
14779 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGUseElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14780 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14781 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGUseElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14782 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14785 declare var SVGUseElement: {
14786 prototype: SVGUseElement;
14787 new(): SVGUseElement;
14790 /** Provides access to the properties of <view> elements, as well as methods to manipulate them. */
14791 interface SVGViewElement extends SVGElement, SVGFitToViewBox, SVGZoomAndPan {
14793 readonly viewTarget: SVGStringList;
14794 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGViewElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14795 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14796 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGViewElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14797 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14800 declare var SVGViewElement: {
14801 prototype: SVGViewElement;
14802 new(): SVGViewElement;
14803 readonly SVG_ZOOMANDPAN_DISABLE: number;
14804 readonly SVG_ZOOMANDPAN_MAGNIFY: number;
14805 readonly SVG_ZOOMANDPAN_UNKNOWN: number;
14808 /** Used to reflect the zoomAndPan attribute, and is mixed in to other interfaces for elements that support this attribute. */
14809 interface SVGZoomAndPan {
14810 readonly zoomAndPan: number;
14813 declare var SVGZoomAndPan: {
14814 readonly SVG_ZOOMANDPAN_DISABLE: number;
14815 readonly SVG_ZOOMANDPAN_MAGNIFY: number;
14816 readonly SVG_ZOOMANDPAN_UNKNOWN: number;
14819 interface SVGZoomEvent extends UIEvent {
14820 readonly newScale: number;
14821 readonly newTranslate: SVGPoint;
14822 readonly previousScale: number;
14823 readonly previousTranslate: SVGPoint;
14824 readonly zoomRectScreen: SVGRect;
14827 declare var SVGZoomEvent: {
14828 prototype: SVGZoomEvent;
14829 new(): SVGZoomEvent;
14832 interface ScopedCredential {
14833 readonly id: ArrayBuffer;
14834 readonly type: ScopedCredentialType;
14837 declare var ScopedCredential: {
14838 prototype: ScopedCredential;
14839 new(): ScopedCredential;
14842 interface ScopedCredentialInfo {
14843 readonly credential: ScopedCredential;
14844 readonly publicKey: CryptoKey;
14847 declare var ScopedCredentialInfo: {
14848 prototype: ScopedCredentialInfo;
14849 new(): ScopedCredentialInfo;
14852 /** A screen, usually the one on which the current window is being rendered, and is obtained using window.screen. */
14854 readonly availHeight: number;
14855 readonly availWidth: number;
14856 readonly colorDepth: number;
14857 readonly height: number;
14858 readonly orientation: ScreenOrientation;
14859 readonly pixelDepth: number;
14860 readonly width: number;
14863 declare var Screen: {
14868 interface ScreenOrientationEventMap {
14872 interface ScreenOrientation extends EventTarget {
14873 readonly angle: number;
14874 onchange: ((this: ScreenOrientation, ev: Event) => any) | null;
14875 readonly type: OrientationType;
14876 lock(orientation: OrientationLockType): Promise<void>;
14878 addEventListener<K extends keyof ScreenOrientationEventMap>(type: K, listener: (this: ScreenOrientation, ev: ScreenOrientationEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14879 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14880 removeEventListener<K extends keyof ScreenOrientationEventMap>(type: K, listener: (this: ScreenOrientation, ev: ScreenOrientationEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14881 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14884 declare var ScreenOrientation: {
14885 prototype: ScreenOrientation;
14886 new(): ScreenOrientation;
14889 interface ScriptProcessorNodeEventMap {
14890 "audioprocess": AudioProcessingEvent;
14893 /** Allows the generation, processing, or analyzing of audio using JavaScript.
14894 * @deprecated As of the August 29 2014 Web Audio API spec publication, this feature has been marked as deprecated, and was replaced by AudioWorklet (see AudioWorkletNode).
14896 interface ScriptProcessorNode extends AudioNode {
14898 readonly bufferSize: number;
14900 onaudioprocess: ((this: ScriptProcessorNode, ev: AudioProcessingEvent) => any) | null;
14901 addEventListener<K extends keyof ScriptProcessorNodeEventMap>(type: K, listener: (this: ScriptProcessorNode, ev: ScriptProcessorNodeEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14902 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14903 removeEventListener<K extends keyof ScriptProcessorNodeEventMap>(type: K, listener: (this: ScriptProcessorNode, ev: ScriptProcessorNodeEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14904 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14907 declare var ScriptProcessorNode: {
14908 prototype: ScriptProcessorNode;
14909 new(): ScriptProcessorNode;
14912 /** Inherits from Event, and represents the event object of an event sent on a document or worker when its content security policy is violated. */
14913 interface SecurityPolicyViolationEvent extends Event {
14914 readonly blockedURI: string;
14915 readonly columnNumber: number;
14916 readonly documentURI: string;
14917 readonly effectiveDirective: string;
14918 readonly lineNumber: number;
14919 readonly originalPolicy: string;
14920 readonly referrer: string;
14921 readonly sourceFile: string;
14922 readonly statusCode: number;
14923 readonly violatedDirective: string;
14926 declare var SecurityPolicyViolationEvent: {
14927 prototype: SecurityPolicyViolationEvent;
14928 new(type: string, eventInitDict?: SecurityPolicyViolationEventInit): SecurityPolicyViolationEvent;
14931 /** A Selection object represents the range of text selected by the user or the current position of the caret. To obtain a Selection object for examination or modification, call Window.getSelection(). */
14932 interface Selection {
14933 readonly anchorNode: Node | null;
14934 readonly anchorOffset: number;
14935 readonly focusNode: Node | null;
14936 readonly focusOffset: number;
14937 readonly isCollapsed: boolean;
14938 readonly rangeCount: number;
14939 readonly type: string;
14940 addRange(range: Range): void;
14941 collapse(node: Node | null, offset?: number): void;
14942 collapseToEnd(): void;
14943 collapseToStart(): void;
14944 containsNode(node: Node, allowPartialContainment?: boolean): boolean;
14945 deleteFromDocument(): void;
14947 extend(node: Node, offset?: number): void;
14948 getRangeAt(index: number): Range;
14949 removeAllRanges(): void;
14950 removeRange(range: Range): void;
14951 selectAllChildren(node: Node): void;
14952 setBaseAndExtent(anchorNode: Node, anchorOffset: number, focusNode: Node, focusOffset: number): void;
14953 setPosition(node: Node | null, offset?: number): void;
14954 toString(): string;
14957 declare var Selection: {
14958 prototype: Selection;
14960 toString(): string;
14963 interface ServiceUIFrameContext {
14964 getCachedFrameMessage(key: string): string;
14965 postFrameMessage(key: string, data: string): void;
14967 declare var ServiceUIFrameContext: ServiceUIFrameContext;
14969 interface ServiceWorkerEventMap extends AbstractWorkerEventMap {
14970 "statechange": Event;
14973 /** This ServiceWorker API interface provides a reference to a service worker. Multiple browsing contexts (e.g. pages, workers, etc.) can be associated with the same service worker, each through a unique ServiceWorker object. */
14974 interface ServiceWorker extends EventTarget, AbstractWorker {
14975 onstatechange: ((this: ServiceWorker, ev: Event) => any) | null;
14976 readonly scriptURL: string;
14977 readonly state: ServiceWorkerState;
14978 postMessage(message: any, transfer: Transferable[]): void;
14979 postMessage(message: any, options?: PostMessageOptions): void;
14980 addEventListener<K extends keyof ServiceWorkerEventMap>(type: K, listener: (this: ServiceWorker, ev: ServiceWorkerEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14981 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14982 removeEventListener<K extends keyof ServiceWorkerEventMap>(type: K, listener: (this: ServiceWorker, ev: ServiceWorkerEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14983 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14986 declare var ServiceWorker: {
14987 prototype: ServiceWorker;
14988 new(): ServiceWorker;
14991 interface ServiceWorkerContainerEventMap {
14992 "controllerchange": Event;
14993 "message": MessageEvent;
14994 "messageerror": MessageEvent;
14997 /** The ServiceWorkerContainer interface of the ServiceWorker API provides an object representing the service worker as an overall unit in the network ecosystem, including facilities to register, unregister and update service workers, and access the state of service workers and their registrations. */
14998 interface ServiceWorkerContainer extends EventTarget {
14999 readonly controller: ServiceWorker | null;
15000 oncontrollerchange: ((this: ServiceWorkerContainer, ev: Event) => any) | null;
15001 onmessage: ((this: ServiceWorkerContainer, ev: MessageEvent) => any) | null;
15002 onmessageerror: ((this: ServiceWorkerContainer, ev: MessageEvent) => any) | null;
15003 readonly ready: Promise<ServiceWorkerRegistration>;
15004 getRegistration(clientURL?: string): Promise<ServiceWorkerRegistration | undefined>;
15005 getRegistrations(): Promise<ReadonlyArray<ServiceWorkerRegistration>>;
15006 register(scriptURL: string | URL, options?: RegistrationOptions): Promise<ServiceWorkerRegistration>;
15007 startMessages(): void;
15008 addEventListener<K extends keyof ServiceWorkerContainerEventMap>(type: K, listener: (this: ServiceWorkerContainer, ev: ServiceWorkerContainerEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
15009 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
15010 removeEventListener<K extends keyof ServiceWorkerContainerEventMap>(type: K, listener: (this: ServiceWorkerContainer, ev: ServiceWorkerContainerEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
15011 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
15014 declare var ServiceWorkerContainer: {
15015 prototype: ServiceWorkerContainer;
15016 new(): ServiceWorkerContainer;
15019 /** This ServiceWorker API interface contains information about an event sent to a ServiceWorkerContainer target. This extends the default message event to allow setting a ServiceWorker object as the source of a message. The event object is accessed via the handler function of a message event, when fired by a message received from a service worker.
15020 * @deprecated In modern browsers, this interface has been deprecated. Service worker messages will now use the MessageEvent interface, for consistency with other web messaging features.
15022 interface ServiceWorkerMessageEvent extends Event {
15023 readonly data: any;
15024 readonly lastEventId: string;
15025 readonly origin: string;
15026 readonly ports: ReadonlyArray<MessagePort> | null;
15027 readonly source: ServiceWorker | MessagePort | null;
15030 declare var ServiceWorkerMessageEvent: {
15031 prototype: ServiceWorkerMessageEvent;
15032 new(type: string, eventInitDict?: ServiceWorkerMessageEventInit): ServiceWorkerMessageEvent;
15035 interface ServiceWorkerRegistrationEventMap {
15036 "updatefound": Event;
15039 /** This ServiceWorker API interface represents the service worker registration. You register a service worker to control one or more pages that share the same origin. */
15040 interface ServiceWorkerRegistration extends EventTarget {
15041 readonly active: ServiceWorker | null;
15042 readonly installing: ServiceWorker | null;
15043 readonly navigationPreload: NavigationPreloadManager;
15044 onupdatefound: ((this: ServiceWorkerRegistration, ev: Event) => any) | null;
15045 readonly pushManager: PushManager;
15046 readonly scope: string;
15047 readonly sync: SyncManager;
15048 readonly updateViaCache: ServiceWorkerUpdateViaCache;
15049 readonly waiting: ServiceWorker | null;
15050 getNotifications(filter?: GetNotificationOptions): Promise<Notification[]>;
15051 showNotification(title: string, options?: NotificationOptions): Promise<void>;
15052 unregister(): Promise<boolean>;
15053 update(): Promise<void>;
15054 addEventListener<K extends keyof ServiceWorkerRegistrationEventMap>(type: K, listener: (this: ServiceWorkerRegistration, ev: ServiceWorkerRegistrationEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
15055 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
15056 removeEventListener<K extends keyof ServiceWorkerRegistrationEventMap>(type: K, listener: (this: ServiceWorkerRegistration, ev: ServiceWorkerRegistrationEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
15057 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
15060 declare var ServiceWorkerRegistration: {
15061 prototype: ServiceWorkerRegistration;
15062 new(): ServiceWorkerRegistration;
15065 interface ShadowRoot extends DocumentFragment, DocumentOrShadowRoot, InnerHTML {
15066 readonly host: Element;
15067 readonly mode: ShadowRootMode;
15069 * Throws a "NotSupportedError" DOMException if context object is a shadow root.
15073 declare var ShadowRoot: {
15074 prototype: ShadowRoot;
15078 interface SharedWorker extends EventTarget, AbstractWorker {
15080 * Returns sharedWorker's MessagePort object which can be used to communicate with the global environment.
15082 readonly port: MessagePort;
15083 addEventListener<K extends keyof AbstractWorkerEventMap>(type: K, listener: (this: SharedWorker, ev: AbstractWorkerEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
15084 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
15085 removeEventListener<K extends keyof AbstractWorkerEventMap>(type: K, listener: (this: SharedWorker, ev: AbstractWorkerEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
15086 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
15089 declare var SharedWorker: {
15090 prototype: SharedWorker;
15091 new(scriptURL: string, options?: string | WorkerOptions): SharedWorker;
15094 interface Slottable {
15095 readonly assignedSlot: HTMLSlotElement | null;
15098 interface SourceBufferEventMap {
15102 "updateend": Event;
15103 "updatestart": Event;
15106 /** A chunk of media to be passed into an HTMLMediaElement and played, via a MediaSource object. This can be made up of one or several media segments. */
15107 interface SourceBuffer extends EventTarget {
15108 appendWindowEnd: number;
15109 appendWindowStart: number;
15110 readonly buffered: TimeRanges;
15112 onabort: ((this: SourceBuffer, ev: Event) => any) | null;
15113 onerror: ((this: SourceBuffer, ev: Event) => any) | null;
15114 onupdate: ((this: SourceBuffer, ev: Event) => any) | null;
15115 onupdateend: ((this: SourceBuffer, ev: Event) => any) | null;
15116 onupdatestart: ((this: SourceBuffer, ev: Event) => any) | null;
15117 timestampOffset: number;
15118 readonly updating: boolean;
15120 appendBuffer(data: BufferSource): void;
15121 remove(start: number, end: number): void;
15122 addEventListener<K extends keyof SourceBufferEventMap>(type: K, listener: (this: SourceBuffer, ev: SourceBufferEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
15123 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
15124 removeEventListener<K extends keyof SourceBufferEventMap>(type: K, listener: (this: SourceBuffer, ev: SourceBufferEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
15125 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
15128 declare var SourceBuffer: {
15129 prototype: SourceBuffer;
15130 new(): SourceBuffer;
15133 interface SourceBufferListEventMap {
15134 "addsourcebuffer": Event;
15135 "removesourcebuffer": Event;
15138 /** A simple container list for multiple SourceBuffer objects. */
15139 interface SourceBufferList extends EventTarget {
15140 readonly length: number;
15141 onaddsourcebuffer: ((this: SourceBufferList, ev: Event) => any) | null;
15142 onremovesourcebuffer: ((this: SourceBufferList, ev: Event) => any) | null;
15143 addEventListener<K extends keyof SourceBufferListEventMap>(type: K, listener: (this: SourceBufferList, ev: SourceBufferListEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
15144 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
15145 removeEventListener<K extends keyof SourceBufferListEventMap>(type: K, listener: (this: SourceBufferList, ev: SourceBufferListEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
15146 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
15147 [index: number]: SourceBuffer;
15150 declare var SourceBufferList: {
15151 prototype: SourceBufferList;
15152 new(): SourceBufferList;
15155 interface SpeechGrammar {
15160 declare var SpeechGrammar: {
15161 prototype: SpeechGrammar;
15162 new(): SpeechGrammar;
15165 interface SpeechGrammarList {
15166 readonly length: number;
15167 addFromString(string: string, weight?: number): void;
15168 addFromURI(src: string, weight?: number): void;
15169 item(index: number): SpeechGrammar;
15170 [index: number]: SpeechGrammar;
15173 declare var SpeechGrammarList: {
15174 prototype: SpeechGrammarList;
15175 new(): SpeechGrammarList;
15178 interface SpeechRecognitionEventMap {
15180 "audiostart": Event;
15182 "error": SpeechRecognitionErrorEvent;
15183 "nomatch": SpeechRecognitionEvent;
15184 "result": SpeechRecognitionEvent;
15186 "soundstart": Event;
15187 "speechend": Event;
15188 "speechstart": Event;
15192 interface SpeechRecognition extends EventTarget {
15193 continuous: boolean;
15194 grammars: SpeechGrammarList;
15195 interimResults: boolean;
15197 maxAlternatives: number;
15198 onaudioend: ((this: SpeechRecognition, ev: Event) => any) | null;
15199 onaudiostart: ((this: SpeechRecognition, ev: Event) => any) | null;
15200 onend: ((this: SpeechRecognition, ev: Event) => any) | null;
15201 onerror: ((this: SpeechRecognition, ev: SpeechRecognitionErrorEvent) => any) | null;
15202 onnomatch: ((this: SpeechRecognition, ev: SpeechRecognitionEvent) => any) | null;
15203 onresult: ((this: SpeechRecognition, ev: SpeechRecognitionEvent) => any) | null;
15204 onsoundend: ((this: SpeechRecognition, ev: Event) => any) | null;
15205 onsoundstart: ((this: SpeechRecognition, ev: Event) => any) | null;
15206 onspeechend: ((this: SpeechRecognition, ev: Event) => any) | null;
15207 onspeechstart: ((this: SpeechRecognition, ev: Event) => any) | null;
15208 onstart: ((this: SpeechRecognition, ev: Event) => any) | null;
15212 addEventListener<K extends keyof SpeechRecognitionEventMap>(type: K, listener: (this: SpeechRecognition, ev: SpeechRecognitionEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
15213 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
15214 removeEventListener<K extends keyof SpeechRecognitionEventMap>(type: K, listener: (this: SpeechRecognition, ev: SpeechRecognitionEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
15215 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
15218 declare var SpeechRecognition: {
15219 prototype: SpeechRecognition;
15220 new(): SpeechRecognition;
15223 interface SpeechRecognitionAlternative {
15224 readonly confidence: number;
15225 readonly transcript: string;
15228 declare var SpeechRecognitionAlternative: {
15229 prototype: SpeechRecognitionAlternative;
15230 new(): SpeechRecognitionAlternative;
15233 interface SpeechRecognitionErrorEvent extends Event {
15234 readonly error: SpeechRecognitionErrorCode;
15235 readonly message: string;
15238 declare var SpeechRecognitionErrorEvent: {
15239 prototype: SpeechRecognitionErrorEvent;
15240 new(type: string, eventInitDict: SpeechRecognitionErrorEventInit): SpeechRecognitionErrorEvent;
15243 interface SpeechRecognitionEvent extends Event {
15244 readonly resultIndex: number;
15245 readonly results: SpeechRecognitionResultList;
15248 declare var SpeechRecognitionEvent: {
15249 prototype: SpeechRecognitionEvent;
15250 new(type: string, eventInitDict: SpeechRecognitionEventInit): SpeechRecognitionEvent;
15253 interface SpeechRecognitionResult {
15254 readonly isFinal: boolean;
15255 readonly length: number;
15256 item(index: number): SpeechRecognitionAlternative;
15257 [index: number]: SpeechRecognitionAlternative;
15260 declare var SpeechRecognitionResult: {
15261 prototype: SpeechRecognitionResult;
15262 new(): SpeechRecognitionResult;
15265 interface SpeechRecognitionResultList {
15266 readonly length: number;
15267 item(index: number): SpeechRecognitionResult;
15268 [index: number]: SpeechRecognitionResult;
15271 declare var SpeechRecognitionResultList: {
15272 prototype: SpeechRecognitionResultList;
15273 new(): SpeechRecognitionResultList;
15276 interface SpeechSynthesisEventMap {
15277 "voiceschanged": Event;
15280 /** This Web Speech API interface is the controller interface for the speech service; this can be used to retrieve information about the synthesis voices available on the device, start and pause speech, and other commands besides. */
15281 interface SpeechSynthesis extends EventTarget {
15282 onvoiceschanged: ((this: SpeechSynthesis, ev: Event) => any) | null;
15283 readonly paused: boolean;
15284 readonly pending: boolean;
15285 readonly speaking: boolean;
15287 getVoices(): SpeechSynthesisVoice[];
15290 speak(utterance: SpeechSynthesisUtterance): void;
15291 addEventListener<K extends keyof SpeechSynthesisEventMap>(type: K, listener: (this: SpeechSynthesis, ev: SpeechSynthesisEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
15292 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
15293 removeEventListener<K extends keyof SpeechSynthesisEventMap>(type: K, listener: (this: SpeechSynthesis, ev: SpeechSynthesisEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
15294 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
15297 declare var SpeechSynthesis: {
15298 prototype: SpeechSynthesis;
15299 new(): SpeechSynthesis;
15302 interface SpeechSynthesisErrorEvent extends SpeechSynthesisEvent {
15303 readonly error: SpeechSynthesisErrorCode;
15306 declare var SpeechSynthesisErrorEvent: {
15307 prototype: SpeechSynthesisErrorEvent;
15308 new(type: string, eventInitDict: SpeechSynthesisErrorEventInit): SpeechSynthesisErrorEvent;
15311 /** This Web Speech API interface contains information about the current state of SpeechSynthesisUtterance objects that have been processed in the speech service. */
15312 interface SpeechSynthesisEvent extends Event {
15313 readonly charIndex: number;
15314 readonly charLength: number;
15315 readonly elapsedTime: number;
15316 readonly name: string;
15317 readonly utterance: SpeechSynthesisUtterance;
15320 declare var SpeechSynthesisEvent: {
15321 prototype: SpeechSynthesisEvent;
15322 new(type: string, eventInitDict: SpeechSynthesisEventInit): SpeechSynthesisEvent;
15325 interface SpeechSynthesisUtteranceEventMap {
15326 "boundary": SpeechSynthesisEvent;
15327 "end": SpeechSynthesisEvent;
15328 "error": SpeechSynthesisErrorEvent;
15329 "mark": SpeechSynthesisEvent;
15330 "pause": SpeechSynthesisEvent;
15331 "resume": SpeechSynthesisEvent;
15332 "start": SpeechSynthesisEvent;
15335 /** This Web Speech API interface represents a speech request. It contains the content the speech service should read and information about how to read it (e.g. language, pitch and volume.) */
15336 interface SpeechSynthesisUtterance extends EventTarget {
15338 onboundary: ((this: SpeechSynthesisUtterance, ev: SpeechSynthesisEvent) => any) | null;
15339 onend: ((this: SpeechSynthesisUtterance, ev: SpeechSynthesisEvent) => any) | null;
15340 onerror: ((this: SpeechSynthesisUtterance, ev: SpeechSynthesisErrorEvent) => any) | null;
15341 onmark: ((this: SpeechSynthesisUtterance, ev: SpeechSynthesisEvent) => any) | null;
15342 onpause: ((this: SpeechSynthesisUtterance, ev: SpeechSynthesisEvent) => any) | null;
15343 onresume: ((this: SpeechSynthesisUtterance, ev: SpeechSynthesisEvent) => any) | null;
15344 onstart: ((this: SpeechSynthesisUtterance, ev: SpeechSynthesisEvent) => any) | null;
15348 voice: SpeechSynthesisVoice | null;
15350 addEventListener<K extends keyof SpeechSynthesisUtteranceEventMap>(type: K, listener: (this: SpeechSynthesisUtterance, ev: SpeechSynthesisUtteranceEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
15351 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
15352 removeEventListener<K extends keyof SpeechSynthesisUtteranceEventMap>(type: K, listener: (this: SpeechSynthesisUtterance, ev: SpeechSynthesisUtteranceEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
15353 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
15356 declare var SpeechSynthesisUtterance: {
15357 prototype: SpeechSynthesisUtterance;
15358 new(text?: string): SpeechSynthesisUtterance;
15361 /** This Web Speech API interface represents a voice that the system supports. Every SpeechSynthesisVoice has its own relative speech service including information about language, name and URI. */
15362 interface SpeechSynthesisVoice {
15363 readonly default: boolean;
15364 readonly lang: string;
15365 readonly localService: boolean;
15366 readonly name: string;
15367 readonly voiceURI: string;
15370 declare var SpeechSynthesisVoice: {
15371 prototype: SpeechSynthesisVoice;
15372 new(): SpeechSynthesisVoice;
15375 interface StaticRange extends AbstractRange {
15378 declare var StaticRange: {
15379 prototype: StaticRange;
15380 new(init: StaticRangeInit): StaticRange;
15383 /** The pan property takes a unitless value between -1 (full left pan) and 1 (full right pan). This interface was introduced as a much simpler way to apply a simple panning effect than having to use a full PannerNode. */
15384 interface StereoPannerNode extends AudioNode {
15385 readonly pan: AudioParam;
15388 declare var StereoPannerNode: {
15389 prototype: StereoPannerNode;
15390 new(context: BaseAudioContext, options?: StereoPannerOptions): StereoPannerNode;
15393 /** This Web Storage API interface provides access to a particular domain's session or local storage. It allows, for example, the addition, modification, or deletion of stored data items. */
15394 interface Storage {
15396 * Returns the number of key/value pairs currently present in the list associated with the object.
15398 readonly length: number;
15400 * Empties the list associated with the object of all key/value pairs, if there are any.
15404 * Returns the current value associated with the given key, or null if the given key does not exist in the list associated with the object.
15406 getItem(key: string): string | null;
15408 * Returns the name of the nth key in the list, or null if n is greater than or equal to the number of key/value pairs in the object.
15410 key(index: number): string | null;
15412 * Removes the key/value pair with the given key from the list associated with the object, if a key/value pair with the given key exists.
15414 removeItem(key: string): void;
15416 * Sets the value of the pair identified by key to value, creating a new key/value pair if none existed for key previously.
15418 * Throws a "QuotaExceededError" DOMException exception if the new value couldn't be set. (Setting could fail if, e.g., the user has disabled storage for the site, or if the quota has been exceeded.)
15420 setItem(key: string, value: string): void;
15421 [name: string]: any;
15424 declare var Storage: {
15425 prototype: Storage;
15429 /** A StorageEvent is sent to a window when a storage area it has access to is changed within the context of another document. */
15430 interface StorageEvent extends Event {
15432 * Returns the key of the storage item being changed.
15434 readonly key: string | null;
15436 * Returns the new value of the key of the storage item whose value is being changed.
15438 readonly newValue: string | null;
15440 * Returns the old value of the key of the storage item whose value is being changed.
15442 readonly oldValue: string | null;
15444 * Returns the Storage object that was affected.
15446 readonly storageArea: Storage | null;
15448 * Returns the URL of the document whose storage item changed.
15450 readonly url: string;
15453 declare var StorageEvent: {
15454 prototype: StorageEvent;
15455 new(type: string, eventInitDict?: StorageEventInit): StorageEvent;
15458 interface StorageManager {
15459 estimate(): Promise<StorageEstimate>;
15460 persist(): Promise<boolean>;
15461 persisted(): Promise<boolean>;
15464 declare var StorageManager: {
15465 prototype: StorageManager;
15466 new(): StorageManager;
15469 interface StyleMedia {
15470 readonly type: string;
15471 matchMedium(mediaquery: string): boolean;
15474 declare var StyleMedia: {
15475 prototype: StyleMedia;
15479 /** A single style sheet. CSS style sheets will further implement the more specialized CSSStyleSheet interface. */
15480 interface StyleSheet {
15482 readonly href: string | null;
15483 readonly media: MediaList;
15484 readonly ownerNode: Element | ProcessingInstruction | null;
15485 readonly parentStyleSheet: CSSStyleSheet | null;
15486 readonly title: string | null;
15487 readonly type: string;
15490 declare var StyleSheet: {
15491 prototype: StyleSheet;
15495 /** A list of StyleSheet. */
15496 interface StyleSheetList {
15497 readonly length: number;
15498 item(index: number): CSSStyleSheet | null;
15499 [index: number]: CSSStyleSheet;
15502 declare var StyleSheetList: {
15503 prototype: StyleSheetList;
15504 new(): StyleSheetList;
15507 /** This Web Crypto API interface provides a number of low-level cryptographic functions. It is accessed via the Crypto.subtle properties available in a window context (via Window.crypto). */
15508 interface SubtleCrypto {
15509 decrypt(algorithm: AlgorithmIdentifier | RsaOaepParams | AesCtrParams | AesCbcParams | AesCmacParams | AesGcmParams | AesCfbParams, key: CryptoKey, data: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer): Promise<ArrayBuffer>;
15510 deriveBits(algorithm: AlgorithmIdentifier | EcdhKeyDeriveParams | DhKeyDeriveParams | ConcatParams | HkdfParams | Pbkdf2Params, baseKey: CryptoKey, length: number): Promise<ArrayBuffer>;
15511 deriveKey(algorithm: AlgorithmIdentifier | EcdhKeyDeriveParams | DhKeyDeriveParams | ConcatParams | HkdfParams | Pbkdf2Params, baseKey: CryptoKey, derivedKeyType: string | AesDerivedKeyParams | HmacImportParams | ConcatParams | HkdfParams | Pbkdf2Params, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey>;
15512 digest(algorithm: AlgorithmIdentifier, data: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer): Promise<ArrayBuffer>;
15513 encrypt(algorithm: AlgorithmIdentifier | RsaOaepParams | AesCtrParams | AesCbcParams | AesCmacParams | AesGcmParams | AesCfbParams, key: CryptoKey, data: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer): Promise<ArrayBuffer>;
15514 exportKey(format: "jwk", key: CryptoKey): Promise<JsonWebKey>;
15515 exportKey(format: "raw" | "pkcs8" | "spki", key: CryptoKey): Promise<ArrayBuffer>;
15516 exportKey(format: string, key: CryptoKey): Promise<JsonWebKey | ArrayBuffer>;
15517 generateKey(algorithm: RsaHashedKeyGenParams | EcKeyGenParams | DhKeyGenParams, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKeyPair>;
15518 generateKey(algorithm: AesKeyGenParams | HmacKeyGenParams | Pbkdf2Params, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey>;
15519 generateKey(algorithm: AlgorithmIdentifier, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKeyPair | CryptoKey>;
15520 importKey(format: "jwk", keyData: JsonWebKey, algorithm: AlgorithmIdentifier | RsaHashedImportParams | EcKeyImportParams | HmacImportParams | DhImportKeyParams | AesKeyAlgorithm, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey>;
15521 importKey(format: "raw" | "pkcs8" | "spki", keyData: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer, algorithm: AlgorithmIdentifier | RsaHashedImportParams | EcKeyImportParams | HmacImportParams | DhImportKeyParams | AesKeyAlgorithm, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey>;
15522 importKey(format: string, keyData: JsonWebKey | Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer, algorithm: AlgorithmIdentifier | RsaHashedImportParams | EcKeyImportParams | HmacImportParams | DhImportKeyParams | AesKeyAlgorithm, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey>;
15523 sign(algorithm: AlgorithmIdentifier | RsaPssParams | EcdsaParams | AesCmacParams, key: CryptoKey, data: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer): Promise<ArrayBuffer>;
15524 unwrapKey(format: "raw" | "pkcs8" | "spki" | "jwk" | string, wrappedKey: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer, unwrappingKey: CryptoKey, unwrapAlgorithm: AlgorithmIdentifier | RsaOaepParams | AesCtrParams | AesCbcParams | AesCmacParams | AesGcmParams | AesCfbParams, unwrappedKeyAlgorithm: AlgorithmIdentifier | RsaHashedImportParams | EcKeyImportParams | HmacImportParams | DhImportKeyParams | AesKeyAlgorithm, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey>;
15525 verify(algorithm: AlgorithmIdentifier | RsaPssParams | EcdsaParams | AesCmacParams, key: CryptoKey, signature: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer, data: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer): Promise<boolean>;
15526 wrapKey(format: "raw" | "pkcs8" | "spki" | "jwk" | string, key: CryptoKey, wrappingKey: CryptoKey, wrapAlgorithm: AlgorithmIdentifier | RsaOaepParams | AesCtrParams | AesCbcParams | AesCmacParams | AesGcmParams | AesCfbParams): Promise<ArrayBuffer>;
15529 declare var SubtleCrypto: {
15530 prototype: SubtleCrypto;
15531 new(): SubtleCrypto;
15534 /** This ServiceWorker API interface provides an interface for registering and listing sync registrations. */
15535 interface SyncManager {
15536 getTags(): Promise<string[]>;
15537 register(tag: string): Promise<void>;
15540 declare var SyncManager: {
15541 prototype: SyncManager;
15542 new(): SyncManager;
15545 /** The textual content of Element or Attr. If an element has no markup within its content, it has a single child implementing Text that contains the element's text. However, if the element contains markup, it is parsed into information items and Text nodes that form its children. */
15546 interface Text extends CharacterData, Slottable {
15547 readonly assignedSlot: HTMLSlotElement | null;
15549 * Returns the combined data of all direct Text node siblings.
15551 readonly wholeText: string;
15553 * Splits data at the given offset and returns the remainder as Text node.
15555 splitText(offset: number): Text;
15558 declare var Text: {
15560 new(data?: string): Text;
15563 /** A decoder for a specific method, that is a specific character encoding, like utf-8, iso-8859-2, koi8, cp1261, gbk, etc. A decoder takes a stream of bytes as input and emits a stream of code points. For a more scalable, non-native library, see StringView – a C-like representation of strings based on typed arrays. */
15564 interface TextDecoder extends TextDecoderCommon {
15566 * Returns the result of running encoding's decoder. The method can be invoked zero or more times with options's stream set to true, and then once without options's stream (or set to false), to process a fragmented input. If the invocation without options's stream (or set to false) has no input, it's clearest to omit both arguments.
15569 * var string = "", decoder = new TextDecoder(encoding), buffer;
15570 * while(buffer = next_chunk()) {
15571 * string += decoder.decode(buffer, {stream:true});
15573 * string += decoder.decode(); // end-of-queue
15576 * If the error mode is "fatal" and encoding's decoder returns error, throws a TypeError.
15578 decode(input?: BufferSource, options?: TextDecodeOptions): string;
15581 declare var TextDecoder: {
15582 prototype: TextDecoder;
15583 new(label?: string, options?: TextDecoderOptions): TextDecoder;
15586 interface TextDecoderCommon {
15588 * Returns encoding's name, lowercased.
15590 readonly encoding: string;
15592 * Returns true if error mode is "fatal", otherwise false.
15594 readonly fatal: boolean;
15596 * Returns the value of ignore BOM.
15598 readonly ignoreBOM: boolean;
15601 interface TextDecoderStream extends GenericTransformStream, TextDecoderCommon {
15602 readonly readable: ReadableStream<string>;
15603 readonly writable: WritableStream<BufferSource>;
15606 declare var TextDecoderStream: {
15607 prototype: TextDecoderStream;
15608 new(label?: string, options?: TextDecoderOptions): TextDecoderStream;
15611 /** TextEncoder takes a stream of code points as input and emits a stream of bytes. For a more scalable, non-native library, see StringView – a C-like representation of strings based on typed arrays. */
15612 interface TextEncoder extends TextEncoderCommon {
15614 * Returns the result of running UTF-8's encoder.
15616 encode(input?: string): Uint8Array;
15618 * Runs the UTF-8 encoder on source, stores the result of that operation into destination, and returns the progress made as an object wherein read is the number of converted code units of source and written is the number of bytes modified in destination.
15620 encodeInto(source: string, destination: Uint8Array): TextEncoderEncodeIntoResult;
15623 declare var TextEncoder: {
15624 prototype: TextEncoder;
15625 new(): TextEncoder;
15628 interface TextEncoderCommon {
15632 readonly encoding: string;
15635 interface TextEncoderStream extends GenericTransformStream, TextEncoderCommon {
15636 readonly readable: ReadableStream<Uint8Array>;
15637 readonly writable: WritableStream<string>;
15640 declare var TextEncoderStream: {
15641 prototype: TextEncoderStream;
15642 new(): TextEncoderStream;
15645 interface TextEvent extends UIEvent {
15646 readonly data: string;
15647 initTextEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, viewArg: Window, dataArg: string, inputMethod: number, locale: string): void;
15648 readonly DOM_INPUT_METHOD_DROP: number;
15649 readonly DOM_INPUT_METHOD_HANDWRITING: number;
15650 readonly DOM_INPUT_METHOD_IME: number;
15651 readonly DOM_INPUT_METHOD_KEYBOARD: number;
15652 readonly DOM_INPUT_METHOD_MULTIMODAL: number;
15653 readonly DOM_INPUT_METHOD_OPTION: number;
15654 readonly DOM_INPUT_METHOD_PASTE: number;
15655 readonly DOM_INPUT_METHOD_SCRIPT: number;
15656 readonly DOM_INPUT_METHOD_UNKNOWN: number;
15657 readonly DOM_INPUT_METHOD_VOICE: number;
15660 declare var TextEvent: {
15661 prototype: TextEvent;
15663 readonly DOM_INPUT_METHOD_DROP: number;
15664 readonly DOM_INPUT_METHOD_HANDWRITING: number;
15665 readonly DOM_INPUT_METHOD_IME: number;
15666 readonly DOM_INPUT_METHOD_KEYBOARD: number;
15667 readonly DOM_INPUT_METHOD_MULTIMODAL: number;
15668 readonly DOM_INPUT_METHOD_OPTION: number;
15669 readonly DOM_INPUT_METHOD_PASTE: number;
15670 readonly DOM_INPUT_METHOD_SCRIPT: number;
15671 readonly DOM_INPUT_METHOD_UNKNOWN: number;
15672 readonly DOM_INPUT_METHOD_VOICE: number;
15675 /** The dimensions of a piece of text in the canvas, as created by the CanvasRenderingContext2D.measureText() method. */
15676 interface TextMetrics {
15678 * Returns the measurement described below.
15680 readonly actualBoundingBoxAscent: number;
15682 * Returns the measurement described below.
15684 readonly actualBoundingBoxDescent: number;
15686 * Returns the measurement described below.
15688 readonly actualBoundingBoxLeft: number;
15690 * Returns the measurement described below.
15692 readonly actualBoundingBoxRight: number;
15694 * Returns the measurement described below.
15696 readonly alphabeticBaseline: number;
15698 * Returns the measurement described below.
15700 readonly emHeightAscent: number;
15702 * Returns the measurement described below.
15704 readonly emHeightDescent: number;
15706 * Returns the measurement described below.
15708 readonly fontBoundingBoxAscent: number;
15710 * Returns the measurement described below.
15712 readonly fontBoundingBoxDescent: number;
15714 * Returns the measurement described below.
15716 readonly hangingBaseline: number;
15718 * Returns the measurement described below.
15720 readonly ideographicBaseline: number;
15722 * Returns the measurement described below.
15724 readonly width: number;
15727 declare var TextMetrics: {
15728 prototype: TextMetrics;
15729 new(): TextMetrics;
15732 interface TextTrackEventMap {
15733 "cuechange": Event;
15736 /** This interface also inherits properties from EventTarget. */
15737 interface TextTrack extends EventTarget {
15739 * Returns the text track cues from the text track list of cues that are currently active (i.e. that start before the current playback position and end after it), as a TextTrackCueList object.
15741 readonly activeCues: TextTrackCueList | null;
15743 * Returns the text track list of cues, as a TextTrackCueList object.
15745 readonly cues: TextTrackCueList | null;
15747 * Returns the ID of the given track.
15749 * For in-band tracks, this is the ID that can be used with a fragment if the format supports media fragment syntax, and that can be used with the getTrackById() method.
15751 * For TextTrack objects corresponding to track elements, this is the ID of the track element.
15753 readonly id: string;
15755 * Returns the text track in-band metadata track dispatch type string.
15757 readonly inBandMetadataTrackDispatchType: string;
15759 * Returns the text track kind string.
15761 readonly kind: TextTrackKind;
15763 * Returns the text track label, if there is one, or the empty string otherwise (indicating that a custom label probably needs to be generated from the other attributes of the object if the object is exposed to the user).
15765 readonly label: string;
15767 * Returns the text track language string.
15769 readonly language: string;
15771 * Returns the text track mode, represented by a string from the following list:
15773 * Can be set, to change the mode.
15775 mode: TextTrackMode;
15776 oncuechange: ((this: TextTrack, ev: Event) => any) | null;
15777 readonly sourceBuffer: SourceBuffer | null;
15779 * Adds the given cue to textTrack's text track list of cues.
15781 addCue(cue: TextTrackCue): void;
15783 * Removes the given cue from textTrack's text track list of cues.
15785 removeCue(cue: TextTrackCue): void;
15786 addEventListener<K extends keyof TextTrackEventMap>(type: K, listener: (this: TextTrack, ev: TextTrackEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
15787 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
15788 removeEventListener<K extends keyof TextTrackEventMap>(type: K, listener: (this: TextTrack, ev: TextTrackEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
15789 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
15792 declare var TextTrack: {
15793 prototype: TextTrack;
15797 interface TextTrackCueEventMap {
15802 /** TextTrackCues represent a string of text that will be displayed for some duration of time on a TextTrack. This includes the start and end times that the cue will be displayed. A TextTrackCue cannot be used directly, instead one of the derived types (e.g. VTTCue) must be used. */
15803 interface TextTrackCue extends EventTarget {
15805 * Returns the text track cue end time, in seconds.
15811 * Returns the text track cue identifier.
15816 onenter: ((this: TextTrackCue, ev: Event) => any) | null;
15817 onexit: ((this: TextTrackCue, ev: Event) => any) | null;
15819 * Returns true if the text track cue pause-on-exit flag is set, false otherwise.
15823 pauseOnExit: boolean;
15825 * Returns the text track cue start time, in seconds.
15831 * Returns the TextTrack object to which this text track cue belongs, if any, or null otherwise.
15833 readonly track: TextTrack | null;
15834 addEventListener<K extends keyof TextTrackCueEventMap>(type: K, listener: (this: TextTrackCue, ev: TextTrackCueEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
15835 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
15836 removeEventListener<K extends keyof TextTrackCueEventMap>(type: K, listener: (this: TextTrackCue, ev: TextTrackCueEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
15837 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
15840 declare var TextTrackCue: {
15841 prototype: TextTrackCue;
15842 new(): TextTrackCue;
15845 interface TextTrackCueList {
15847 * Returns the number of cues in the list.
15849 readonly length: number;
15851 * Returns the first text track cue (in text track cue order) with text track cue identifier id.
15853 * Returns null if none of the cues have the given identifier or if the argument is the empty string.
15855 getCueById(id: string): TextTrackCue | null;
15856 [index: number]: TextTrackCue;
15859 declare var TextTrackCueList: {
15860 prototype: TextTrackCueList;
15861 new(): TextTrackCueList;
15864 interface TextTrackListEventMap {
15865 "addtrack": TrackEvent;
15867 "removetrack": TrackEvent;
15870 interface TextTrackList extends EventTarget {
15871 readonly length: number;
15872 onaddtrack: ((this: TextTrackList, ev: TrackEvent) => any) | null;
15873 onchange: ((this: TextTrackList, ev: Event) => any) | null;
15874 onremovetrack: ((this: TextTrackList, ev: TrackEvent) => any) | null;
15875 getTrackById(id: string): TextTrack | null;
15876 addEventListener<K extends keyof TextTrackListEventMap>(type: K, listener: (this: TextTrackList, ev: TextTrackListEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
15877 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
15878 removeEventListener<K extends keyof TextTrackListEventMap>(type: K, listener: (this: TextTrackList, ev: TextTrackListEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
15879 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
15880 [index: number]: TextTrack;
15883 declare var TextTrackList: {
15884 prototype: TextTrackList;
15885 new(): TextTrackList;
15888 /** Used to represent a set of time ranges, primarily for the purpose of tracking which portions of media have been buffered when loading it for use by the <audio> and <video>Â elements. */
15889 interface TimeRanges {
15891 * Returns the number of ranges in the object.
15893 readonly length: number;
15895 * Returns the time for the end of the range with the given index.
15897 * Throws an "IndexSizeError" DOMException if the index is out of range.
15899 end(index: number): number;
15901 * Returns the time for the start of the range with the given index.
15903 * Throws an "IndexSizeError" DOMException if the index is out of range.
15905 start(index: number): number;
15908 declare var TimeRanges: {
15909 prototype: TimeRanges;
15913 /** A single contact point on a touch-sensitive device. The contact point is commonly a finger or stylus and the device may be a touchscreen or trackpad. */
15915 readonly altitudeAngle: number;
15916 readonly azimuthAngle: number;
15917 readonly clientX: number;
15918 readonly clientY: number;
15919 readonly force: number;
15920 readonly identifier: number;
15921 readonly pageX: number;
15922 readonly pageY: number;
15923 readonly radiusX: number;
15924 readonly radiusY: number;
15925 readonly rotationAngle: number;
15926 readonly screenX: number;
15927 readonly screenY: number;
15928 readonly target: EventTarget;
15929 readonly touchType: TouchType;
15932 declare var Touch: {
15934 new(touchInitDict: TouchInit): Touch;
15937 /** An event sent when the state of contacts with a touch-sensitive surface changes. This surface can be a touch screen or trackpad, for example. The event can describe one or more points of contact with the screen and includes support for detecting movement, addition and removal of contact points, and so forth. */
15938 interface TouchEvent extends UIEvent {
15939 readonly altKey: boolean;
15940 readonly changedTouches: TouchList;
15941 readonly ctrlKey: boolean;
15942 readonly metaKey: boolean;
15943 readonly shiftKey: boolean;
15944 readonly targetTouches: TouchList;
15945 readonly touches: TouchList;
15948 declare var TouchEvent: {
15949 prototype: TouchEvent;
15950 new(type: string, eventInitDict?: TouchEventInit): TouchEvent;
15953 /** A list of contact points on a touch surface. For example, if the user has three fingers on the touch surface (such as a screen or trackpad), the corresponding TouchList object would have one Touch object for each finger, for a total of three entries. */
15954 interface TouchList {
15955 readonly length: number;
15956 item(index: number): Touch | null;
15957 [index: number]: Touch;
15960 declare var TouchList: {
15961 prototype: TouchList;
15965 /** The TrackEvent interface, part of the HTML DOM specification, is used for events which represent changes to the set of available tracks on an HTML media element; these events are addtrack and removetrack. */
15966 interface TrackEvent extends Event {
15968 * Returns the track object (TextTrack, AudioTrack, or VideoTrack) to which the event relates.
15970 readonly track: TextTrack | null;
15973 declare var TrackEvent: {
15974 prototype: TrackEvent;
15975 new(type: string, eventInitDict?: TrackEventInit): TrackEvent;
15978 interface TransformStream<I = any, O = any> {
15979 readonly readable: ReadableStream<O>;
15980 readonly writable: WritableStream<I>;
15983 declare var TransformStream: {
15984 prototype: TransformStream;
15985 new<I = any, O = any>(transformer?: Transformer<I, O>, writableStrategy?: QueuingStrategy<I>, readableStrategy?: QueuingStrategy<O>): TransformStream<I, O>;
15988 interface TransformStreamDefaultController<O = any> {
15989 readonly desiredSize: number | null;
15990 enqueue(chunk: O): void;
15991 error(reason?: any): void;
15995 declare var TransformStreamDefaultController: {
15996 prototype: TransformStreamDefaultController;
15997 new(): TransformStreamDefaultController;
16000 /** Events providing information related to transitions. */
16001 interface TransitionEvent extends Event {
16002 readonly elapsedTime: number;
16003 readonly propertyName: string;
16004 readonly pseudoElement: string;
16007 declare var TransitionEvent: {
16008 prototype: TransitionEvent;
16009 new(type: string, transitionEventInitDict?: TransitionEventInit): TransitionEvent;
16012 /** The nodes of a document subtree and a position within them. */
16013 interface TreeWalker {
16015 readonly filter: NodeFilter | null;
16016 readonly root: Node;
16017 readonly whatToShow: number;
16018 firstChild(): Node | null;
16019 lastChild(): Node | null;
16020 nextNode(): Node | null;
16021 nextSibling(): Node | null;
16022 parentNode(): Node | null;
16023 previousNode(): Node | null;
16024 previousSibling(): Node | null;
16027 declare var TreeWalker: {
16028 prototype: TreeWalker;
16032 /** Simple user interface events. */
16033 interface UIEvent extends Event {
16034 readonly detail: number;
16035 readonly view: Window | null;
16037 readonly which: number;
16040 declare var UIEvent: {
16041 prototype: UIEvent;
16042 new(type: string, eventInitDict?: UIEventInit): UIEvent;
16045 /** The URLÂ interface represents an object providing static methods used for creating object URLs. */
16051 toString(): string;
16052 readonly origin: string;
16058 readonly searchParams: URLSearchParams;
16065 new(url: string, base?: string | URL): URL;
16066 createObjectURL(object: any): string;
16067 revokeObjectURL(url: string): void;
16070 type webkitURL = URL;
16071 declare var webkitURL: typeof URL;
16073 interface URLSearchParams {
16075 * Appends a specified key/value pair as a new search parameter.
16077 append(name: string, value: string): void;
16079 * Deletes the given search parameter, and its associated value, from the list of all search parameters.
16081 delete(name: string): void;
16083 * Returns the first value associated to the given search parameter.
16085 get(name: string): string | null;
16087 * Returns all the values association with a given search parameter.
16089 getAll(name: string): string[];
16091 * Returns a Boolean indicating if such a search parameter exists.
16093 has(name: string): boolean;
16095 * Sets the value associated to a given search parameter to the given value. If there were several values, delete the others.
16097 set(name: string, value: string): void;
16100 * Returns a string containing a query string suitable for use in a URL. Does not include the question mark.
16102 toString(): string;
16103 forEach(callbackfn: (value: string, key: string, parent: URLSearchParams) => void, thisArg?: any): void;
16106 declare var URLSearchParams: {
16107 prototype: URLSearchParams;
16108 new(init?: string[][] | Record<string, string> | string | URLSearchParams): URLSearchParams;
16109 toString(): string;
16112 /** This WebVR API interface represents any VR device supported by this API. It includes generic information such as device IDs and descriptions, as well as methods for starting to present a VR scene, retrieving eye parameters and display capabilities, and other important functionality. */
16113 interface VRDisplay extends EventTarget {
16114 readonly capabilities: VRDisplayCapabilities;
16117 readonly displayId: number;
16118 readonly displayName: string;
16119 readonly isConnected: boolean;
16120 readonly isPresenting: boolean;
16121 readonly stageParameters: VRStageParameters | null;
16122 cancelAnimationFrame(handle: number): void;
16123 exitPresent(): Promise<void>;
16124 getEyeParameters(whichEye: string): VREyeParameters;
16125 getFrameData(frameData: VRFrameData): boolean;
16126 getLayers(): VRLayer[];
16129 requestAnimationFrame(callback: FrameRequestCallback): number;
16130 requestPresent(layers: VRLayer[]): Promise<void>;
16132 submitFrame(pose?: VRPose): void;
16135 declare var VRDisplay: {
16136 prototype: VRDisplay;
16140 /** This WebVR API interface describes the capabilities of a VRDisplay — its features can be used to perform VR device capability tests, for example can it return position information. */
16141 interface VRDisplayCapabilities {
16142 readonly canPresent: boolean;
16143 readonly hasExternalDisplay: boolean;
16144 readonly hasOrientation: boolean;
16145 readonly hasPosition: boolean;
16146 readonly maxLayers: number;
16149 declare var VRDisplayCapabilities: {
16150 prototype: VRDisplayCapabilities;
16151 new(): VRDisplayCapabilities;
16154 /** This WebVR API interface represents represents the event object of WebVR-related events (see the list of WebVR window extensions). */
16155 interface VRDisplayEvent extends Event {
16156 readonly display: VRDisplay;
16157 readonly reason: VRDisplayEventReason | null;
16160 declare var VRDisplayEvent: {
16161 prototype: VRDisplayEvent;
16162 new(type: string, eventInitDict: VRDisplayEventInit): VRDisplayEvent;
16165 /** This WebVR API interface represents all the information required to correctly render a scene for a given eye, including field of view information. */
16166 interface VREyeParameters {
16168 readonly fieldOfView: VRFieldOfView;
16169 readonly offset: Float32Array;
16170 readonly renderHeight: number;
16171 readonly renderWidth: number;
16174 declare var VREyeParameters: {
16175 prototype: VREyeParameters;
16176 new(): VREyeParameters;
16179 /** This WebVR API interface represents a field of view defined by 4 different degree values describing the view from a center point. */
16180 interface VRFieldOfView {
16181 readonly downDegrees: number;
16182 readonly leftDegrees: number;
16183 readonly rightDegrees: number;
16184 readonly upDegrees: number;
16187 declare var VRFieldOfView: {
16188 prototype: VRFieldOfView;
16189 new(): VRFieldOfView;
16192 /** This WebVR API interface represents all the information needed to render a single frame of a VR scene; constructed by VRDisplay.getFrameData(). */
16193 interface VRFrameData {
16194 readonly leftProjectionMatrix: Float32Array;
16195 readonly leftViewMatrix: Float32Array;
16196 readonly pose: VRPose;
16197 readonly rightProjectionMatrix: Float32Array;
16198 readonly rightViewMatrix: Float32Array;
16199 readonly timestamp: number;
16202 declare var VRFrameData: {
16203 prototype: VRFrameData;
16204 new(): VRFrameData;
16207 /** This WebVR API interface represents the state of a VR sensor at a given timestamp (which includes orientation, position, velocity, and acceleration information.) */
16209 readonly angularAcceleration: Float32Array | null;
16210 readonly angularVelocity: Float32Array | null;
16211 readonly linearAcceleration: Float32Array | null;
16212 readonly linearVelocity: Float32Array | null;
16213 readonly orientation: Float32Array | null;
16214 readonly position: Float32Array | null;
16215 readonly timestamp: number;
16218 declare var VRPose: {
16223 interface VTTCue extends TextTrackCue {
16224 align: AlignSetting;
16225 line: LineAndPositionSetting;
16226 lineAlign: LineAlignSetting;
16227 position: LineAndPositionSetting;
16228 positionAlign: PositionAlignSetting;
16229 region: VTTRegion | null;
16231 snapToLines: boolean;
16233 vertical: DirectionSetting;
16234 getCueAsHTML(): DocumentFragment;
16235 addEventListener<K extends keyof TextTrackCueEventMap>(type: K, listener: (this: VTTCue, ev: TextTrackCueEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
16236 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
16237 removeEventListener<K extends keyof TextTrackCueEventMap>(type: K, listener: (this: VTTCue, ev: TextTrackCueEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
16238 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
16241 declare var VTTCue: {
16243 new(startTime: number, endTime: number, text: string): VTTCue;
16246 interface VTTRegion {
16249 regionAnchorX: number;
16250 regionAnchorY: number;
16251 scroll: ScrollSetting;
16252 viewportAnchorX: number;
16253 viewportAnchorY: number;
16257 declare var VTTRegion: {
16258 prototype: VTTRegion;
16262 /** The validity states that an element can be in, with respect to constraint validation. Together, they help explain why an element's value fails to validate, if it's not valid. */
16263 interface ValidityState {
16264 readonly badInput: boolean;
16265 readonly customError: boolean;
16266 readonly patternMismatch: boolean;
16267 readonly rangeOverflow: boolean;
16268 readonly rangeUnderflow: boolean;
16269 readonly stepMismatch: boolean;
16270 readonly tooLong: boolean;
16271 readonly tooShort: boolean;
16272 readonly typeMismatch: boolean;
16273 readonly valid: boolean;
16274 readonly valueMissing: boolean;
16277 declare var ValidityState: {
16278 prototype: ValidityState;
16279 new(): ValidityState;
16282 /** Returned by the HTMLVideoElement.getVideoPlaybackQuality() method and contains metrics that can be used to determine the playback quality of a video. */
16283 interface VideoPlaybackQuality {
16284 readonly creationTime: number;
16285 readonly droppedVideoFrames: number;
16286 readonly totalVideoFrames: number;
16289 declare var VideoPlaybackQuality: {
16290 prototype: VideoPlaybackQuality;
16291 new(): VideoPlaybackQuality;
16294 interface VisualViewportEventMap {
16299 interface VisualViewport extends EventTarget {
16300 readonly height: number;
16301 readonly offsetLeft: number;
16302 readonly offsetTop: number;
16303 onresize: ((this: VisualViewport, ev: UIEvent) => any) | null;
16304 onscroll: ((this: VisualViewport, ev: Event) => any) | null;
16305 readonly pageLeft: number;
16306 readonly pageTop: number;
16307 readonly scale: number;
16308 readonly width: number;
16309 addEventListener<K extends keyof VisualViewportEventMap>(type: K, listener: (this: VisualViewport, ev: VisualViewportEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
16310 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
16311 removeEventListener<K extends keyof VisualViewportEventMap>(type: K, listener: (this: VisualViewport, ev: VisualViewportEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
16312 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
16315 declare var VisualViewport: {
16316 prototype: VisualViewport;
16317 new(): VisualViewport;
16320 interface WEBGL_color_buffer_float {
16321 readonly FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE_EXT: GLenum;
16322 readonly RGBA32F_EXT: GLenum;
16323 readonly UNSIGNED_NORMALIZED_EXT: GLenum;
16326 interface WEBGL_compressed_texture_astc {
16327 getSupportedProfiles(): string[];
16328 readonly COMPRESSED_RGBA_ASTC_10x10_KHR: GLenum;
16329 readonly COMPRESSED_RGBA_ASTC_10x5_KHR: GLenum;
16330 readonly COMPRESSED_RGBA_ASTC_10x6_KHR: GLenum;
16331 readonly COMPRESSED_RGBA_ASTC_10x8_KHR: GLenum;
16332 readonly COMPRESSED_RGBA_ASTC_12x10_KHR: GLenum;
16333 readonly COMPRESSED_RGBA_ASTC_12x12_KHR: GLenum;
16334 readonly COMPRESSED_RGBA_ASTC_4x4_KHR: GLenum;
16335 readonly COMPRESSED_RGBA_ASTC_5x4_KHR: GLenum;
16336 readonly COMPRESSED_RGBA_ASTC_5x5_KHR: GLenum;
16337 readonly COMPRESSED_RGBA_ASTC_6x5_KHR: GLenum;
16338 readonly COMPRESSED_RGBA_ASTC_6x6_KHR: GLenum;
16339 readonly COMPRESSED_RGBA_ASTC_8x5_KHR: GLenum;
16340 readonly COMPRESSED_RGBA_ASTC_8x6_KHR: GLenum;
16341 readonly COMPRESSED_RGBA_ASTC_8x8_KHR: GLenum;
16342 readonly COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR: GLenum;
16343 readonly COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR: GLenum;
16344 readonly COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR: GLenum;
16345 readonly COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR: GLenum;
16346 readonly COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR: GLenum;
16347 readonly COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR: GLenum;
16348 readonly COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR: GLenum;
16349 readonly COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR: GLenum;
16350 readonly COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR: GLenum;
16351 readonly COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR: GLenum;
16352 readonly COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR: GLenum;
16353 readonly COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR: GLenum;
16354 readonly COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR: GLenum;
16355 readonly COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR: GLenum;
16358 /** The WEBGL_compressed_texture_s3tc extension is part of the WebGL API and exposes four S3TC compressed texture formats. */
16359 interface WEBGL_compressed_texture_s3tc {
16360 readonly COMPRESSED_RGBA_S3TC_DXT1_EXT: GLenum;
16361 readonly COMPRESSED_RGBA_S3TC_DXT3_EXT: GLenum;
16362 readonly COMPRESSED_RGBA_S3TC_DXT5_EXT: GLenum;
16363 readonly COMPRESSED_RGB_S3TC_DXT1_EXT: GLenum;
16366 interface WEBGL_compressed_texture_s3tc_srgb {
16367 readonly COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT: GLenum;
16368 readonly COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT: GLenum;
16369 readonly COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT: GLenum;
16370 readonly COMPRESSED_SRGB_S3TC_DXT1_EXT: GLenum;
16373 /** The WEBGL_debug_renderer_info extension is part of the WebGL API and exposes two constants with information about the graphics driver for debugging purposes. */
16374 interface WEBGL_debug_renderer_info {
16375 readonly UNMASKED_RENDERER_WEBGL: GLenum;
16376 readonly UNMASKED_VENDOR_WEBGL: GLenum;
16379 interface WEBGL_debug_shaders {
16380 getTranslatedShaderSource(shader: WebGLShader): string;
16383 /** The WEBGL_depth_texture extension is part of the WebGL API and defines 2D depth and depth-stencil textures. */
16384 interface WEBGL_depth_texture {
16385 readonly UNSIGNED_INT_24_8_WEBGL: GLenum;
16388 interface WEBGL_draw_buffers {
16389 drawBuffersWEBGL(buffers: GLenum[]): void;
16390 readonly COLOR_ATTACHMENT0_WEBGL: GLenum;
16391 readonly COLOR_ATTACHMENT10_WEBGL: GLenum;
16392 readonly COLOR_ATTACHMENT11_WEBGL: GLenum;
16393 readonly COLOR_ATTACHMENT12_WEBGL: GLenum;
16394 readonly COLOR_ATTACHMENT13_WEBGL: GLenum;
16395 readonly COLOR_ATTACHMENT14_WEBGL: GLenum;
16396 readonly COLOR_ATTACHMENT15_WEBGL: GLenum;
16397 readonly COLOR_ATTACHMENT1_WEBGL: GLenum;
16398 readonly COLOR_ATTACHMENT2_WEBGL: GLenum;
16399 readonly COLOR_ATTACHMENT3_WEBGL: GLenum;
16400 readonly COLOR_ATTACHMENT4_WEBGL: GLenum;
16401 readonly COLOR_ATTACHMENT5_WEBGL: GLenum;
16402 readonly COLOR_ATTACHMENT6_WEBGL: GLenum;
16403 readonly COLOR_ATTACHMENT7_WEBGL: GLenum;
16404 readonly COLOR_ATTACHMENT8_WEBGL: GLenum;
16405 readonly COLOR_ATTACHMENT9_WEBGL: GLenum;
16406 readonly DRAW_BUFFER0_WEBGL: GLenum;
16407 readonly DRAW_BUFFER10_WEBGL: GLenum;
16408 readonly DRAW_BUFFER11_WEBGL: GLenum;
16409 readonly DRAW_BUFFER12_WEBGL: GLenum;
16410 readonly DRAW_BUFFER13_WEBGL: GLenum;
16411 readonly DRAW_BUFFER14_WEBGL: GLenum;
16412 readonly DRAW_BUFFER15_WEBGL: GLenum;
16413 readonly DRAW_BUFFER1_WEBGL: GLenum;
16414 readonly DRAW_BUFFER2_WEBGL: GLenum;
16415 readonly DRAW_BUFFER3_WEBGL: GLenum;
16416 readonly DRAW_BUFFER4_WEBGL: GLenum;
16417 readonly DRAW_BUFFER5_WEBGL: GLenum;
16418 readonly DRAW_BUFFER6_WEBGL: GLenum;
16419 readonly DRAW_BUFFER7_WEBGL: GLenum;
16420 readonly DRAW_BUFFER8_WEBGL: GLenum;
16421 readonly DRAW_BUFFER9_WEBGL: GLenum;
16422 readonly MAX_COLOR_ATTACHMENTS_WEBGL: GLenum;
16423 readonly MAX_DRAW_BUFFERS_WEBGL: GLenum;
16426 interface WEBGL_lose_context {
16427 loseContext(): void;
16428 restoreContext(): void;
16431 /** A WaveShaperNode always has exactly one input and one output. */
16432 interface WaveShaperNode extends AudioNode {
16433 curve: Float32Array | null;
16434 oversample: OverSampleType;
16437 declare var WaveShaperNode: {
16438 prototype: WaveShaperNode;
16439 new(context: BaseAudioContext, options?: WaveShaperOptions): WaveShaperNode;
16442 interface WebAuthentication {
16443 getAssertion(assertionChallenge: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer | null, options?: AssertionOptions): Promise<WebAuthnAssertion>;
16444 makeCredential(accountInformation: Account, cryptoParameters: ScopedCredentialParameters[], attestationChallenge: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer | null, options?: ScopedCredentialOptions): Promise<ScopedCredentialInfo>;
16447 declare var WebAuthentication: {
16448 prototype: WebAuthentication;
16449 new(): WebAuthentication;
16452 interface WebAuthnAssertion {
16453 readonly authenticatorData: ArrayBuffer;
16454 readonly clientData: ArrayBuffer;
16455 readonly credential: ScopedCredential;
16456 readonly signature: ArrayBuffer;
16459 declare var WebAuthnAssertion: {
16460 prototype: WebAuthnAssertion;
16461 new(): WebAuthnAssertion;
16464 interface WebGL2RenderingContext extends WebGL2RenderingContextBase, WebGL2RenderingContextOverloads, WebGLRenderingContextBase {
16467 declare var WebGL2RenderingContext: {
16468 prototype: WebGL2RenderingContext;
16469 new(): WebGL2RenderingContext;
16470 readonly ACTIVE_ATTRIBUTES: GLenum;
16471 readonly ACTIVE_TEXTURE: GLenum;
16472 readonly ACTIVE_UNIFORMS: GLenum;
16473 readonly ALIASED_LINE_WIDTH_RANGE: GLenum;
16474 readonly ALIASED_POINT_SIZE_RANGE: GLenum;
16475 readonly ALPHA: GLenum;
16476 readonly ALPHA_BITS: GLenum;
16477 readonly ALWAYS: GLenum;
16478 readonly ARRAY_BUFFER: GLenum;
16479 readonly ARRAY_BUFFER_BINDING: GLenum;
16480 readonly ATTACHED_SHADERS: GLenum;
16481 readonly BACK: GLenum;
16482 readonly BLEND: GLenum;
16483 readonly BLEND_COLOR: GLenum;
16484 readonly BLEND_DST_ALPHA: GLenum;
16485 readonly BLEND_DST_RGB: GLenum;
16486 readonly BLEND_EQUATION: GLenum;
16487 readonly BLEND_EQUATION_ALPHA: GLenum;
16488 readonly BLEND_EQUATION_RGB: GLenum;
16489 readonly BLEND_SRC_ALPHA: GLenum;
16490 readonly BLEND_SRC_RGB: GLenum;
16491 readonly BLUE_BITS: GLenum;
16492 readonly BOOL: GLenum;
16493 readonly BOOL_VEC2: GLenum;
16494 readonly BOOL_VEC3: GLenum;
16495 readonly BOOL_VEC4: GLenum;
16496 readonly BROWSER_DEFAULT_WEBGL: GLenum;
16497 readonly BUFFER_SIZE: GLenum;
16498 readonly BUFFER_USAGE: GLenum;
16499 readonly BYTE: GLenum;
16500 readonly CCW: GLenum;
16501 readonly CLAMP_TO_EDGE: GLenum;
16502 readonly COLOR_ATTACHMENT0: GLenum;
16503 readonly COLOR_BUFFER_BIT: GLenum;
16504 readonly COLOR_CLEAR_VALUE: GLenum;
16505 readonly COLOR_WRITEMASK: GLenum;
16506 readonly COMPILE_STATUS: GLenum;
16507 readonly COMPRESSED_TEXTURE_FORMATS: GLenum;
16508 readonly CONSTANT_ALPHA: GLenum;
16509 readonly CONSTANT_COLOR: GLenum;
16510 readonly CONTEXT_LOST_WEBGL: GLenum;
16511 readonly CULL_FACE: GLenum;
16512 readonly CULL_FACE_MODE: GLenum;
16513 readonly CURRENT_PROGRAM: GLenum;
16514 readonly CURRENT_VERTEX_ATTRIB: GLenum;
16515 readonly CW: GLenum;
16516 readonly DECR: GLenum;
16517 readonly DECR_WRAP: GLenum;
16518 readonly DELETE_STATUS: GLenum;
16519 readonly DEPTH_ATTACHMENT: GLenum;
16520 readonly DEPTH_BITS: GLenum;
16521 readonly DEPTH_BUFFER_BIT: GLenum;
16522 readonly DEPTH_CLEAR_VALUE: GLenum;
16523 readonly DEPTH_COMPONENT: GLenum;
16524 readonly DEPTH_COMPONENT16: GLenum;
16525 readonly DEPTH_FUNC: GLenum;
16526 readonly DEPTH_RANGE: GLenum;
16527 readonly DEPTH_STENCIL: GLenum;
16528 readonly DEPTH_STENCIL_ATTACHMENT: GLenum;
16529 readonly DEPTH_TEST: GLenum;
16530 readonly DEPTH_WRITEMASK: GLenum;
16531 readonly DITHER: GLenum;
16532 readonly DONT_CARE: GLenum;
16533 readonly DST_ALPHA: GLenum;
16534 readonly DST_COLOR: GLenum;
16535 readonly DYNAMIC_DRAW: GLenum;
16536 readonly ELEMENT_ARRAY_BUFFER: GLenum;
16537 readonly ELEMENT_ARRAY_BUFFER_BINDING: GLenum;
16538 readonly EQUAL: GLenum;
16539 readonly FASTEST: GLenum;
16540 readonly FLOAT: GLenum;
16541 readonly FLOAT_MAT2: GLenum;
16542 readonly FLOAT_MAT3: GLenum;
16543 readonly FLOAT_MAT4: GLenum;
16544 readonly FLOAT_VEC2: GLenum;
16545 readonly FLOAT_VEC3: GLenum;
16546 readonly FLOAT_VEC4: GLenum;
16547 readonly FRAGMENT_SHADER: GLenum;
16548 readonly FRAMEBUFFER: GLenum;
16549 readonly FRAMEBUFFER_ATTACHMENT_OBJECT_NAME: GLenum;
16550 readonly FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE: GLenum;
16551 readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE: GLenum;
16552 readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL: GLenum;
16553 readonly FRAMEBUFFER_BINDING: GLenum;
16554 readonly FRAMEBUFFER_COMPLETE: GLenum;
16555 readonly FRAMEBUFFER_INCOMPLETE_ATTACHMENT: GLenum;
16556 readonly FRAMEBUFFER_INCOMPLETE_DIMENSIONS: GLenum;
16557 readonly FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: GLenum;
16558 readonly FRAMEBUFFER_UNSUPPORTED: GLenum;
16559 readonly FRONT: GLenum;
16560 readonly FRONT_AND_BACK: GLenum;
16561 readonly FRONT_FACE: GLenum;
16562 readonly FUNC_ADD: GLenum;
16563 readonly FUNC_REVERSE_SUBTRACT: GLenum;
16564 readonly FUNC_SUBTRACT: GLenum;
16565 readonly GENERATE_MIPMAP_HINT: GLenum;
16566 readonly GEQUAL: GLenum;
16567 readonly GREATER: GLenum;
16568 readonly GREEN_BITS: GLenum;
16569 readonly HIGH_FLOAT: GLenum;
16570 readonly HIGH_INT: GLenum;
16571 readonly IMPLEMENTATION_COLOR_READ_FORMAT: GLenum;
16572 readonly IMPLEMENTATION_COLOR_READ_TYPE: GLenum;
16573 readonly INCR: GLenum;
16574 readonly INCR_WRAP: GLenum;
16575 readonly INT: GLenum;
16576 readonly INT_VEC2: GLenum;
16577 readonly INT_VEC3: GLenum;
16578 readonly INT_VEC4: GLenum;
16579 readonly INVALID_ENUM: GLenum;
16580 readonly INVALID_FRAMEBUFFER_OPERATION: GLenum;
16581 readonly INVALID_OPERATION: GLenum;
16582 readonly INVALID_VALUE: GLenum;
16583 readonly INVERT: GLenum;
16584 readonly KEEP: GLenum;
16585 readonly LEQUAL: GLenum;
16586 readonly LESS: GLenum;
16587 readonly LINEAR: GLenum;
16588 readonly LINEAR_MIPMAP_LINEAR: GLenum;
16589 readonly LINEAR_MIPMAP_NEAREST: GLenum;
16590 readonly LINES: GLenum;
16591 readonly LINE_LOOP: GLenum;
16592 readonly LINE_STRIP: GLenum;
16593 readonly LINE_WIDTH: GLenum;
16594 readonly LINK_STATUS: GLenum;
16595 readonly LOW_FLOAT: GLenum;
16596 readonly LOW_INT: GLenum;
16597 readonly LUMINANCE: GLenum;
16598 readonly LUMINANCE_ALPHA: GLenum;
16599 readonly MAX_COMBINED_TEXTURE_IMAGE_UNITS: GLenum;
16600 readonly MAX_CUBE_MAP_TEXTURE_SIZE: GLenum;
16601 readonly MAX_FRAGMENT_UNIFORM_VECTORS: GLenum;
16602 readonly MAX_RENDERBUFFER_SIZE: GLenum;
16603 readonly MAX_TEXTURE_IMAGE_UNITS: GLenum;
16604 readonly MAX_TEXTURE_SIZE: GLenum;
16605 readonly MAX_VARYING_VECTORS: GLenum;
16606 readonly MAX_VERTEX_ATTRIBS: GLenum;
16607 readonly MAX_VERTEX_TEXTURE_IMAGE_UNITS: GLenum;
16608 readonly MAX_VERTEX_UNIFORM_VECTORS: GLenum;
16609 readonly MAX_VIEWPORT_DIMS: GLenum;
16610 readonly MEDIUM_FLOAT: GLenum;
16611 readonly MEDIUM_INT: GLenum;
16612 readonly MIRRORED_REPEAT: GLenum;
16613 readonly NEAREST: GLenum;
16614 readonly NEAREST_MIPMAP_LINEAR: GLenum;
16615 readonly NEAREST_MIPMAP_NEAREST: GLenum;
16616 readonly NEVER: GLenum;
16617 readonly NICEST: GLenum;
16618 readonly NONE: GLenum;
16619 readonly NOTEQUAL: GLenum;
16620 readonly NO_ERROR: GLenum;
16621 readonly ONE: GLenum;
16622 readonly ONE_MINUS_CONSTANT_ALPHA: GLenum;
16623 readonly ONE_MINUS_CONSTANT_COLOR: GLenum;
16624 readonly ONE_MINUS_DST_ALPHA: GLenum;
16625 readonly ONE_MINUS_DST_COLOR: GLenum;
16626 readonly ONE_MINUS_SRC_ALPHA: GLenum;
16627 readonly ONE_MINUS_SRC_COLOR: GLenum;
16628 readonly OUT_OF_MEMORY: GLenum;
16629 readonly PACK_ALIGNMENT: GLenum;
16630 readonly POINTS: GLenum;
16631 readonly POLYGON_OFFSET_FACTOR: GLenum;
16632 readonly POLYGON_OFFSET_FILL: GLenum;
16633 readonly POLYGON_OFFSET_UNITS: GLenum;
16634 readonly RED_BITS: GLenum;
16635 readonly RENDERBUFFER: GLenum;
16636 readonly RENDERBUFFER_ALPHA_SIZE: GLenum;
16637 readonly RENDERBUFFER_BINDING: GLenum;
16638 readonly RENDERBUFFER_BLUE_SIZE: GLenum;
16639 readonly RENDERBUFFER_DEPTH_SIZE: GLenum;
16640 readonly RENDERBUFFER_GREEN_SIZE: GLenum;
16641 readonly RENDERBUFFER_HEIGHT: GLenum;
16642 readonly RENDERBUFFER_INTERNAL_FORMAT: GLenum;
16643 readonly RENDERBUFFER_RED_SIZE: GLenum;
16644 readonly RENDERBUFFER_STENCIL_SIZE: GLenum;
16645 readonly RENDERBUFFER_WIDTH: GLenum;
16646 readonly RENDERER: GLenum;
16647 readonly REPEAT: GLenum;
16648 readonly REPLACE: GLenum;
16649 readonly RGB: GLenum;
16650 readonly RGB565: GLenum;
16651 readonly RGB5_A1: GLenum;
16652 readonly RGBA: GLenum;
16653 readonly RGBA4: GLenum;
16654 readonly SAMPLER_2D: GLenum;
16655 readonly SAMPLER_CUBE: GLenum;
16656 readonly SAMPLES: GLenum;
16657 readonly SAMPLE_ALPHA_TO_COVERAGE: GLenum;
16658 readonly SAMPLE_BUFFERS: GLenum;
16659 readonly SAMPLE_COVERAGE: GLenum;
16660 readonly SAMPLE_COVERAGE_INVERT: GLenum;
16661 readonly SAMPLE_COVERAGE_VALUE: GLenum;
16662 readonly SCISSOR_BOX: GLenum;
16663 readonly SCISSOR_TEST: GLenum;
16664 readonly SHADER_TYPE: GLenum;
16665 readonly SHADING_LANGUAGE_VERSION: GLenum;
16666 readonly SHORT: GLenum;
16667 readonly SRC_ALPHA: GLenum;
16668 readonly SRC_ALPHA_SATURATE: GLenum;
16669 readonly SRC_COLOR: GLenum;
16670 readonly STATIC_DRAW: GLenum;
16671 readonly STENCIL_ATTACHMENT: GLenum;
16672 readonly STENCIL_BACK_FAIL: GLenum;
16673 readonly STENCIL_BACK_FUNC: GLenum;
16674 readonly STENCIL_BACK_PASS_DEPTH_FAIL: GLenum;
16675 readonly STENCIL_BACK_PASS_DEPTH_PASS: GLenum;
16676 readonly STENCIL_BACK_REF: GLenum;
16677 readonly STENCIL_BACK_VALUE_MASK: GLenum;
16678 readonly STENCIL_BACK_WRITEMASK: GLenum;
16679 readonly STENCIL_BITS: GLenum;
16680 readonly STENCIL_BUFFER_BIT: GLenum;
16681 readonly STENCIL_CLEAR_VALUE: GLenum;
16682 readonly STENCIL_FAIL: GLenum;
16683 readonly STENCIL_FUNC: GLenum;
16684 readonly STENCIL_INDEX8: GLenum;
16685 readonly STENCIL_PASS_DEPTH_FAIL: GLenum;
16686 readonly STENCIL_PASS_DEPTH_PASS: GLenum;
16687 readonly STENCIL_REF: GLenum;
16688 readonly STENCIL_TEST: GLenum;
16689 readonly STENCIL_VALUE_MASK: GLenum;
16690 readonly STENCIL_WRITEMASK: GLenum;
16691 readonly STREAM_DRAW: GLenum;
16692 readonly SUBPIXEL_BITS: GLenum;
16693 readonly TEXTURE: GLenum;
16694 readonly TEXTURE0: GLenum;
16695 readonly TEXTURE1: GLenum;
16696 readonly TEXTURE10: GLenum;
16697 readonly TEXTURE11: GLenum;
16698 readonly TEXTURE12: GLenum;
16699 readonly TEXTURE13: GLenum;
16700 readonly TEXTURE14: GLenum;
16701 readonly TEXTURE15: GLenum;
16702 readonly TEXTURE16: GLenum;
16703 readonly TEXTURE17: GLenum;
16704 readonly TEXTURE18: GLenum;
16705 readonly TEXTURE19: GLenum;
16706 readonly TEXTURE2: GLenum;
16707 readonly TEXTURE20: GLenum;
16708 readonly TEXTURE21: GLenum;
16709 readonly TEXTURE22: GLenum;
16710 readonly TEXTURE23: GLenum;
16711 readonly TEXTURE24: GLenum;
16712 readonly TEXTURE25: GLenum;
16713 readonly TEXTURE26: GLenum;
16714 readonly TEXTURE27: GLenum;
16715 readonly TEXTURE28: GLenum;
16716 readonly TEXTURE29: GLenum;
16717 readonly TEXTURE3: GLenum;
16718 readonly TEXTURE30: GLenum;
16719 readonly TEXTURE31: GLenum;
16720 readonly TEXTURE4: GLenum;
16721 readonly TEXTURE5: GLenum;
16722 readonly TEXTURE6: GLenum;
16723 readonly TEXTURE7: GLenum;
16724 readonly TEXTURE8: GLenum;
16725 readonly TEXTURE9: GLenum;
16726 readonly TEXTURE_2D: GLenum;
16727 readonly TEXTURE_BINDING_2D: GLenum;
16728 readonly TEXTURE_BINDING_CUBE_MAP: GLenum;
16729 readonly TEXTURE_CUBE_MAP: GLenum;
16730 readonly TEXTURE_CUBE_MAP_NEGATIVE_X: GLenum;
16731 readonly TEXTURE_CUBE_MAP_NEGATIVE_Y: GLenum;
16732 readonly TEXTURE_CUBE_MAP_NEGATIVE_Z: GLenum;
16733 readonly TEXTURE_CUBE_MAP_POSITIVE_X: GLenum;
16734 readonly TEXTURE_CUBE_MAP_POSITIVE_Y: GLenum;
16735 readonly TEXTURE_CUBE_MAP_POSITIVE_Z: GLenum;
16736 readonly TEXTURE_MAG_FILTER: GLenum;
16737 readonly TEXTURE_MIN_FILTER: GLenum;
16738 readonly TEXTURE_WRAP_S: GLenum;
16739 readonly TEXTURE_WRAP_T: GLenum;
16740 readonly TRIANGLES: GLenum;
16741 readonly TRIANGLE_FAN: GLenum;
16742 readonly TRIANGLE_STRIP: GLenum;
16743 readonly UNPACK_ALIGNMENT: GLenum;
16744 readonly UNPACK_COLORSPACE_CONVERSION_WEBGL: GLenum;
16745 readonly UNPACK_FLIP_Y_WEBGL: GLenum;
16746 readonly UNPACK_PREMULTIPLY_ALPHA_WEBGL: GLenum;
16747 readonly UNSIGNED_BYTE: GLenum;
16748 readonly UNSIGNED_INT: GLenum;
16749 readonly UNSIGNED_SHORT: GLenum;
16750 readonly UNSIGNED_SHORT_4_4_4_4: GLenum;
16751 readonly UNSIGNED_SHORT_5_5_5_1: GLenum;
16752 readonly UNSIGNED_SHORT_5_6_5: GLenum;
16753 readonly VALIDATE_STATUS: GLenum;
16754 readonly VENDOR: GLenum;
16755 readonly VERSION: GLenum;
16756 readonly VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: GLenum;
16757 readonly VERTEX_ATTRIB_ARRAY_ENABLED: GLenum;
16758 readonly VERTEX_ATTRIB_ARRAY_NORMALIZED: GLenum;
16759 readonly VERTEX_ATTRIB_ARRAY_POINTER: GLenum;
16760 readonly VERTEX_ATTRIB_ARRAY_SIZE: GLenum;
16761 readonly VERTEX_ATTRIB_ARRAY_STRIDE: GLenum;
16762 readonly VERTEX_ATTRIB_ARRAY_TYPE: GLenum;
16763 readonly VERTEX_SHADER: GLenum;
16764 readonly VIEWPORT: GLenum;
16765 readonly ZERO: GLenum;
16766 readonly ACTIVE_UNIFORM_BLOCKS: GLenum;
16767 readonly ALREADY_SIGNALED: GLenum;
16768 readonly ANY_SAMPLES_PASSED: GLenum;
16769 readonly ANY_SAMPLES_PASSED_CONSERVATIVE: GLenum;
16770 readonly COLOR: GLenum;
16771 readonly COLOR_ATTACHMENT1: GLenum;
16772 readonly COLOR_ATTACHMENT10: GLenum;
16773 readonly COLOR_ATTACHMENT11: GLenum;
16774 readonly COLOR_ATTACHMENT12: GLenum;
16775 readonly COLOR_ATTACHMENT13: GLenum;
16776 readonly COLOR_ATTACHMENT14: GLenum;
16777 readonly COLOR_ATTACHMENT15: GLenum;
16778 readonly COLOR_ATTACHMENT2: GLenum;
16779 readonly COLOR_ATTACHMENT3: GLenum;
16780 readonly COLOR_ATTACHMENT4: GLenum;
16781 readonly COLOR_ATTACHMENT5: GLenum;
16782 readonly COLOR_ATTACHMENT6: GLenum;
16783 readonly COLOR_ATTACHMENT7: GLenum;
16784 readonly COLOR_ATTACHMENT8: GLenum;
16785 readonly COLOR_ATTACHMENT9: GLenum;
16786 readonly COMPARE_REF_TO_TEXTURE: GLenum;
16787 readonly CONDITION_SATISFIED: GLenum;
16788 readonly COPY_READ_BUFFER: GLenum;
16789 readonly COPY_READ_BUFFER_BINDING: GLenum;
16790 readonly COPY_WRITE_BUFFER: GLenum;
16791 readonly COPY_WRITE_BUFFER_BINDING: GLenum;
16792 readonly CURRENT_QUERY: GLenum;
16793 readonly DEPTH: GLenum;
16794 readonly DEPTH24_STENCIL8: GLenum;
16795 readonly DEPTH32F_STENCIL8: GLenum;
16796 readonly DEPTH_COMPONENT24: GLenum;
16797 readonly DEPTH_COMPONENT32F: GLenum;
16798 readonly DRAW_BUFFER0: GLenum;
16799 readonly DRAW_BUFFER1: GLenum;
16800 readonly DRAW_BUFFER10: GLenum;
16801 readonly DRAW_BUFFER11: GLenum;
16802 readonly DRAW_BUFFER12: GLenum;
16803 readonly DRAW_BUFFER13: GLenum;
16804 readonly DRAW_BUFFER14: GLenum;
16805 readonly DRAW_BUFFER15: GLenum;
16806 readonly DRAW_BUFFER2: GLenum;
16807 readonly DRAW_BUFFER3: GLenum;
16808 readonly DRAW_BUFFER4: GLenum;
16809 readonly DRAW_BUFFER5: GLenum;
16810 readonly DRAW_BUFFER6: GLenum;
16811 readonly DRAW_BUFFER7: GLenum;
16812 readonly DRAW_BUFFER8: GLenum;
16813 readonly DRAW_BUFFER9: GLenum;
16814 readonly DRAW_FRAMEBUFFER: GLenum;
16815 readonly DRAW_FRAMEBUFFER_BINDING: GLenum;
16816 readonly DYNAMIC_COPY: GLenum;
16817 readonly DYNAMIC_READ: GLenum;
16818 readonly FLOAT_32_UNSIGNED_INT_24_8_REV: GLenum;
16819 readonly FLOAT_MAT2x3: GLenum;
16820 readonly FLOAT_MAT2x4: GLenum;
16821 readonly FLOAT_MAT3x2: GLenum;
16822 readonly FLOAT_MAT3x4: GLenum;
16823 readonly FLOAT_MAT4x2: GLenum;
16824 readonly FLOAT_MAT4x3: GLenum;
16825 readonly FRAGMENT_SHADER_DERIVATIVE_HINT: GLenum;
16826 readonly FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE: GLenum;
16827 readonly FRAMEBUFFER_ATTACHMENT_BLUE_SIZE: GLenum;
16828 readonly FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING: GLenum;
16829 readonly FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE: GLenum;
16830 readonly FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE: GLenum;
16831 readonly FRAMEBUFFER_ATTACHMENT_GREEN_SIZE: GLenum;
16832 readonly FRAMEBUFFER_ATTACHMENT_RED_SIZE: GLenum;
16833 readonly FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE: GLenum;
16834 readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER: GLenum;
16835 readonly FRAMEBUFFER_DEFAULT: GLenum;
16836 readonly FRAMEBUFFER_INCOMPLETE_MULTISAMPLE: GLenum;
16837 readonly HALF_FLOAT: GLenum;
16838 readonly INTERLEAVED_ATTRIBS: GLenum;
16839 readonly INT_2_10_10_10_REV: GLenum;
16840 readonly INT_SAMPLER_2D: GLenum;
16841 readonly INT_SAMPLER_2D_ARRAY: GLenum;
16842 readonly INT_SAMPLER_3D: GLenum;
16843 readonly INT_SAMPLER_CUBE: GLenum;
16844 readonly INVALID_INDEX: GLenum;
16845 readonly MAX: GLenum;
16846 readonly MAX_3D_TEXTURE_SIZE: GLenum;
16847 readonly MAX_ARRAY_TEXTURE_LAYERS: GLenum;
16848 readonly MAX_CLIENT_WAIT_TIMEOUT_WEBGL: GLenum;
16849 readonly MAX_COLOR_ATTACHMENTS: GLenum;
16850 readonly MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS: GLenum;
16851 readonly MAX_COMBINED_UNIFORM_BLOCKS: GLenum;
16852 readonly MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS: GLenum;
16853 readonly MAX_DRAW_BUFFERS: GLenum;
16854 readonly MAX_ELEMENTS_INDICES: GLenum;
16855 readonly MAX_ELEMENTS_VERTICES: GLenum;
16856 readonly MAX_ELEMENT_INDEX: GLenum;
16857 readonly MAX_FRAGMENT_INPUT_COMPONENTS: GLenum;
16858 readonly MAX_FRAGMENT_UNIFORM_BLOCKS: GLenum;
16859 readonly MAX_FRAGMENT_UNIFORM_COMPONENTS: GLenum;
16860 readonly MAX_PROGRAM_TEXEL_OFFSET: GLenum;
16861 readonly MAX_SAMPLES: GLenum;
16862 readonly MAX_SERVER_WAIT_TIMEOUT: GLenum;
16863 readonly MAX_TEXTURE_LOD_BIAS: GLenum;
16864 readonly MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS: GLenum;
16865 readonly MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS: GLenum;
16866 readonly MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS: GLenum;
16867 readonly MAX_UNIFORM_BLOCK_SIZE: GLenum;
16868 readonly MAX_UNIFORM_BUFFER_BINDINGS: GLenum;
16869 readonly MAX_VARYING_COMPONENTS: GLenum;
16870 readonly MAX_VERTEX_OUTPUT_COMPONENTS: GLenum;
16871 readonly MAX_VERTEX_UNIFORM_BLOCKS: GLenum;
16872 readonly MAX_VERTEX_UNIFORM_COMPONENTS: GLenum;
16873 readonly MIN: GLenum;
16874 readonly MIN_PROGRAM_TEXEL_OFFSET: GLenum;
16875 readonly OBJECT_TYPE: GLenum;
16876 readonly PACK_ROW_LENGTH: GLenum;
16877 readonly PACK_SKIP_PIXELS: GLenum;
16878 readonly PACK_SKIP_ROWS: GLenum;
16879 readonly PIXEL_PACK_BUFFER: GLenum;
16880 readonly PIXEL_PACK_BUFFER_BINDING: GLenum;
16881 readonly PIXEL_UNPACK_BUFFER: GLenum;
16882 readonly PIXEL_UNPACK_BUFFER_BINDING: GLenum;
16883 readonly QUERY_RESULT: GLenum;
16884 readonly QUERY_RESULT_AVAILABLE: GLenum;
16885 readonly R11F_G11F_B10F: GLenum;
16886 readonly R16F: GLenum;
16887 readonly R16I: GLenum;
16888 readonly R16UI: GLenum;
16889 readonly R32F: GLenum;
16890 readonly R32I: GLenum;
16891 readonly R32UI: GLenum;
16892 readonly R8: GLenum;
16893 readonly R8I: GLenum;
16894 readonly R8UI: GLenum;
16895 readonly R8_SNORM: GLenum;
16896 readonly RASTERIZER_DISCARD: GLenum;
16897 readonly READ_BUFFER: GLenum;
16898 readonly READ_FRAMEBUFFER: GLenum;
16899 readonly READ_FRAMEBUFFER_BINDING: GLenum;
16900 readonly RED: GLenum;
16901 readonly RED_INTEGER: GLenum;
16902 readonly RENDERBUFFER_SAMPLES: GLenum;
16903 readonly RG: GLenum;
16904 readonly RG16F: GLenum;
16905 readonly RG16I: GLenum;
16906 readonly RG16UI: GLenum;
16907 readonly RG32F: GLenum;
16908 readonly RG32I: GLenum;
16909 readonly RG32UI: GLenum;
16910 readonly RG8: GLenum;
16911 readonly RG8I: GLenum;
16912 readonly RG8UI: GLenum;
16913 readonly RG8_SNORM: GLenum;
16914 readonly RGB10_A2: GLenum;
16915 readonly RGB10_A2UI: GLenum;
16916 readonly RGB16F: GLenum;
16917 readonly RGB16I: GLenum;
16918 readonly RGB16UI: GLenum;
16919 readonly RGB32F: GLenum;
16920 readonly RGB32I: GLenum;
16921 readonly RGB32UI: GLenum;
16922 readonly RGB8: GLenum;
16923 readonly RGB8I: GLenum;
16924 readonly RGB8UI: GLenum;
16925 readonly RGB8_SNORM: GLenum;
16926 readonly RGB9_E5: GLenum;
16927 readonly RGBA16F: GLenum;
16928 readonly RGBA16I: GLenum;
16929 readonly RGBA16UI: GLenum;
16930 readonly RGBA32F: GLenum;
16931 readonly RGBA32I: GLenum;
16932 readonly RGBA32UI: GLenum;
16933 readonly RGBA8: GLenum;
16934 readonly RGBA8I: GLenum;
16935 readonly RGBA8UI: GLenum;
16936 readonly RGBA8_SNORM: GLenum;
16937 readonly RGBA_INTEGER: GLenum;
16938 readonly RGB_INTEGER: GLenum;
16939 readonly RG_INTEGER: GLenum;
16940 readonly SAMPLER_2D_ARRAY: GLenum;
16941 readonly SAMPLER_2D_ARRAY_SHADOW: GLenum;
16942 readonly SAMPLER_2D_SHADOW: GLenum;
16943 readonly SAMPLER_3D: GLenum;
16944 readonly SAMPLER_BINDING: GLenum;
16945 readonly SAMPLER_CUBE_SHADOW: GLenum;
16946 readonly SEPARATE_ATTRIBS: GLenum;
16947 readonly SIGNALED: GLenum;
16948 readonly SIGNED_NORMALIZED: GLenum;
16949 readonly SRGB: GLenum;
16950 readonly SRGB8: GLenum;
16951 readonly SRGB8_ALPHA8: GLenum;
16952 readonly STATIC_COPY: GLenum;
16953 readonly STATIC_READ: GLenum;
16954 readonly STENCIL: GLenum;
16955 readonly STREAM_COPY: GLenum;
16956 readonly STREAM_READ: GLenum;
16957 readonly SYNC_CONDITION: GLenum;
16958 readonly SYNC_FENCE: GLenum;
16959 readonly SYNC_FLAGS: GLenum;
16960 readonly SYNC_FLUSH_COMMANDS_BIT: GLenum;
16961 readonly SYNC_GPU_COMMANDS_COMPLETE: GLenum;
16962 readonly SYNC_STATUS: GLenum;
16963 readonly TEXTURE_2D_ARRAY: GLenum;
16964 readonly TEXTURE_3D: GLenum;
16965 readonly TEXTURE_BASE_LEVEL: GLenum;
16966 readonly TEXTURE_BINDING_2D_ARRAY: GLenum;
16967 readonly TEXTURE_BINDING_3D: GLenum;
16968 readonly TEXTURE_COMPARE_FUNC: GLenum;
16969 readonly TEXTURE_COMPARE_MODE: GLenum;
16970 readonly TEXTURE_IMMUTABLE_FORMAT: GLenum;
16971 readonly TEXTURE_IMMUTABLE_LEVELS: GLenum;
16972 readonly TEXTURE_MAX_LEVEL: GLenum;
16973 readonly TEXTURE_MAX_LOD: GLenum;
16974 readonly TEXTURE_MIN_LOD: GLenum;
16975 readonly TEXTURE_WRAP_R: GLenum;
16976 readonly TIMEOUT_EXPIRED: GLenum;
16977 readonly TIMEOUT_IGNORED: GLint64;
16978 readonly TRANSFORM_FEEDBACK: GLenum;
16979 readonly TRANSFORM_FEEDBACK_ACTIVE: GLenum;
16980 readonly TRANSFORM_FEEDBACK_BINDING: GLenum;
16981 readonly TRANSFORM_FEEDBACK_BUFFER: GLenum;
16982 readonly TRANSFORM_FEEDBACK_BUFFER_BINDING: GLenum;
16983 readonly TRANSFORM_FEEDBACK_BUFFER_MODE: GLenum;
16984 readonly TRANSFORM_FEEDBACK_BUFFER_SIZE: GLenum;
16985 readonly TRANSFORM_FEEDBACK_BUFFER_START: GLenum;
16986 readonly TRANSFORM_FEEDBACK_PAUSED: GLenum;
16987 readonly TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN: GLenum;
16988 readonly TRANSFORM_FEEDBACK_VARYINGS: GLenum;
16989 readonly UNIFORM_ARRAY_STRIDE: GLenum;
16990 readonly UNIFORM_BLOCK_ACTIVE_UNIFORMS: GLenum;
16991 readonly UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES: GLenum;
16992 readonly UNIFORM_BLOCK_BINDING: GLenum;
16993 readonly UNIFORM_BLOCK_DATA_SIZE: GLenum;
16994 readonly UNIFORM_BLOCK_INDEX: GLenum;
16995 readonly UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER: GLenum;
16996 readonly UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER: GLenum;
16997 readonly UNIFORM_BUFFER: GLenum;
16998 readonly UNIFORM_BUFFER_BINDING: GLenum;
16999 readonly UNIFORM_BUFFER_OFFSET_ALIGNMENT: GLenum;
17000 readonly UNIFORM_BUFFER_SIZE: GLenum;
17001 readonly UNIFORM_BUFFER_START: GLenum;
17002 readonly UNIFORM_IS_ROW_MAJOR: GLenum;
17003 readonly UNIFORM_MATRIX_STRIDE: GLenum;
17004 readonly UNIFORM_OFFSET: GLenum;
17005 readonly UNIFORM_SIZE: GLenum;
17006 readonly UNIFORM_TYPE: GLenum;
17007 readonly UNPACK_IMAGE_HEIGHT: GLenum;
17008 readonly UNPACK_ROW_LENGTH: GLenum;
17009 readonly UNPACK_SKIP_IMAGES: GLenum;
17010 readonly UNPACK_SKIP_PIXELS: GLenum;
17011 readonly UNPACK_SKIP_ROWS: GLenum;
17012 readonly UNSIGNALED: GLenum;
17013 readonly UNSIGNED_INT_10F_11F_11F_REV: GLenum;
17014 readonly UNSIGNED_INT_24_8: GLenum;
17015 readonly UNSIGNED_INT_2_10_10_10_REV: GLenum;
17016 readonly UNSIGNED_INT_5_9_9_9_REV: GLenum;
17017 readonly UNSIGNED_INT_SAMPLER_2D: GLenum;
17018 readonly UNSIGNED_INT_SAMPLER_2D_ARRAY: GLenum;
17019 readonly UNSIGNED_INT_SAMPLER_3D: GLenum;
17020 readonly UNSIGNED_INT_SAMPLER_CUBE: GLenum;
17021 readonly UNSIGNED_INT_VEC2: GLenum;
17022 readonly UNSIGNED_INT_VEC3: GLenum;
17023 readonly UNSIGNED_INT_VEC4: GLenum;
17024 readonly UNSIGNED_NORMALIZED: GLenum;
17025 readonly VERTEX_ARRAY_BINDING: GLenum;
17026 readonly VERTEX_ATTRIB_ARRAY_DIVISOR: GLenum;
17027 readonly VERTEX_ATTRIB_ARRAY_INTEGER: GLenum;
17028 readonly WAIT_FAILED: GLenum;
17031 interface WebGL2RenderingContextBase {
17032 beginQuery(target: GLenum, query: WebGLQuery): void;
17033 beginTransformFeedback(primitiveMode: GLenum): void;
17034 bindBufferBase(target: GLenum, index: GLuint, buffer: WebGLBuffer | null): void;
17035 bindBufferRange(target: GLenum, index: GLuint, buffer: WebGLBuffer | null, offset: GLintptr, size: GLsizeiptr): void;
17036 bindSampler(unit: GLuint, sampler: WebGLSampler | null): void;
17037 bindTransformFeedback(target: GLenum, tf: WebGLTransformFeedback | null): void;
17038 bindVertexArray(array: WebGLVertexArrayObject | null): void;
17039 blitFramebuffer(srcX0: GLint, srcY0: GLint, srcX1: GLint, srcY1: GLint, dstX0: GLint, dstY0: GLint, dstX1: GLint, dstY1: GLint, mask: GLbitfield, filter: GLenum): void;
17040 clearBufferfi(buffer: GLenum, drawbuffer: GLint, depth: GLfloat, stencil: GLint): void;
17041 clearBufferfv(buffer: GLenum, drawbuffer: GLint, values: Float32List, srcOffset?: GLuint): void;
17042 clearBufferiv(buffer: GLenum, drawbuffer: GLint, values: Int32List, srcOffset?: GLuint): void;
17043 clearBufferuiv(buffer: GLenum, drawbuffer: GLint, values: Uint32List, srcOffset?: GLuint): void;
17044 clientWaitSync(sync: WebGLSync, flags: GLbitfield, timeout: GLuint64): GLenum;
17045 compressedTexImage3D(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, imageSize: GLsizei, offset: GLintptr): void;
17046 compressedTexImage3D(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, srcData: ArrayBufferView, srcOffset?: GLuint, srcLengthOverride?: GLuint): void;
17047 compressedTexSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, imageSize: GLsizei, offset: GLintptr): void;
17048 compressedTexSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, srcData: ArrayBufferView, srcOffset?: GLuint, srcLengthOverride?: GLuint): void;
17049 copyBufferSubData(readTarget: GLenum, writeTarget: GLenum, readOffset: GLintptr, writeOffset: GLintptr, size: GLsizeiptr): void;
17050 copyTexSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, x: GLint, y: GLint, width: GLsizei, height: GLsizei): void;
17051 createQuery(): WebGLQuery | null;
17052 createSampler(): WebGLSampler | null;
17053 createTransformFeedback(): WebGLTransformFeedback | null;
17054 createVertexArray(): WebGLVertexArrayObject | null;
17055 deleteQuery(query: WebGLQuery | null): void;
17056 deleteSampler(sampler: WebGLSampler | null): void;
17057 deleteSync(sync: WebGLSync | null): void;
17058 deleteTransformFeedback(tf: WebGLTransformFeedback | null): void;
17059 deleteVertexArray(vertexArray: WebGLVertexArrayObject | null): void;
17060 drawArraysInstanced(mode: GLenum, first: GLint, count: GLsizei, instanceCount: GLsizei): void;
17061 drawBuffers(buffers: GLenum[]): void;
17062 drawElementsInstanced(mode: GLenum, count: GLsizei, type: GLenum, offset: GLintptr, instanceCount: GLsizei): void;
17063 drawRangeElements(mode: GLenum, start: GLuint, end: GLuint, count: GLsizei, type: GLenum, offset: GLintptr): void;
17064 endQuery(target: GLenum): void;
17065 endTransformFeedback(): void;
17066 fenceSync(condition: GLenum, flags: GLbitfield): WebGLSync | null;
17067 framebufferTextureLayer(target: GLenum, attachment: GLenum, texture: WebGLTexture | null, level: GLint, layer: GLint): void;
17068 getActiveUniformBlockName(program: WebGLProgram, uniformBlockIndex: GLuint): string | null;
17069 getActiveUniformBlockParameter(program: WebGLProgram, uniformBlockIndex: GLuint, pname: GLenum): any;
17070 getActiveUniforms(program: WebGLProgram, uniformIndices: GLuint[], pname: GLenum): any;
17071 getBufferSubData(target: GLenum, srcByteOffset: GLintptr, dstBuffer: ArrayBufferView, dstOffset?: GLuint, length?: GLuint): void;
17072 getFragDataLocation(program: WebGLProgram, name: string): GLint;
17073 getIndexedParameter(target: GLenum, index: GLuint): any;
17074 getInternalformatParameter(target: GLenum, internalformat: GLenum, pname: GLenum): any;
17075 getQuery(target: GLenum, pname: GLenum): WebGLQuery | null;
17076 getQueryParameter(query: WebGLQuery, pname: GLenum): any;
17077 getSamplerParameter(sampler: WebGLSampler, pname: GLenum): any;
17078 getSyncParameter(sync: WebGLSync, pname: GLenum): any;
17079 getTransformFeedbackVarying(program: WebGLProgram, index: GLuint): WebGLActiveInfo | null;
17080 getUniformBlockIndex(program: WebGLProgram, uniformBlockName: string): GLuint;
17081 getUniformIndices(program: WebGLProgram, uniformNames: string[]): GLuint[] | null;
17082 invalidateFramebuffer(target: GLenum, attachments: GLenum[]): void;
17083 invalidateSubFramebuffer(target: GLenum, attachments: GLenum[], x: GLint, y: GLint, width: GLsizei, height: GLsizei): void;
17084 isQuery(query: WebGLQuery | null): GLboolean;
17085 isSampler(sampler: WebGLSampler | null): GLboolean;
17086 isSync(sync: WebGLSync | null): GLboolean;
17087 isTransformFeedback(tf: WebGLTransformFeedback | null): GLboolean;
17088 isVertexArray(vertexArray: WebGLVertexArrayObject | null): GLboolean;
17089 pauseTransformFeedback(): void;
17090 readBuffer(src: GLenum): void;
17091 renderbufferStorageMultisample(target: GLenum, samples: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei): void;
17092 resumeTransformFeedback(): void;
17093 samplerParameterf(sampler: WebGLSampler, pname: GLenum, param: GLfloat): void;
17094 samplerParameteri(sampler: WebGLSampler, pname: GLenum, param: GLint): void;
17095 texImage3D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, format: GLenum, type: GLenum, pboOffset: GLintptr): void;
17096 texImage3D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, format: GLenum, type: GLenum, source: TexImageSource): void;
17097 texImage3D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, format: GLenum, type: GLenum, srcData: ArrayBufferView | null): void;
17098 texImage3D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, format: GLenum, type: GLenum, srcData: ArrayBufferView, srcOffset: GLuint): void;
17099 texStorage2D(target: GLenum, levels: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei): void;
17100 texStorage3D(target: GLenum, levels: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei): void;
17101 texSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, type: GLenum, pboOffset: GLintptr): void;
17102 texSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, type: GLenum, source: TexImageSource): void;
17103 texSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, type: GLenum, srcData: ArrayBufferView | null, srcOffset?: GLuint): void;
17104 transformFeedbackVaryings(program: WebGLProgram, varyings: string[], bufferMode: GLenum): void;
17105 uniform1ui(location: WebGLUniformLocation | null, v0: GLuint): void;
17106 uniform1uiv(location: WebGLUniformLocation | null, data: Uint32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17107 uniform2ui(location: WebGLUniformLocation | null, v0: GLuint, v1: GLuint): void;
17108 uniform2uiv(location: WebGLUniformLocation | null, data: Uint32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17109 uniform3ui(location: WebGLUniformLocation | null, v0: GLuint, v1: GLuint, v2: GLuint): void;
17110 uniform3uiv(location: WebGLUniformLocation | null, data: Uint32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17111 uniform4ui(location: WebGLUniformLocation | null, v0: GLuint, v1: GLuint, v2: GLuint, v3: GLuint): void;
17112 uniform4uiv(location: WebGLUniformLocation | null, data: Uint32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17113 uniformBlockBinding(program: WebGLProgram, uniformBlockIndex: GLuint, uniformBlockBinding: GLuint): void;
17114 uniformMatrix2x3fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17115 uniformMatrix2x4fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17116 uniformMatrix3x2fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17117 uniformMatrix3x4fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17118 uniformMatrix4x2fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17119 uniformMatrix4x3fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17120 vertexAttribDivisor(index: GLuint, divisor: GLuint): void;
17121 vertexAttribI4i(index: GLuint, x: GLint, y: GLint, z: GLint, w: GLint): void;
17122 vertexAttribI4iv(index: GLuint, values: Int32List): void;
17123 vertexAttribI4ui(index: GLuint, x: GLuint, y: GLuint, z: GLuint, w: GLuint): void;
17124 vertexAttribI4uiv(index: GLuint, values: Uint32List): void;
17125 vertexAttribIPointer(index: GLuint, size: GLint, type: GLenum, stride: GLsizei, offset: GLintptr): void;
17126 waitSync(sync: WebGLSync, flags: GLbitfield, timeout: GLint64): void;
17127 readonly ACTIVE_UNIFORM_BLOCKS: GLenum;
17128 readonly ALREADY_SIGNALED: GLenum;
17129 readonly ANY_SAMPLES_PASSED: GLenum;
17130 readonly ANY_SAMPLES_PASSED_CONSERVATIVE: GLenum;
17131 readonly COLOR: GLenum;
17132 readonly COLOR_ATTACHMENT1: GLenum;
17133 readonly COLOR_ATTACHMENT10: GLenum;
17134 readonly COLOR_ATTACHMENT11: GLenum;
17135 readonly COLOR_ATTACHMENT12: GLenum;
17136 readonly COLOR_ATTACHMENT13: GLenum;
17137 readonly COLOR_ATTACHMENT14: GLenum;
17138 readonly COLOR_ATTACHMENT15: GLenum;
17139 readonly COLOR_ATTACHMENT2: GLenum;
17140 readonly COLOR_ATTACHMENT3: GLenum;
17141 readonly COLOR_ATTACHMENT4: GLenum;
17142 readonly COLOR_ATTACHMENT5: GLenum;
17143 readonly COLOR_ATTACHMENT6: GLenum;
17144 readonly COLOR_ATTACHMENT7: GLenum;
17145 readonly COLOR_ATTACHMENT8: GLenum;
17146 readonly COLOR_ATTACHMENT9: GLenum;
17147 readonly COMPARE_REF_TO_TEXTURE: GLenum;
17148 readonly CONDITION_SATISFIED: GLenum;
17149 readonly COPY_READ_BUFFER: GLenum;
17150 readonly COPY_READ_BUFFER_BINDING: GLenum;
17151 readonly COPY_WRITE_BUFFER: GLenum;
17152 readonly COPY_WRITE_BUFFER_BINDING: GLenum;
17153 readonly CURRENT_QUERY: GLenum;
17154 readonly DEPTH: GLenum;
17155 readonly DEPTH24_STENCIL8: GLenum;
17156 readonly DEPTH32F_STENCIL8: GLenum;
17157 readonly DEPTH_COMPONENT24: GLenum;
17158 readonly DEPTH_COMPONENT32F: GLenum;
17159 readonly DRAW_BUFFER0: GLenum;
17160 readonly DRAW_BUFFER1: GLenum;
17161 readonly DRAW_BUFFER10: GLenum;
17162 readonly DRAW_BUFFER11: GLenum;
17163 readonly DRAW_BUFFER12: GLenum;
17164 readonly DRAW_BUFFER13: GLenum;
17165 readonly DRAW_BUFFER14: GLenum;
17166 readonly DRAW_BUFFER15: GLenum;
17167 readonly DRAW_BUFFER2: GLenum;
17168 readonly DRAW_BUFFER3: GLenum;
17169 readonly DRAW_BUFFER4: GLenum;
17170 readonly DRAW_BUFFER5: GLenum;
17171 readonly DRAW_BUFFER6: GLenum;
17172 readonly DRAW_BUFFER7: GLenum;
17173 readonly DRAW_BUFFER8: GLenum;
17174 readonly DRAW_BUFFER9: GLenum;
17175 readonly DRAW_FRAMEBUFFER: GLenum;
17176 readonly DRAW_FRAMEBUFFER_BINDING: GLenum;
17177 readonly DYNAMIC_COPY: GLenum;
17178 readonly DYNAMIC_READ: GLenum;
17179 readonly FLOAT_32_UNSIGNED_INT_24_8_REV: GLenum;
17180 readonly FLOAT_MAT2x3: GLenum;
17181 readonly FLOAT_MAT2x4: GLenum;
17182 readonly FLOAT_MAT3x2: GLenum;
17183 readonly FLOAT_MAT3x4: GLenum;
17184 readonly FLOAT_MAT4x2: GLenum;
17185 readonly FLOAT_MAT4x3: GLenum;
17186 readonly FRAGMENT_SHADER_DERIVATIVE_HINT: GLenum;
17187 readonly FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE: GLenum;
17188 readonly FRAMEBUFFER_ATTACHMENT_BLUE_SIZE: GLenum;
17189 readonly FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING: GLenum;
17190 readonly FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE: GLenum;
17191 readonly FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE: GLenum;
17192 readonly FRAMEBUFFER_ATTACHMENT_GREEN_SIZE: GLenum;
17193 readonly FRAMEBUFFER_ATTACHMENT_RED_SIZE: GLenum;
17194 readonly FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE: GLenum;
17195 readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER: GLenum;
17196 readonly FRAMEBUFFER_DEFAULT: GLenum;
17197 readonly FRAMEBUFFER_INCOMPLETE_MULTISAMPLE: GLenum;
17198 readonly HALF_FLOAT: GLenum;
17199 readonly INTERLEAVED_ATTRIBS: GLenum;
17200 readonly INT_2_10_10_10_REV: GLenum;
17201 readonly INT_SAMPLER_2D: GLenum;
17202 readonly INT_SAMPLER_2D_ARRAY: GLenum;
17203 readonly INT_SAMPLER_3D: GLenum;
17204 readonly INT_SAMPLER_CUBE: GLenum;
17205 readonly INVALID_INDEX: GLenum;
17206 readonly MAX: GLenum;
17207 readonly MAX_3D_TEXTURE_SIZE: GLenum;
17208 readonly MAX_ARRAY_TEXTURE_LAYERS: GLenum;
17209 readonly MAX_CLIENT_WAIT_TIMEOUT_WEBGL: GLenum;
17210 readonly MAX_COLOR_ATTACHMENTS: GLenum;
17211 readonly MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS: GLenum;
17212 readonly MAX_COMBINED_UNIFORM_BLOCKS: GLenum;
17213 readonly MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS: GLenum;
17214 readonly MAX_DRAW_BUFFERS: GLenum;
17215 readonly MAX_ELEMENTS_INDICES: GLenum;
17216 readonly MAX_ELEMENTS_VERTICES: GLenum;
17217 readonly MAX_ELEMENT_INDEX: GLenum;
17218 readonly MAX_FRAGMENT_INPUT_COMPONENTS: GLenum;
17219 readonly MAX_FRAGMENT_UNIFORM_BLOCKS: GLenum;
17220 readonly MAX_FRAGMENT_UNIFORM_COMPONENTS: GLenum;
17221 readonly MAX_PROGRAM_TEXEL_OFFSET: GLenum;
17222 readonly MAX_SAMPLES: GLenum;
17223 readonly MAX_SERVER_WAIT_TIMEOUT: GLenum;
17224 readonly MAX_TEXTURE_LOD_BIAS: GLenum;
17225 readonly MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS: GLenum;
17226 readonly MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS: GLenum;
17227 readonly MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS: GLenum;
17228 readonly MAX_UNIFORM_BLOCK_SIZE: GLenum;
17229 readonly MAX_UNIFORM_BUFFER_BINDINGS: GLenum;
17230 readonly MAX_VARYING_COMPONENTS: GLenum;
17231 readonly MAX_VERTEX_OUTPUT_COMPONENTS: GLenum;
17232 readonly MAX_VERTEX_UNIFORM_BLOCKS: GLenum;
17233 readonly MAX_VERTEX_UNIFORM_COMPONENTS: GLenum;
17234 readonly MIN: GLenum;
17235 readonly MIN_PROGRAM_TEXEL_OFFSET: GLenum;
17236 readonly OBJECT_TYPE: GLenum;
17237 readonly PACK_ROW_LENGTH: GLenum;
17238 readonly PACK_SKIP_PIXELS: GLenum;
17239 readonly PACK_SKIP_ROWS: GLenum;
17240 readonly PIXEL_PACK_BUFFER: GLenum;
17241 readonly PIXEL_PACK_BUFFER_BINDING: GLenum;
17242 readonly PIXEL_UNPACK_BUFFER: GLenum;
17243 readonly PIXEL_UNPACK_BUFFER_BINDING: GLenum;
17244 readonly QUERY_RESULT: GLenum;
17245 readonly QUERY_RESULT_AVAILABLE: GLenum;
17246 readonly R11F_G11F_B10F: GLenum;
17247 readonly R16F: GLenum;
17248 readonly R16I: GLenum;
17249 readonly R16UI: GLenum;
17250 readonly R32F: GLenum;
17251 readonly R32I: GLenum;
17252 readonly R32UI: GLenum;
17253 readonly R8: GLenum;
17254 readonly R8I: GLenum;
17255 readonly R8UI: GLenum;
17256 readonly R8_SNORM: GLenum;
17257 readonly RASTERIZER_DISCARD: GLenum;
17258 readonly READ_BUFFER: GLenum;
17259 readonly READ_FRAMEBUFFER: GLenum;
17260 readonly READ_FRAMEBUFFER_BINDING: GLenum;
17261 readonly RED: GLenum;
17262 readonly RED_INTEGER: GLenum;
17263 readonly RENDERBUFFER_SAMPLES: GLenum;
17264 readonly RG: GLenum;
17265 readonly RG16F: GLenum;
17266 readonly RG16I: GLenum;
17267 readonly RG16UI: GLenum;
17268 readonly RG32F: GLenum;
17269 readonly RG32I: GLenum;
17270 readonly RG32UI: GLenum;
17271 readonly RG8: GLenum;
17272 readonly RG8I: GLenum;
17273 readonly RG8UI: GLenum;
17274 readonly RG8_SNORM: GLenum;
17275 readonly RGB10_A2: GLenum;
17276 readonly RGB10_A2UI: GLenum;
17277 readonly RGB16F: GLenum;
17278 readonly RGB16I: GLenum;
17279 readonly RGB16UI: GLenum;
17280 readonly RGB32F: GLenum;
17281 readonly RGB32I: GLenum;
17282 readonly RGB32UI: GLenum;
17283 readonly RGB8: GLenum;
17284 readonly RGB8I: GLenum;
17285 readonly RGB8UI: GLenum;
17286 readonly RGB8_SNORM: GLenum;
17287 readonly RGB9_E5: GLenum;
17288 readonly RGBA16F: GLenum;
17289 readonly RGBA16I: GLenum;
17290 readonly RGBA16UI: GLenum;
17291 readonly RGBA32F: GLenum;
17292 readonly RGBA32I: GLenum;
17293 readonly RGBA32UI: GLenum;
17294 readonly RGBA8: GLenum;
17295 readonly RGBA8I: GLenum;
17296 readonly RGBA8UI: GLenum;
17297 readonly RGBA8_SNORM: GLenum;
17298 readonly RGBA_INTEGER: GLenum;
17299 readonly RGB_INTEGER: GLenum;
17300 readonly RG_INTEGER: GLenum;
17301 readonly SAMPLER_2D_ARRAY: GLenum;
17302 readonly SAMPLER_2D_ARRAY_SHADOW: GLenum;
17303 readonly SAMPLER_2D_SHADOW: GLenum;
17304 readonly SAMPLER_3D: GLenum;
17305 readonly SAMPLER_BINDING: GLenum;
17306 readonly SAMPLER_CUBE_SHADOW: GLenum;
17307 readonly SEPARATE_ATTRIBS: GLenum;
17308 readonly SIGNALED: GLenum;
17309 readonly SIGNED_NORMALIZED: GLenum;
17310 readonly SRGB: GLenum;
17311 readonly SRGB8: GLenum;
17312 readonly SRGB8_ALPHA8: GLenum;
17313 readonly STATIC_COPY: GLenum;
17314 readonly STATIC_READ: GLenum;
17315 readonly STENCIL: GLenum;
17316 readonly STREAM_COPY: GLenum;
17317 readonly STREAM_READ: GLenum;
17318 readonly SYNC_CONDITION: GLenum;
17319 readonly SYNC_FENCE: GLenum;
17320 readonly SYNC_FLAGS: GLenum;
17321 readonly SYNC_FLUSH_COMMANDS_BIT: GLenum;
17322 readonly SYNC_GPU_COMMANDS_COMPLETE: GLenum;
17323 readonly SYNC_STATUS: GLenum;
17324 readonly TEXTURE_2D_ARRAY: GLenum;
17325 readonly TEXTURE_3D: GLenum;
17326 readonly TEXTURE_BASE_LEVEL: GLenum;
17327 readonly TEXTURE_BINDING_2D_ARRAY: GLenum;
17328 readonly TEXTURE_BINDING_3D: GLenum;
17329 readonly TEXTURE_COMPARE_FUNC: GLenum;
17330 readonly TEXTURE_COMPARE_MODE: GLenum;
17331 readonly TEXTURE_IMMUTABLE_FORMAT: GLenum;
17332 readonly TEXTURE_IMMUTABLE_LEVELS: GLenum;
17333 readonly TEXTURE_MAX_LEVEL: GLenum;
17334 readonly TEXTURE_MAX_LOD: GLenum;
17335 readonly TEXTURE_MIN_LOD: GLenum;
17336 readonly TEXTURE_WRAP_R: GLenum;
17337 readonly TIMEOUT_EXPIRED: GLenum;
17338 readonly TIMEOUT_IGNORED: GLint64;
17339 readonly TRANSFORM_FEEDBACK: GLenum;
17340 readonly TRANSFORM_FEEDBACK_ACTIVE: GLenum;
17341 readonly TRANSFORM_FEEDBACK_BINDING: GLenum;
17342 readonly TRANSFORM_FEEDBACK_BUFFER: GLenum;
17343 readonly TRANSFORM_FEEDBACK_BUFFER_BINDING: GLenum;
17344 readonly TRANSFORM_FEEDBACK_BUFFER_MODE: GLenum;
17345 readonly TRANSFORM_FEEDBACK_BUFFER_SIZE: GLenum;
17346 readonly TRANSFORM_FEEDBACK_BUFFER_START: GLenum;
17347 readonly TRANSFORM_FEEDBACK_PAUSED: GLenum;
17348 readonly TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN: GLenum;
17349 readonly TRANSFORM_FEEDBACK_VARYINGS: GLenum;
17350 readonly UNIFORM_ARRAY_STRIDE: GLenum;
17351 readonly UNIFORM_BLOCK_ACTIVE_UNIFORMS: GLenum;
17352 readonly UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES: GLenum;
17353 readonly UNIFORM_BLOCK_BINDING: GLenum;
17354 readonly UNIFORM_BLOCK_DATA_SIZE: GLenum;
17355 readonly UNIFORM_BLOCK_INDEX: GLenum;
17356 readonly UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER: GLenum;
17357 readonly UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER: GLenum;
17358 readonly UNIFORM_BUFFER: GLenum;
17359 readonly UNIFORM_BUFFER_BINDING: GLenum;
17360 readonly UNIFORM_BUFFER_OFFSET_ALIGNMENT: GLenum;
17361 readonly UNIFORM_BUFFER_SIZE: GLenum;
17362 readonly UNIFORM_BUFFER_START: GLenum;
17363 readonly UNIFORM_IS_ROW_MAJOR: GLenum;
17364 readonly UNIFORM_MATRIX_STRIDE: GLenum;
17365 readonly UNIFORM_OFFSET: GLenum;
17366 readonly UNIFORM_SIZE: GLenum;
17367 readonly UNIFORM_TYPE: GLenum;
17368 readonly UNPACK_IMAGE_HEIGHT: GLenum;
17369 readonly UNPACK_ROW_LENGTH: GLenum;
17370 readonly UNPACK_SKIP_IMAGES: GLenum;
17371 readonly UNPACK_SKIP_PIXELS: GLenum;
17372 readonly UNPACK_SKIP_ROWS: GLenum;
17373 readonly UNSIGNALED: GLenum;
17374 readonly UNSIGNED_INT_10F_11F_11F_REV: GLenum;
17375 readonly UNSIGNED_INT_24_8: GLenum;
17376 readonly UNSIGNED_INT_2_10_10_10_REV: GLenum;
17377 readonly UNSIGNED_INT_5_9_9_9_REV: GLenum;
17378 readonly UNSIGNED_INT_SAMPLER_2D: GLenum;
17379 readonly UNSIGNED_INT_SAMPLER_2D_ARRAY: GLenum;
17380 readonly UNSIGNED_INT_SAMPLER_3D: GLenum;
17381 readonly UNSIGNED_INT_SAMPLER_CUBE: GLenum;
17382 readonly UNSIGNED_INT_VEC2: GLenum;
17383 readonly UNSIGNED_INT_VEC3: GLenum;
17384 readonly UNSIGNED_INT_VEC4: GLenum;
17385 readonly UNSIGNED_NORMALIZED: GLenum;
17386 readonly VERTEX_ARRAY_BINDING: GLenum;
17387 readonly VERTEX_ATTRIB_ARRAY_DIVISOR: GLenum;
17388 readonly VERTEX_ATTRIB_ARRAY_INTEGER: GLenum;
17389 readonly WAIT_FAILED: GLenum;
17392 interface WebGL2RenderingContextOverloads {
17393 bufferData(target: GLenum, size: GLsizeiptr, usage: GLenum): void;
17394 bufferData(target: GLenum, srcData: BufferSource | null, usage: GLenum): void;
17395 bufferData(target: GLenum, srcData: ArrayBufferView, usage: GLenum, srcOffset: GLuint, length?: GLuint): void;
17396 bufferSubData(target: GLenum, dstByteOffset: GLintptr, srcData: BufferSource): void;
17397 bufferSubData(target: GLenum, dstByteOffset: GLintptr, srcData: ArrayBufferView, srcOffset: GLuint, length?: GLuint): void;
17398 compressedTexImage2D(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, border: GLint, imageSize: GLsizei, offset: GLintptr): void;
17399 compressedTexImage2D(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, border: GLint, srcData: ArrayBufferView, srcOffset?: GLuint, srcLengthOverride?: GLuint): void;
17400 compressedTexSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, imageSize: GLsizei, offset: GLintptr): void;
17401 compressedTexSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, srcData: ArrayBufferView, srcOffset?: GLuint, srcLengthOverride?: GLuint): void;
17402 readPixels(x: GLint, y: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, dstData: ArrayBufferView | null): void;
17403 readPixels(x: GLint, y: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, offset: GLintptr): void;
17404 readPixels(x: GLint, y: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, dstData: ArrayBufferView, dstOffset: GLuint): void;
17405 texImage2D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, border: GLint, format: GLenum, type: GLenum, pixels: ArrayBufferView | null): void;
17406 texImage2D(target: GLenum, level: GLint, internalformat: GLint, format: GLenum, type: GLenum, source: TexImageSource): void;
17407 texImage2D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, border: GLint, format: GLenum, type: GLenum, pboOffset: GLintptr): void;
17408 texImage2D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, border: GLint, format: GLenum, type: GLenum, source: TexImageSource): void;
17409 texImage2D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, border: GLint, format: GLenum, type: GLenum, srcData: ArrayBufferView, srcOffset: GLuint): void;
17410 texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, pixels: ArrayBufferView | null): void;
17411 texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, format: GLenum, type: GLenum, source: TexImageSource): void;
17412 texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, pboOffset: GLintptr): void;
17413 texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, source: TexImageSource): void;
17414 texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, srcData: ArrayBufferView, srcOffset: GLuint): void;
17415 uniform1fv(location: WebGLUniformLocation | null, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17416 uniform1iv(location: WebGLUniformLocation | null, data: Int32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17417 uniform2fv(location: WebGLUniformLocation | null, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17418 uniform2iv(location: WebGLUniformLocation | null, data: Int32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17419 uniform3fv(location: WebGLUniformLocation | null, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17420 uniform3iv(location: WebGLUniformLocation | null, data: Int32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17421 uniform4fv(location: WebGLUniformLocation | null, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17422 uniform4iv(location: WebGLUniformLocation | null, data: Int32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17423 uniformMatrix2fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17424 uniformMatrix3fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17425 uniformMatrix4fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
17428 /** Part of the WebGL API and represents the information returned by calling the WebGLRenderingContext.getActiveAttrib() and WebGLRenderingContext.getActiveUniform() methods. */
17429 interface WebGLActiveInfo {
17430 readonly name: string;
17431 readonly size: GLint;
17432 readonly type: GLenum;
17435 declare var WebGLActiveInfo: {
17436 prototype: WebGLActiveInfo;
17437 new(): WebGLActiveInfo;
17440 /** Part of the WebGL API and represents an opaque buffer object storing data such as vertices or colors. */
17441 interface WebGLBuffer extends WebGLObject {
17444 declare var WebGLBuffer: {
17445 prototype: WebGLBuffer;
17446 new(): WebGLBuffer;
17449 /** The WebContextEvent interface is part of the WebGL API and is an interface for an event that is generated in response to a status change to the WebGL rendering context. */
17450 interface WebGLContextEvent extends Event {
17451 readonly statusMessage: string;
17454 declare var WebGLContextEvent: {
17455 prototype: WebGLContextEvent;
17456 new(type: string, eventInit?: WebGLContextEventInit): WebGLContextEvent;
17459 /** Part of the WebGL API and represents a collection of buffers that serve as a rendering destination. */
17460 interface WebGLFramebuffer extends WebGLObject {
17463 declare var WebGLFramebuffer: {
17464 prototype: WebGLFramebuffer;
17465 new(): WebGLFramebuffer;
17468 interface WebGLObject {
17471 declare var WebGLObject: {
17472 prototype: WebGLObject;
17473 new(): WebGLObject;
17476 /** The WebGLProgram is part of the WebGL API and is a combination of two compiled WebGLShaders consisting of a vertex shader and a fragment shader (both written in GLSL). */
17477 interface WebGLProgram extends WebGLObject {
17480 declare var WebGLProgram: {
17481 prototype: WebGLProgram;
17482 new(): WebGLProgram;
17485 interface WebGLQuery extends WebGLObject {
17488 declare var WebGLQuery: {
17489 prototype: WebGLQuery;
17493 /** Part of the WebGL API and represents a buffer that can contain an image, or can be source or target of an rendering operation. */
17494 interface WebGLRenderbuffer extends WebGLObject {
17497 declare var WebGLRenderbuffer: {
17498 prototype: WebGLRenderbuffer;
17499 new(): WebGLRenderbuffer;
17502 /** Provides an interface to the OpenGL ES 2.0 graphics rendering context for the drawing surface of an HTML <canvas> element. */
17503 interface WebGLRenderingContext extends WebGLRenderingContextBase, WebGLRenderingContextOverloads {
17506 declare var WebGLRenderingContext: {
17507 prototype: WebGLRenderingContext;
17508 new(): WebGLRenderingContext;
17509 readonly ACTIVE_ATTRIBUTES: GLenum;
17510 readonly ACTIVE_TEXTURE: GLenum;
17511 readonly ACTIVE_UNIFORMS: GLenum;
17512 readonly ALIASED_LINE_WIDTH_RANGE: GLenum;
17513 readonly ALIASED_POINT_SIZE_RANGE: GLenum;
17514 readonly ALPHA: GLenum;
17515 readonly ALPHA_BITS: GLenum;
17516 readonly ALWAYS: GLenum;
17517 readonly ARRAY_BUFFER: GLenum;
17518 readonly ARRAY_BUFFER_BINDING: GLenum;
17519 readonly ATTACHED_SHADERS: GLenum;
17520 readonly BACK: GLenum;
17521 readonly BLEND: GLenum;
17522 readonly BLEND_COLOR: GLenum;
17523 readonly BLEND_DST_ALPHA: GLenum;
17524 readonly BLEND_DST_RGB: GLenum;
17525 readonly BLEND_EQUATION: GLenum;
17526 readonly BLEND_EQUATION_ALPHA: GLenum;
17527 readonly BLEND_EQUATION_RGB: GLenum;
17528 readonly BLEND_SRC_ALPHA: GLenum;
17529 readonly BLEND_SRC_RGB: GLenum;
17530 readonly BLUE_BITS: GLenum;
17531 readonly BOOL: GLenum;
17532 readonly BOOL_VEC2: GLenum;
17533 readonly BOOL_VEC3: GLenum;
17534 readonly BOOL_VEC4: GLenum;
17535 readonly BROWSER_DEFAULT_WEBGL: GLenum;
17536 readonly BUFFER_SIZE: GLenum;
17537 readonly BUFFER_USAGE: GLenum;
17538 readonly BYTE: GLenum;
17539 readonly CCW: GLenum;
17540 readonly CLAMP_TO_EDGE: GLenum;
17541 readonly COLOR_ATTACHMENT0: GLenum;
17542 readonly COLOR_BUFFER_BIT: GLenum;
17543 readonly COLOR_CLEAR_VALUE: GLenum;
17544 readonly COLOR_WRITEMASK: GLenum;
17545 readonly COMPILE_STATUS: GLenum;
17546 readonly COMPRESSED_TEXTURE_FORMATS: GLenum;
17547 readonly CONSTANT_ALPHA: GLenum;
17548 readonly CONSTANT_COLOR: GLenum;
17549 readonly CONTEXT_LOST_WEBGL: GLenum;
17550 readonly CULL_FACE: GLenum;
17551 readonly CULL_FACE_MODE: GLenum;
17552 readonly CURRENT_PROGRAM: GLenum;
17553 readonly CURRENT_VERTEX_ATTRIB: GLenum;
17554 readonly CW: GLenum;
17555 readonly DECR: GLenum;
17556 readonly DECR_WRAP: GLenum;
17557 readonly DELETE_STATUS: GLenum;
17558 readonly DEPTH_ATTACHMENT: GLenum;
17559 readonly DEPTH_BITS: GLenum;
17560 readonly DEPTH_BUFFER_BIT: GLenum;
17561 readonly DEPTH_CLEAR_VALUE: GLenum;
17562 readonly DEPTH_COMPONENT: GLenum;
17563 readonly DEPTH_COMPONENT16: GLenum;
17564 readonly DEPTH_FUNC: GLenum;
17565 readonly DEPTH_RANGE: GLenum;
17566 readonly DEPTH_STENCIL: GLenum;
17567 readonly DEPTH_STENCIL_ATTACHMENT: GLenum;
17568 readonly DEPTH_TEST: GLenum;
17569 readonly DEPTH_WRITEMASK: GLenum;
17570 readonly DITHER: GLenum;
17571 readonly DONT_CARE: GLenum;
17572 readonly DST_ALPHA: GLenum;
17573 readonly DST_COLOR: GLenum;
17574 readonly DYNAMIC_DRAW: GLenum;
17575 readonly ELEMENT_ARRAY_BUFFER: GLenum;
17576 readonly ELEMENT_ARRAY_BUFFER_BINDING: GLenum;
17577 readonly EQUAL: GLenum;
17578 readonly FASTEST: GLenum;
17579 readonly FLOAT: GLenum;
17580 readonly FLOAT_MAT2: GLenum;
17581 readonly FLOAT_MAT3: GLenum;
17582 readonly FLOAT_MAT4: GLenum;
17583 readonly FLOAT_VEC2: GLenum;
17584 readonly FLOAT_VEC3: GLenum;
17585 readonly FLOAT_VEC4: GLenum;
17586 readonly FRAGMENT_SHADER: GLenum;
17587 readonly FRAMEBUFFER: GLenum;
17588 readonly FRAMEBUFFER_ATTACHMENT_OBJECT_NAME: GLenum;
17589 readonly FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE: GLenum;
17590 readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE: GLenum;
17591 readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL: GLenum;
17592 readonly FRAMEBUFFER_BINDING: GLenum;
17593 readonly FRAMEBUFFER_COMPLETE: GLenum;
17594 readonly FRAMEBUFFER_INCOMPLETE_ATTACHMENT: GLenum;
17595 readonly FRAMEBUFFER_INCOMPLETE_DIMENSIONS: GLenum;
17596 readonly FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: GLenum;
17597 readonly FRAMEBUFFER_UNSUPPORTED: GLenum;
17598 readonly FRONT: GLenum;
17599 readonly FRONT_AND_BACK: GLenum;
17600 readonly FRONT_FACE: GLenum;
17601 readonly FUNC_ADD: GLenum;
17602 readonly FUNC_REVERSE_SUBTRACT: GLenum;
17603 readonly FUNC_SUBTRACT: GLenum;
17604 readonly GENERATE_MIPMAP_HINT: GLenum;
17605 readonly GEQUAL: GLenum;
17606 readonly GREATER: GLenum;
17607 readonly GREEN_BITS: GLenum;
17608 readonly HIGH_FLOAT: GLenum;
17609 readonly HIGH_INT: GLenum;
17610 readonly IMPLEMENTATION_COLOR_READ_FORMAT: GLenum;
17611 readonly IMPLEMENTATION_COLOR_READ_TYPE: GLenum;
17612 readonly INCR: GLenum;
17613 readonly INCR_WRAP: GLenum;
17614 readonly INT: GLenum;
17615 readonly INT_VEC2: GLenum;
17616 readonly INT_VEC3: GLenum;
17617 readonly INT_VEC4: GLenum;
17618 readonly INVALID_ENUM: GLenum;
17619 readonly INVALID_FRAMEBUFFER_OPERATION: GLenum;
17620 readonly INVALID_OPERATION: GLenum;
17621 readonly INVALID_VALUE: GLenum;
17622 readonly INVERT: GLenum;
17623 readonly KEEP: GLenum;
17624 readonly LEQUAL: GLenum;
17625 readonly LESS: GLenum;
17626 readonly LINEAR: GLenum;
17627 readonly LINEAR_MIPMAP_LINEAR: GLenum;
17628 readonly LINEAR_MIPMAP_NEAREST: GLenum;
17629 readonly LINES: GLenum;
17630 readonly LINE_LOOP: GLenum;
17631 readonly LINE_STRIP: GLenum;
17632 readonly LINE_WIDTH: GLenum;
17633 readonly LINK_STATUS: GLenum;
17634 readonly LOW_FLOAT: GLenum;
17635 readonly LOW_INT: GLenum;
17636 readonly LUMINANCE: GLenum;
17637 readonly LUMINANCE_ALPHA: GLenum;
17638 readonly MAX_COMBINED_TEXTURE_IMAGE_UNITS: GLenum;
17639 readonly MAX_CUBE_MAP_TEXTURE_SIZE: GLenum;
17640 readonly MAX_FRAGMENT_UNIFORM_VECTORS: GLenum;
17641 readonly MAX_RENDERBUFFER_SIZE: GLenum;
17642 readonly MAX_TEXTURE_IMAGE_UNITS: GLenum;
17643 readonly MAX_TEXTURE_SIZE: GLenum;
17644 readonly MAX_VARYING_VECTORS: GLenum;
17645 readonly MAX_VERTEX_ATTRIBS: GLenum;
17646 readonly MAX_VERTEX_TEXTURE_IMAGE_UNITS: GLenum;
17647 readonly MAX_VERTEX_UNIFORM_VECTORS: GLenum;
17648 readonly MAX_VIEWPORT_DIMS: GLenum;
17649 readonly MEDIUM_FLOAT: GLenum;
17650 readonly MEDIUM_INT: GLenum;
17651 readonly MIRRORED_REPEAT: GLenum;
17652 readonly NEAREST: GLenum;
17653 readonly NEAREST_MIPMAP_LINEAR: GLenum;
17654 readonly NEAREST_MIPMAP_NEAREST: GLenum;
17655 readonly NEVER: GLenum;
17656 readonly NICEST: GLenum;
17657 readonly NONE: GLenum;
17658 readonly NOTEQUAL: GLenum;
17659 readonly NO_ERROR: GLenum;
17660 readonly ONE: GLenum;
17661 readonly ONE_MINUS_CONSTANT_ALPHA: GLenum;
17662 readonly ONE_MINUS_CONSTANT_COLOR: GLenum;
17663 readonly ONE_MINUS_DST_ALPHA: GLenum;
17664 readonly ONE_MINUS_DST_COLOR: GLenum;
17665 readonly ONE_MINUS_SRC_ALPHA: GLenum;
17666 readonly ONE_MINUS_SRC_COLOR: GLenum;
17667 readonly OUT_OF_MEMORY: GLenum;
17668 readonly PACK_ALIGNMENT: GLenum;
17669 readonly POINTS: GLenum;
17670 readonly POLYGON_OFFSET_FACTOR: GLenum;
17671 readonly POLYGON_OFFSET_FILL: GLenum;
17672 readonly POLYGON_OFFSET_UNITS: GLenum;
17673 readonly RED_BITS: GLenum;
17674 readonly RENDERBUFFER: GLenum;
17675 readonly RENDERBUFFER_ALPHA_SIZE: GLenum;
17676 readonly RENDERBUFFER_BINDING: GLenum;
17677 readonly RENDERBUFFER_BLUE_SIZE: GLenum;
17678 readonly RENDERBUFFER_DEPTH_SIZE: GLenum;
17679 readonly RENDERBUFFER_GREEN_SIZE: GLenum;
17680 readonly RENDERBUFFER_HEIGHT: GLenum;
17681 readonly RENDERBUFFER_INTERNAL_FORMAT: GLenum;
17682 readonly RENDERBUFFER_RED_SIZE: GLenum;
17683 readonly RENDERBUFFER_STENCIL_SIZE: GLenum;
17684 readonly RENDERBUFFER_WIDTH: GLenum;
17685 readonly RENDERER: GLenum;
17686 readonly REPEAT: GLenum;
17687 readonly REPLACE: GLenum;
17688 readonly RGB: GLenum;
17689 readonly RGB565: GLenum;
17690 readonly RGB5_A1: GLenum;
17691 readonly RGBA: GLenum;
17692 readonly RGBA4: GLenum;
17693 readonly SAMPLER_2D: GLenum;
17694 readonly SAMPLER_CUBE: GLenum;
17695 readonly SAMPLES: GLenum;
17696 readonly SAMPLE_ALPHA_TO_COVERAGE: GLenum;
17697 readonly SAMPLE_BUFFERS: GLenum;
17698 readonly SAMPLE_COVERAGE: GLenum;
17699 readonly SAMPLE_COVERAGE_INVERT: GLenum;
17700 readonly SAMPLE_COVERAGE_VALUE: GLenum;
17701 readonly SCISSOR_BOX: GLenum;
17702 readonly SCISSOR_TEST: GLenum;
17703 readonly SHADER_TYPE: GLenum;
17704 readonly SHADING_LANGUAGE_VERSION: GLenum;
17705 readonly SHORT: GLenum;
17706 readonly SRC_ALPHA: GLenum;
17707 readonly SRC_ALPHA_SATURATE: GLenum;
17708 readonly SRC_COLOR: GLenum;
17709 readonly STATIC_DRAW: GLenum;
17710 readonly STENCIL_ATTACHMENT: GLenum;
17711 readonly STENCIL_BACK_FAIL: GLenum;
17712 readonly STENCIL_BACK_FUNC: GLenum;
17713 readonly STENCIL_BACK_PASS_DEPTH_FAIL: GLenum;
17714 readonly STENCIL_BACK_PASS_DEPTH_PASS: GLenum;
17715 readonly STENCIL_BACK_REF: GLenum;
17716 readonly STENCIL_BACK_VALUE_MASK: GLenum;
17717 readonly STENCIL_BACK_WRITEMASK: GLenum;
17718 readonly STENCIL_BITS: GLenum;
17719 readonly STENCIL_BUFFER_BIT: GLenum;
17720 readonly STENCIL_CLEAR_VALUE: GLenum;
17721 readonly STENCIL_FAIL: GLenum;
17722 readonly STENCIL_FUNC: GLenum;
17723 readonly STENCIL_INDEX8: GLenum;
17724 readonly STENCIL_PASS_DEPTH_FAIL: GLenum;
17725 readonly STENCIL_PASS_DEPTH_PASS: GLenum;
17726 readonly STENCIL_REF: GLenum;
17727 readonly STENCIL_TEST: GLenum;
17728 readonly STENCIL_VALUE_MASK: GLenum;
17729 readonly STENCIL_WRITEMASK: GLenum;
17730 readonly STREAM_DRAW: GLenum;
17731 readonly SUBPIXEL_BITS: GLenum;
17732 readonly TEXTURE: GLenum;
17733 readonly TEXTURE0: GLenum;
17734 readonly TEXTURE1: GLenum;
17735 readonly TEXTURE10: GLenum;
17736 readonly TEXTURE11: GLenum;
17737 readonly TEXTURE12: GLenum;
17738 readonly TEXTURE13: GLenum;
17739 readonly TEXTURE14: GLenum;
17740 readonly TEXTURE15: GLenum;
17741 readonly TEXTURE16: GLenum;
17742 readonly TEXTURE17: GLenum;
17743 readonly TEXTURE18: GLenum;
17744 readonly TEXTURE19: GLenum;
17745 readonly TEXTURE2: GLenum;
17746 readonly TEXTURE20: GLenum;
17747 readonly TEXTURE21: GLenum;
17748 readonly TEXTURE22: GLenum;
17749 readonly TEXTURE23: GLenum;
17750 readonly TEXTURE24: GLenum;
17751 readonly TEXTURE25: GLenum;
17752 readonly TEXTURE26: GLenum;
17753 readonly TEXTURE27: GLenum;
17754 readonly TEXTURE28: GLenum;
17755 readonly TEXTURE29: GLenum;
17756 readonly TEXTURE3: GLenum;
17757 readonly TEXTURE30: GLenum;
17758 readonly TEXTURE31: GLenum;
17759 readonly TEXTURE4: GLenum;
17760 readonly TEXTURE5: GLenum;
17761 readonly TEXTURE6: GLenum;
17762 readonly TEXTURE7: GLenum;
17763 readonly TEXTURE8: GLenum;
17764 readonly TEXTURE9: GLenum;
17765 readonly TEXTURE_2D: GLenum;
17766 readonly TEXTURE_BINDING_2D: GLenum;
17767 readonly TEXTURE_BINDING_CUBE_MAP: GLenum;
17768 readonly TEXTURE_CUBE_MAP: GLenum;
17769 readonly TEXTURE_CUBE_MAP_NEGATIVE_X: GLenum;
17770 readonly TEXTURE_CUBE_MAP_NEGATIVE_Y: GLenum;
17771 readonly TEXTURE_CUBE_MAP_NEGATIVE_Z: GLenum;
17772 readonly TEXTURE_CUBE_MAP_POSITIVE_X: GLenum;
17773 readonly TEXTURE_CUBE_MAP_POSITIVE_Y: GLenum;
17774 readonly TEXTURE_CUBE_MAP_POSITIVE_Z: GLenum;
17775 readonly TEXTURE_MAG_FILTER: GLenum;
17776 readonly TEXTURE_MIN_FILTER: GLenum;
17777 readonly TEXTURE_WRAP_S: GLenum;
17778 readonly TEXTURE_WRAP_T: GLenum;
17779 readonly TRIANGLES: GLenum;
17780 readonly TRIANGLE_FAN: GLenum;
17781 readonly TRIANGLE_STRIP: GLenum;
17782 readonly UNPACK_ALIGNMENT: GLenum;
17783 readonly UNPACK_COLORSPACE_CONVERSION_WEBGL: GLenum;
17784 readonly UNPACK_FLIP_Y_WEBGL: GLenum;
17785 readonly UNPACK_PREMULTIPLY_ALPHA_WEBGL: GLenum;
17786 readonly UNSIGNED_BYTE: GLenum;
17787 readonly UNSIGNED_INT: GLenum;
17788 readonly UNSIGNED_SHORT: GLenum;
17789 readonly UNSIGNED_SHORT_4_4_4_4: GLenum;
17790 readonly UNSIGNED_SHORT_5_5_5_1: GLenum;
17791 readonly UNSIGNED_SHORT_5_6_5: GLenum;
17792 readonly VALIDATE_STATUS: GLenum;
17793 readonly VENDOR: GLenum;
17794 readonly VERSION: GLenum;
17795 readonly VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: GLenum;
17796 readonly VERTEX_ATTRIB_ARRAY_ENABLED: GLenum;
17797 readonly VERTEX_ATTRIB_ARRAY_NORMALIZED: GLenum;
17798 readonly VERTEX_ATTRIB_ARRAY_POINTER: GLenum;
17799 readonly VERTEX_ATTRIB_ARRAY_SIZE: GLenum;
17800 readonly VERTEX_ATTRIB_ARRAY_STRIDE: GLenum;
17801 readonly VERTEX_ATTRIB_ARRAY_TYPE: GLenum;
17802 readonly VERTEX_SHADER: GLenum;
17803 readonly VIEWPORT: GLenum;
17804 readonly ZERO: GLenum;
17807 interface WebGLRenderingContextBase {
17808 readonly canvas: HTMLCanvasElement | OffscreenCanvas;
17809 readonly drawingBufferHeight: GLsizei;
17810 readonly drawingBufferWidth: GLsizei;
17811 activeTexture(texture: GLenum): void;
17812 attachShader(program: WebGLProgram, shader: WebGLShader): void;
17813 bindAttribLocation(program: WebGLProgram, index: GLuint, name: string): void;
17814 bindBuffer(target: GLenum, buffer: WebGLBuffer | null): void;
17815 bindFramebuffer(target: GLenum, framebuffer: WebGLFramebuffer | null): void;
17816 bindRenderbuffer(target: GLenum, renderbuffer: WebGLRenderbuffer | null): void;
17817 bindTexture(target: GLenum, texture: WebGLTexture | null): void;
17818 blendColor(red: GLclampf, green: GLclampf, blue: GLclampf, alpha: GLclampf): void;
17819 blendEquation(mode: GLenum): void;
17820 blendEquationSeparate(modeRGB: GLenum, modeAlpha: GLenum): void;
17821 blendFunc(sfactor: GLenum, dfactor: GLenum): void;
17822 blendFuncSeparate(srcRGB: GLenum, dstRGB: GLenum, srcAlpha: GLenum, dstAlpha: GLenum): void;
17823 checkFramebufferStatus(target: GLenum): GLenum;
17824 clear(mask: GLbitfield): void;
17825 clearColor(red: GLclampf, green: GLclampf, blue: GLclampf, alpha: GLclampf): void;
17826 clearDepth(depth: GLclampf): void;
17827 clearStencil(s: GLint): void;
17828 colorMask(red: GLboolean, green: GLboolean, blue: GLboolean, alpha: GLboolean): void;
17829 compileShader(shader: WebGLShader): void;
17830 copyTexImage2D(target: GLenum, level: GLint, internalformat: GLenum, x: GLint, y: GLint, width: GLsizei, height: GLsizei, border: GLint): void;
17831 copyTexSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, x: GLint, y: GLint, width: GLsizei, height: GLsizei): void;
17832 createBuffer(): WebGLBuffer | null;
17833 createFramebuffer(): WebGLFramebuffer | null;
17834 createProgram(): WebGLProgram | null;
17835 createRenderbuffer(): WebGLRenderbuffer | null;
17836 createShader(type: GLenum): WebGLShader | null;
17837 createTexture(): WebGLTexture | null;
17838 cullFace(mode: GLenum): void;
17839 deleteBuffer(buffer: WebGLBuffer | null): void;
17840 deleteFramebuffer(framebuffer: WebGLFramebuffer | null): void;
17841 deleteProgram(program: WebGLProgram | null): void;
17842 deleteRenderbuffer(renderbuffer: WebGLRenderbuffer | null): void;
17843 deleteShader(shader: WebGLShader | null): void;
17844 deleteTexture(texture: WebGLTexture | null): void;
17845 depthFunc(func: GLenum): void;
17846 depthMask(flag: GLboolean): void;
17847 depthRange(zNear: GLclampf, zFar: GLclampf): void;
17848 detachShader(program: WebGLProgram, shader: WebGLShader): void;
17849 disable(cap: GLenum): void;
17850 disableVertexAttribArray(index: GLuint): void;
17851 drawArrays(mode: GLenum, first: GLint, count: GLsizei): void;
17852 drawElements(mode: GLenum, count: GLsizei, type: GLenum, offset: GLintptr): void;
17853 enable(cap: GLenum): void;
17854 enableVertexAttribArray(index: GLuint): void;
17857 framebufferRenderbuffer(target: GLenum, attachment: GLenum, renderbuffertarget: GLenum, renderbuffer: WebGLRenderbuffer | null): void;
17858 framebufferTexture2D(target: GLenum, attachment: GLenum, textarget: GLenum, texture: WebGLTexture | null, level: GLint): void;
17859 frontFace(mode: GLenum): void;
17860 generateMipmap(target: GLenum): void;
17861 getActiveAttrib(program: WebGLProgram, index: GLuint): WebGLActiveInfo | null;
17862 getActiveUniform(program: WebGLProgram, index: GLuint): WebGLActiveInfo | null;
17863 getAttachedShaders(program: WebGLProgram): WebGLShader[] | null;
17864 getAttribLocation(program: WebGLProgram, name: string): GLint;
17865 getBufferParameter(target: GLenum, pname: GLenum): any;
17866 getContextAttributes(): WebGLContextAttributes | null;
17867 getError(): GLenum;
17868 getExtension(extensionName: "EXT_blend_minmax"): EXT_blend_minmax | null;
17869 getExtension(extensionName: "EXT_texture_filter_anisotropic"): EXT_texture_filter_anisotropic | null;
17870 getExtension(extensionName: "EXT_frag_depth"): EXT_frag_depth | null;
17871 getExtension(extensionName: "EXT_shader_texture_lod"): EXT_shader_texture_lod | null;
17872 getExtension(extensionName: "EXT_sRGB"): EXT_sRGB | null;
17873 getExtension(extensionName: "OES_vertex_array_object"): OES_vertex_array_object | null;
17874 getExtension(extensionName: "WEBGL_color_buffer_float"): WEBGL_color_buffer_float | null;
17875 getExtension(extensionName: "WEBGL_compressed_texture_astc"): WEBGL_compressed_texture_astc | null;
17876 getExtension(extensionName: "WEBGL_compressed_texture_s3tc_srgb"): WEBGL_compressed_texture_s3tc_srgb | null;
17877 getExtension(extensionName: "WEBGL_debug_shaders"): WEBGL_debug_shaders | null;
17878 getExtension(extensionName: "WEBGL_draw_buffers"): WEBGL_draw_buffers | null;
17879 getExtension(extensionName: "WEBGL_lose_context"): WEBGL_lose_context | null;
17880 getExtension(extensionName: "WEBGL_depth_texture"): WEBGL_depth_texture | null;
17881 getExtension(extensionName: "WEBGL_debug_renderer_info"): WEBGL_debug_renderer_info | null;
17882 getExtension(extensionName: "WEBGL_compressed_texture_s3tc"): WEBGL_compressed_texture_s3tc | null;
17883 getExtension(extensionName: "OES_texture_half_float_linear"): OES_texture_half_float_linear | null;
17884 getExtension(extensionName: "OES_texture_half_float"): OES_texture_half_float | null;
17885 getExtension(extensionName: "OES_texture_float_linear"): OES_texture_float_linear | null;
17886 getExtension(extensionName: "OES_texture_float"): OES_texture_float | null;
17887 getExtension(extensionName: "OES_standard_derivatives"): OES_standard_derivatives | null;
17888 getExtension(extensionName: "OES_element_index_uint"): OES_element_index_uint | null;
17889 getExtension(extensionName: "ANGLE_instanced_arrays"): ANGLE_instanced_arrays | null;
17890 getExtension(extensionName: string): any;
17891 getFramebufferAttachmentParameter(target: GLenum, attachment: GLenum, pname: GLenum): any;
17892 getParameter(pname: GLenum): any;
17893 getProgramInfoLog(program: WebGLProgram): string | null;
17894 getProgramParameter(program: WebGLProgram, pname: GLenum): any;
17895 getRenderbufferParameter(target: GLenum, pname: GLenum): any;
17896 getShaderInfoLog(shader: WebGLShader): string | null;
17897 getShaderParameter(shader: WebGLShader, pname: GLenum): any;
17898 getShaderPrecisionFormat(shadertype: GLenum, precisiontype: GLenum): WebGLShaderPrecisionFormat | null;
17899 getShaderSource(shader: WebGLShader): string | null;
17900 getSupportedExtensions(): string[] | null;
17901 getTexParameter(target: GLenum, pname: GLenum): any;
17902 getUniform(program: WebGLProgram, location: WebGLUniformLocation): any;
17903 getUniformLocation(program: WebGLProgram, name: string): WebGLUniformLocation | null;
17904 getVertexAttrib(index: GLuint, pname: GLenum): any;
17905 getVertexAttribOffset(index: GLuint, pname: GLenum): GLintptr;
17906 hint(target: GLenum, mode: GLenum): void;
17907 isBuffer(buffer: WebGLBuffer | null): GLboolean;
17908 isContextLost(): boolean;
17909 isEnabled(cap: GLenum): GLboolean;
17910 isFramebuffer(framebuffer: WebGLFramebuffer | null): GLboolean;
17911 isProgram(program: WebGLProgram | null): GLboolean;
17912 isRenderbuffer(renderbuffer: WebGLRenderbuffer | null): GLboolean;
17913 isShader(shader: WebGLShader | null): GLboolean;
17914 isTexture(texture: WebGLTexture | null): GLboolean;
17915 lineWidth(width: GLfloat): void;
17916 linkProgram(program: WebGLProgram): void;
17917 pixelStorei(pname: GLenum, param: GLint | GLboolean): void;
17918 polygonOffset(factor: GLfloat, units: GLfloat): void;
17919 renderbufferStorage(target: GLenum, internalformat: GLenum, width: GLsizei, height: GLsizei): void;
17920 sampleCoverage(value: GLclampf, invert: GLboolean): void;
17921 scissor(x: GLint, y: GLint, width: GLsizei, height: GLsizei): void;
17922 shaderSource(shader: WebGLShader, source: string): void;
17923 stencilFunc(func: GLenum, ref: GLint, mask: GLuint): void;
17924 stencilFuncSeparate(face: GLenum, func: GLenum, ref: GLint, mask: GLuint): void;
17925 stencilMask(mask: GLuint): void;
17926 stencilMaskSeparate(face: GLenum, mask: GLuint): void;
17927 stencilOp(fail: GLenum, zfail: GLenum, zpass: GLenum): void;
17928 stencilOpSeparate(face: GLenum, fail: GLenum, zfail: GLenum, zpass: GLenum): void;
17929 texParameterf(target: GLenum, pname: GLenum, param: GLfloat): void;
17930 texParameteri(target: GLenum, pname: GLenum, param: GLint): void;
17931 uniform1f(location: WebGLUniformLocation | null, x: GLfloat): void;
17932 uniform1i(location: WebGLUniformLocation | null, x: GLint): void;
17933 uniform2f(location: WebGLUniformLocation | null, x: GLfloat, y: GLfloat): void;
17934 uniform2i(location: WebGLUniformLocation | null, x: GLint, y: GLint): void;
17935 uniform3f(location: WebGLUniformLocation | null, x: GLfloat, y: GLfloat, z: GLfloat): void;
17936 uniform3i(location: WebGLUniformLocation | null, x: GLint, y: GLint, z: GLint): void;
17937 uniform4f(location: WebGLUniformLocation | null, x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat): void;
17938 uniform4i(location: WebGLUniformLocation | null, x: GLint, y: GLint, z: GLint, w: GLint): void;
17939 useProgram(program: WebGLProgram | null): void;
17940 validateProgram(program: WebGLProgram): void;
17941 vertexAttrib1f(index: GLuint, x: GLfloat): void;
17942 vertexAttrib1fv(index: GLuint, values: Float32List): void;
17943 vertexAttrib2f(index: GLuint, x: GLfloat, y: GLfloat): void;
17944 vertexAttrib2fv(index: GLuint, values: Float32List): void;
17945 vertexAttrib3f(index: GLuint, x: GLfloat, y: GLfloat, z: GLfloat): void;
17946 vertexAttrib3fv(index: GLuint, values: Float32List): void;
17947 vertexAttrib4f(index: GLuint, x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat): void;
17948 vertexAttrib4fv(index: GLuint, values: Float32List): void;
17949 vertexAttribPointer(index: GLuint, size: GLint, type: GLenum, normalized: GLboolean, stride: GLsizei, offset: GLintptr): void;
17950 viewport(x: GLint, y: GLint, width: GLsizei, height: GLsizei): void;
17951 readonly ACTIVE_ATTRIBUTES: GLenum;
17952 readonly ACTIVE_TEXTURE: GLenum;
17953 readonly ACTIVE_UNIFORMS: GLenum;
17954 readonly ALIASED_LINE_WIDTH_RANGE: GLenum;
17955 readonly ALIASED_POINT_SIZE_RANGE: GLenum;
17956 readonly ALPHA: GLenum;
17957 readonly ALPHA_BITS: GLenum;
17958 readonly ALWAYS: GLenum;
17959 readonly ARRAY_BUFFER: GLenum;
17960 readonly ARRAY_BUFFER_BINDING: GLenum;
17961 readonly ATTACHED_SHADERS: GLenum;
17962 readonly BACK: GLenum;
17963 readonly BLEND: GLenum;
17964 readonly BLEND_COLOR: GLenum;
17965 readonly BLEND_DST_ALPHA: GLenum;
17966 readonly BLEND_DST_RGB: GLenum;
17967 readonly BLEND_EQUATION: GLenum;
17968 readonly BLEND_EQUATION_ALPHA: GLenum;
17969 readonly BLEND_EQUATION_RGB: GLenum;
17970 readonly BLEND_SRC_ALPHA: GLenum;
17971 readonly BLEND_SRC_RGB: GLenum;
17972 readonly BLUE_BITS: GLenum;
17973 readonly BOOL: GLenum;
17974 readonly BOOL_VEC2: GLenum;
17975 readonly BOOL_VEC3: GLenum;
17976 readonly BOOL_VEC4: GLenum;
17977 readonly BROWSER_DEFAULT_WEBGL: GLenum;
17978 readonly BUFFER_SIZE: GLenum;
17979 readonly BUFFER_USAGE: GLenum;
17980 readonly BYTE: GLenum;
17981 readonly CCW: GLenum;
17982 readonly CLAMP_TO_EDGE: GLenum;
17983 readonly COLOR_ATTACHMENT0: GLenum;
17984 readonly COLOR_BUFFER_BIT: GLenum;
17985 readonly COLOR_CLEAR_VALUE: GLenum;
17986 readonly COLOR_WRITEMASK: GLenum;
17987 readonly COMPILE_STATUS: GLenum;
17988 readonly COMPRESSED_TEXTURE_FORMATS: GLenum;
17989 readonly CONSTANT_ALPHA: GLenum;
17990 readonly CONSTANT_COLOR: GLenum;
17991 readonly CONTEXT_LOST_WEBGL: GLenum;
17992 readonly CULL_FACE: GLenum;
17993 readonly CULL_FACE_MODE: GLenum;
17994 readonly CURRENT_PROGRAM: GLenum;
17995 readonly CURRENT_VERTEX_ATTRIB: GLenum;
17996 readonly CW: GLenum;
17997 readonly DECR: GLenum;
17998 readonly DECR_WRAP: GLenum;
17999 readonly DELETE_STATUS: GLenum;
18000 readonly DEPTH_ATTACHMENT: GLenum;
18001 readonly DEPTH_BITS: GLenum;
18002 readonly DEPTH_BUFFER_BIT: GLenum;
18003 readonly DEPTH_CLEAR_VALUE: GLenum;
18004 readonly DEPTH_COMPONENT: GLenum;
18005 readonly DEPTH_COMPONENT16: GLenum;
18006 readonly DEPTH_FUNC: GLenum;
18007 readonly DEPTH_RANGE: GLenum;
18008 readonly DEPTH_STENCIL: GLenum;
18009 readonly DEPTH_STENCIL_ATTACHMENT: GLenum;
18010 readonly DEPTH_TEST: GLenum;
18011 readonly DEPTH_WRITEMASK: GLenum;
18012 readonly DITHER: GLenum;
18013 readonly DONT_CARE: GLenum;
18014 readonly DST_ALPHA: GLenum;
18015 readonly DST_COLOR: GLenum;
18016 readonly DYNAMIC_DRAW: GLenum;
18017 readonly ELEMENT_ARRAY_BUFFER: GLenum;
18018 readonly ELEMENT_ARRAY_BUFFER_BINDING: GLenum;
18019 readonly EQUAL: GLenum;
18020 readonly FASTEST: GLenum;
18021 readonly FLOAT: GLenum;
18022 readonly FLOAT_MAT2: GLenum;
18023 readonly FLOAT_MAT3: GLenum;
18024 readonly FLOAT_MAT4: GLenum;
18025 readonly FLOAT_VEC2: GLenum;
18026 readonly FLOAT_VEC3: GLenum;
18027 readonly FLOAT_VEC4: GLenum;
18028 readonly FRAGMENT_SHADER: GLenum;
18029 readonly FRAMEBUFFER: GLenum;
18030 readonly FRAMEBUFFER_ATTACHMENT_OBJECT_NAME: GLenum;
18031 readonly FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE: GLenum;
18032 readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE: GLenum;
18033 readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL: GLenum;
18034 readonly FRAMEBUFFER_BINDING: GLenum;
18035 readonly FRAMEBUFFER_COMPLETE: GLenum;
18036 readonly FRAMEBUFFER_INCOMPLETE_ATTACHMENT: GLenum;
18037 readonly FRAMEBUFFER_INCOMPLETE_DIMENSIONS: GLenum;
18038 readonly FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: GLenum;
18039 readonly FRAMEBUFFER_UNSUPPORTED: GLenum;
18040 readonly FRONT: GLenum;
18041 readonly FRONT_AND_BACK: GLenum;
18042 readonly FRONT_FACE: GLenum;
18043 readonly FUNC_ADD: GLenum;
18044 readonly FUNC_REVERSE_SUBTRACT: GLenum;
18045 readonly FUNC_SUBTRACT: GLenum;
18046 readonly GENERATE_MIPMAP_HINT: GLenum;
18047 readonly GEQUAL: GLenum;
18048 readonly GREATER: GLenum;
18049 readonly GREEN_BITS: GLenum;
18050 readonly HIGH_FLOAT: GLenum;
18051 readonly HIGH_INT: GLenum;
18052 readonly IMPLEMENTATION_COLOR_READ_FORMAT: GLenum;
18053 readonly IMPLEMENTATION_COLOR_READ_TYPE: GLenum;
18054 readonly INCR: GLenum;
18055 readonly INCR_WRAP: GLenum;
18056 readonly INT: GLenum;
18057 readonly INT_VEC2: GLenum;
18058 readonly INT_VEC3: GLenum;
18059 readonly INT_VEC4: GLenum;
18060 readonly INVALID_ENUM: GLenum;
18061 readonly INVALID_FRAMEBUFFER_OPERATION: GLenum;
18062 readonly INVALID_OPERATION: GLenum;
18063 readonly INVALID_VALUE: GLenum;
18064 readonly INVERT: GLenum;
18065 readonly KEEP: GLenum;
18066 readonly LEQUAL: GLenum;
18067 readonly LESS: GLenum;
18068 readonly LINEAR: GLenum;
18069 readonly LINEAR_MIPMAP_LINEAR: GLenum;
18070 readonly LINEAR_MIPMAP_NEAREST: GLenum;
18071 readonly LINES: GLenum;
18072 readonly LINE_LOOP: GLenum;
18073 readonly LINE_STRIP: GLenum;
18074 readonly LINE_WIDTH: GLenum;
18075 readonly LINK_STATUS: GLenum;
18076 readonly LOW_FLOAT: GLenum;
18077 readonly LOW_INT: GLenum;
18078 readonly LUMINANCE: GLenum;
18079 readonly LUMINANCE_ALPHA: GLenum;
18080 readonly MAX_COMBINED_TEXTURE_IMAGE_UNITS: GLenum;
18081 readonly MAX_CUBE_MAP_TEXTURE_SIZE: GLenum;
18082 readonly MAX_FRAGMENT_UNIFORM_VECTORS: GLenum;
18083 readonly MAX_RENDERBUFFER_SIZE: GLenum;
18084 readonly MAX_TEXTURE_IMAGE_UNITS: GLenum;
18085 readonly MAX_TEXTURE_SIZE: GLenum;
18086 readonly MAX_VARYING_VECTORS: GLenum;
18087 readonly MAX_VERTEX_ATTRIBS: GLenum;
18088 readonly MAX_VERTEX_TEXTURE_IMAGE_UNITS: GLenum;
18089 readonly MAX_VERTEX_UNIFORM_VECTORS: GLenum;
18090 readonly MAX_VIEWPORT_DIMS: GLenum;
18091 readonly MEDIUM_FLOAT: GLenum;
18092 readonly MEDIUM_INT: GLenum;
18093 readonly MIRRORED_REPEAT: GLenum;
18094 readonly NEAREST: GLenum;
18095 readonly NEAREST_MIPMAP_LINEAR: GLenum;
18096 readonly NEAREST_MIPMAP_NEAREST: GLenum;
18097 readonly NEVER: GLenum;
18098 readonly NICEST: GLenum;
18099 readonly NONE: GLenum;
18100 readonly NOTEQUAL: GLenum;
18101 readonly NO_ERROR: GLenum;
18102 readonly ONE: GLenum;
18103 readonly ONE_MINUS_CONSTANT_ALPHA: GLenum;
18104 readonly ONE_MINUS_CONSTANT_COLOR: GLenum;
18105 readonly ONE_MINUS_DST_ALPHA: GLenum;
18106 readonly ONE_MINUS_DST_COLOR: GLenum;
18107 readonly ONE_MINUS_SRC_ALPHA: GLenum;
18108 readonly ONE_MINUS_SRC_COLOR: GLenum;
18109 readonly OUT_OF_MEMORY: GLenum;
18110 readonly PACK_ALIGNMENT: GLenum;
18111 readonly POINTS: GLenum;
18112 readonly POLYGON_OFFSET_FACTOR: GLenum;
18113 readonly POLYGON_OFFSET_FILL: GLenum;
18114 readonly POLYGON_OFFSET_UNITS: GLenum;
18115 readonly RED_BITS: GLenum;
18116 readonly RENDERBUFFER: GLenum;
18117 readonly RENDERBUFFER_ALPHA_SIZE: GLenum;
18118 readonly RENDERBUFFER_BINDING: GLenum;
18119 readonly RENDERBUFFER_BLUE_SIZE: GLenum;
18120 readonly RENDERBUFFER_DEPTH_SIZE: GLenum;
18121 readonly RENDERBUFFER_GREEN_SIZE: GLenum;
18122 readonly RENDERBUFFER_HEIGHT: GLenum;
18123 readonly RENDERBUFFER_INTERNAL_FORMAT: GLenum;
18124 readonly RENDERBUFFER_RED_SIZE: GLenum;
18125 readonly RENDERBUFFER_STENCIL_SIZE: GLenum;
18126 readonly RENDERBUFFER_WIDTH: GLenum;
18127 readonly RENDERER: GLenum;
18128 readonly REPEAT: GLenum;
18129 readonly REPLACE: GLenum;
18130 readonly RGB: GLenum;
18131 readonly RGB565: GLenum;
18132 readonly RGB5_A1: GLenum;
18133 readonly RGBA: GLenum;
18134 readonly RGBA4: GLenum;
18135 readonly SAMPLER_2D: GLenum;
18136 readonly SAMPLER_CUBE: GLenum;
18137 readonly SAMPLES: GLenum;
18138 readonly SAMPLE_ALPHA_TO_COVERAGE: GLenum;
18139 readonly SAMPLE_BUFFERS: GLenum;
18140 readonly SAMPLE_COVERAGE: GLenum;
18141 readonly SAMPLE_COVERAGE_INVERT: GLenum;
18142 readonly SAMPLE_COVERAGE_VALUE: GLenum;
18143 readonly SCISSOR_BOX: GLenum;
18144 readonly SCISSOR_TEST: GLenum;
18145 readonly SHADER_TYPE: GLenum;
18146 readonly SHADING_LANGUAGE_VERSION: GLenum;
18147 readonly SHORT: GLenum;
18148 readonly SRC_ALPHA: GLenum;
18149 readonly SRC_ALPHA_SATURATE: GLenum;
18150 readonly SRC_COLOR: GLenum;
18151 readonly STATIC_DRAW: GLenum;
18152 readonly STENCIL_ATTACHMENT: GLenum;
18153 readonly STENCIL_BACK_FAIL: GLenum;
18154 readonly STENCIL_BACK_FUNC: GLenum;
18155 readonly STENCIL_BACK_PASS_DEPTH_FAIL: GLenum;
18156 readonly STENCIL_BACK_PASS_DEPTH_PASS: GLenum;
18157 readonly STENCIL_BACK_REF: GLenum;
18158 readonly STENCIL_BACK_VALUE_MASK: GLenum;
18159 readonly STENCIL_BACK_WRITEMASK: GLenum;
18160 readonly STENCIL_BITS: GLenum;
18161 readonly STENCIL_BUFFER_BIT: GLenum;
18162 readonly STENCIL_CLEAR_VALUE: GLenum;
18163 readonly STENCIL_FAIL: GLenum;
18164 readonly STENCIL_FUNC: GLenum;
18165 readonly STENCIL_INDEX8: GLenum;
18166 readonly STENCIL_PASS_DEPTH_FAIL: GLenum;
18167 readonly STENCIL_PASS_DEPTH_PASS: GLenum;
18168 readonly STENCIL_REF: GLenum;
18169 readonly STENCIL_TEST: GLenum;
18170 readonly STENCIL_VALUE_MASK: GLenum;
18171 readonly STENCIL_WRITEMASK: GLenum;
18172 readonly STREAM_DRAW: GLenum;
18173 readonly SUBPIXEL_BITS: GLenum;
18174 readonly TEXTURE: GLenum;
18175 readonly TEXTURE0: GLenum;
18176 readonly TEXTURE1: GLenum;
18177 readonly TEXTURE10: GLenum;
18178 readonly TEXTURE11: GLenum;
18179 readonly TEXTURE12: GLenum;
18180 readonly TEXTURE13: GLenum;
18181 readonly TEXTURE14: GLenum;
18182 readonly TEXTURE15: GLenum;
18183 readonly TEXTURE16: GLenum;
18184 readonly TEXTURE17: GLenum;
18185 readonly TEXTURE18: GLenum;
18186 readonly TEXTURE19: GLenum;
18187 readonly TEXTURE2: GLenum;
18188 readonly TEXTURE20: GLenum;
18189 readonly TEXTURE21: GLenum;
18190 readonly TEXTURE22: GLenum;
18191 readonly TEXTURE23: GLenum;
18192 readonly TEXTURE24: GLenum;
18193 readonly TEXTURE25: GLenum;
18194 readonly TEXTURE26: GLenum;
18195 readonly TEXTURE27: GLenum;
18196 readonly TEXTURE28: GLenum;
18197 readonly TEXTURE29: GLenum;
18198 readonly TEXTURE3: GLenum;
18199 readonly TEXTURE30: GLenum;
18200 readonly TEXTURE31: GLenum;
18201 readonly TEXTURE4: GLenum;
18202 readonly TEXTURE5: GLenum;
18203 readonly TEXTURE6: GLenum;
18204 readonly TEXTURE7: GLenum;
18205 readonly TEXTURE8: GLenum;
18206 readonly TEXTURE9: GLenum;
18207 readonly TEXTURE_2D: GLenum;
18208 readonly TEXTURE_BINDING_2D: GLenum;
18209 readonly TEXTURE_BINDING_CUBE_MAP: GLenum;
18210 readonly TEXTURE_CUBE_MAP: GLenum;
18211 readonly TEXTURE_CUBE_MAP_NEGATIVE_X: GLenum;
18212 readonly TEXTURE_CUBE_MAP_NEGATIVE_Y: GLenum;
18213 readonly TEXTURE_CUBE_MAP_NEGATIVE_Z: GLenum;
18214 readonly TEXTURE_CUBE_MAP_POSITIVE_X: GLenum;
18215 readonly TEXTURE_CUBE_MAP_POSITIVE_Y: GLenum;
18216 readonly TEXTURE_CUBE_MAP_POSITIVE_Z: GLenum;
18217 readonly TEXTURE_MAG_FILTER: GLenum;
18218 readonly TEXTURE_MIN_FILTER: GLenum;
18219 readonly TEXTURE_WRAP_S: GLenum;
18220 readonly TEXTURE_WRAP_T: GLenum;
18221 readonly TRIANGLES: GLenum;
18222 readonly TRIANGLE_FAN: GLenum;
18223 readonly TRIANGLE_STRIP: GLenum;
18224 readonly UNPACK_ALIGNMENT: GLenum;
18225 readonly UNPACK_COLORSPACE_CONVERSION_WEBGL: GLenum;
18226 readonly UNPACK_FLIP_Y_WEBGL: GLenum;
18227 readonly UNPACK_PREMULTIPLY_ALPHA_WEBGL: GLenum;
18228 readonly UNSIGNED_BYTE: GLenum;
18229 readonly UNSIGNED_INT: GLenum;
18230 readonly UNSIGNED_SHORT: GLenum;
18231 readonly UNSIGNED_SHORT_4_4_4_4: GLenum;
18232 readonly UNSIGNED_SHORT_5_5_5_1: GLenum;
18233 readonly UNSIGNED_SHORT_5_6_5: GLenum;
18234 readonly VALIDATE_STATUS: GLenum;
18235 readonly VENDOR: GLenum;
18236 readonly VERSION: GLenum;
18237 readonly VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: GLenum;
18238 readonly VERTEX_ATTRIB_ARRAY_ENABLED: GLenum;
18239 readonly VERTEX_ATTRIB_ARRAY_NORMALIZED: GLenum;
18240 readonly VERTEX_ATTRIB_ARRAY_POINTER: GLenum;
18241 readonly VERTEX_ATTRIB_ARRAY_SIZE: GLenum;
18242 readonly VERTEX_ATTRIB_ARRAY_STRIDE: GLenum;
18243 readonly VERTEX_ATTRIB_ARRAY_TYPE: GLenum;
18244 readonly VERTEX_SHADER: GLenum;
18245 readonly VIEWPORT: GLenum;
18246 readonly ZERO: GLenum;
18249 interface WebGLRenderingContextOverloads {
18250 bufferData(target: GLenum, size: GLsizeiptr, usage: GLenum): void;
18251 bufferData(target: GLenum, data: BufferSource | null, usage: GLenum): void;
18252 bufferSubData(target: GLenum, offset: GLintptr, data: BufferSource): void;
18253 compressedTexImage2D(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, border: GLint, data: ArrayBufferView): void;
18254 compressedTexSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, data: ArrayBufferView): void;
18255 readPixels(x: GLint, y: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, pixels: ArrayBufferView | null): void;
18256 texImage2D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, border: GLint, format: GLenum, type: GLenum, pixels: ArrayBufferView | null): void;
18257 texImage2D(target: GLenum, level: GLint, internalformat: GLint, format: GLenum, type: GLenum, source: TexImageSource): void;
18258 texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, pixels: ArrayBufferView | null): void;
18259 texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, format: GLenum, type: GLenum, source: TexImageSource): void;
18260 uniform1fv(location: WebGLUniformLocation | null, v: Float32List): void;
18261 uniform1iv(location: WebGLUniformLocation | null, v: Int32List): void;
18262 uniform2fv(location: WebGLUniformLocation | null, v: Float32List): void;
18263 uniform2iv(location: WebGLUniformLocation | null, v: Int32List): void;
18264 uniform3fv(location: WebGLUniformLocation | null, v: Float32List): void;
18265 uniform3iv(location: WebGLUniformLocation | null, v: Int32List): void;
18266 uniform4fv(location: WebGLUniformLocation | null, v: Float32List): void;
18267 uniform4iv(location: WebGLUniformLocation | null, v: Int32List): void;
18268 uniformMatrix2fv(location: WebGLUniformLocation | null, transpose: GLboolean, value: Float32List): void;
18269 uniformMatrix3fv(location: WebGLUniformLocation | null, transpose: GLboolean, value: Float32List): void;
18270 uniformMatrix4fv(location: WebGLUniformLocation | null, transpose: GLboolean, value: Float32List): void;
18273 interface WebGLSampler extends WebGLObject {
18276 declare var WebGLSampler: {
18277 prototype: WebGLSampler;
18278 new(): WebGLSampler;
18281 /** The WebGLShader is part of the WebGL API and can either be a vertex or a fragment shader. A WebGLProgram requires both types of shaders. */
18282 interface WebGLShader extends WebGLObject {
18285 declare var WebGLShader: {
18286 prototype: WebGLShader;
18287 new(): WebGLShader;
18290 /** Part of the WebGL API and represents the information returned by calling the WebGLRenderingContext.getShaderPrecisionFormat() method. */
18291 interface WebGLShaderPrecisionFormat {
18292 readonly precision: GLint;
18293 readonly rangeMax: GLint;
18294 readonly rangeMin: GLint;
18297 declare var WebGLShaderPrecisionFormat: {
18298 prototype: WebGLShaderPrecisionFormat;
18299 new(): WebGLShaderPrecisionFormat;
18302 interface WebGLSync extends WebGLObject {
18305 declare var WebGLSync: {
18306 prototype: WebGLSync;
18310 /** Part of the WebGL API and represents an opaque texture object providing storage and state for texturing operations. */
18311 interface WebGLTexture extends WebGLObject {
18314 declare var WebGLTexture: {
18315 prototype: WebGLTexture;
18316 new(): WebGLTexture;
18319 interface WebGLTransformFeedback extends WebGLObject {
18322 declare var WebGLTransformFeedback: {
18323 prototype: WebGLTransformFeedback;
18324 new(): WebGLTransformFeedback;
18327 /** Part of the WebGL API and represents the location of a uniform variable in a shader program. */
18328 interface WebGLUniformLocation {
18331 declare var WebGLUniformLocation: {
18332 prototype: WebGLUniformLocation;
18333 new(): WebGLUniformLocation;
18336 interface WebGLVertexArrayObject extends WebGLObject {
18339 declare var WebGLVertexArrayObject: {
18340 prototype: WebGLVertexArrayObject;
18341 new(): WebGLVertexArrayObject;
18344 interface WebGLVertexArrayObjectOES extends WebGLObject {
18347 interface WebKitPoint {
18352 declare var WebKitPoint: {
18353 prototype: WebKitPoint;
18354 new(x?: number, y?: number): WebKitPoint;
18357 interface WebSocketEventMap {
18358 "close": CloseEvent;
18360 "message": MessageEvent;
18364 /** Provides the API for creating and managing a WebSocket connection to a server, as well as for sending and receiving data on the connection. */
18365 interface WebSocket extends EventTarget {
18367 * Returns a string that indicates how binary data from the WebSocket object is exposed to scripts:
18369 * Can be set, to change how binary data is returned. The default is "blob".
18371 binaryType: BinaryType;
18373 * Returns the number of bytes of application data (UTF-8 text and binary data) that have been queued using send() but not yet been transmitted to the network.
18375 * If the WebSocket connection is closed, this attribute's value will only increase with each call to the send() method. (The number does not reset to zero once the connection closes.)
18377 readonly bufferedAmount: number;
18379 * Returns the extensions selected by the server, if any.
18381 readonly extensions: string;
18382 onclose: ((this: WebSocket, ev: CloseEvent) => any) | null;
18383 onerror: ((this: WebSocket, ev: Event) => any) | null;
18384 onmessage: ((this: WebSocket, ev: MessageEvent) => any) | null;
18385 onopen: ((this: WebSocket, ev: Event) => any) | null;
18387 * Returns the subprotocol selected by the server, if any. It can be used in conjunction with the array form of the constructor's second argument to perform subprotocol negotiation.
18389 readonly protocol: string;
18391 * Returns the state of the WebSocket object's connection. It can have the values described below.
18393 readonly readyState: number;
18395 * Returns the URL that was used to establish the WebSocket connection.
18397 readonly url: string;
18399 * Closes the WebSocket connection, optionally using code as the the WebSocket connection close code and reason as the the WebSocket connection close reason.
18401 close(code?: number, reason?: string): void;
18403 * Transmits data using the WebSocket connection. data can be a string, a Blob, an ArrayBuffer, or an ArrayBufferView.
18405 send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void;
18406 readonly CLOSED: number;
18407 readonly CLOSING: number;
18408 readonly CONNECTING: number;
18409 readonly OPEN: number;
18410 addEventListener<K extends keyof WebSocketEventMap>(type: K, listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
18411 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
18412 removeEventListener<K extends keyof WebSocketEventMap>(type: K, listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
18413 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
18416 declare var WebSocket: {
18417 prototype: WebSocket;
18418 new(url: string, protocols?: string | string[]): WebSocket;
18419 readonly CLOSED: number;
18420 readonly CLOSING: number;
18421 readonly CONNECTING: number;
18422 readonly OPEN: number;
18425 /** Events that occur due to the user moving a mouse wheel or similar input device. */
18426 interface WheelEvent extends MouseEvent {
18427 readonly deltaMode: number;
18428 readonly deltaX: number;
18429 readonly deltaY: number;
18430 readonly deltaZ: number;
18431 readonly DOM_DELTA_LINE: number;
18432 readonly DOM_DELTA_PAGE: number;
18433 readonly DOM_DELTA_PIXEL: number;
18436 declare var WheelEvent: {
18437 prototype: WheelEvent;
18438 new(type: string, eventInitDict?: WheelEventInit): WheelEvent;
18439 readonly DOM_DELTA_LINE: number;
18440 readonly DOM_DELTA_PAGE: number;
18441 readonly DOM_DELTA_PIXEL: number;
18444 interface WindowEventMap extends GlobalEventHandlersEventMap, WindowEventHandlersEventMap {
18446 "afterprint": Event;
18447 "beforeprint": Event;
18448 "beforeunload": BeforeUnloadEvent;
18449 "blur": FocusEvent;
18451 "canplaythrough": Event;
18453 "click": MouseEvent;
18454 "compassneedscalibration": Event;
18455 "contextmenu": MouseEvent;
18456 "dblclick": MouseEvent;
18457 "devicelight": DeviceLightEvent;
18458 "devicemotion": DeviceMotionEvent;
18459 "deviceorientation": DeviceOrientationEvent;
18460 "deviceorientationabsolute": DeviceOrientationEvent;
18462 "dragend": DragEvent;
18463 "dragenter": DragEvent;
18464 "dragleave": DragEvent;
18465 "dragover": DragEvent;
18466 "dragstart": DragEvent;
18468 "durationchange": Event;
18471 "error": ErrorEvent;
18472 "focus": FocusEvent;
18473 "gamepadconnected": GamepadEvent;
18474 "gamepaddisconnected": GamepadEvent;
18475 "hashchange": HashChangeEvent;
18478 "keydown": KeyboardEvent;
18479 "keypress": KeyboardEvent;
18480 "keyup": KeyboardEvent;
18482 "loadeddata": Event;
18483 "loadedmetadata": Event;
18484 "loadstart": Event;
18485 "message": MessageEvent;
18486 "mousedown": MouseEvent;
18487 "mouseenter": MouseEvent;
18488 "mouseleave": MouseEvent;
18489 "mousemove": MouseEvent;
18490 "mouseout": MouseEvent;
18491 "mouseover": MouseEvent;
18492 "mouseup": MouseEvent;
18493 "mousewheel": Event;
18494 "MSGestureChange": Event;
18495 "MSGestureDoubleTap": Event;
18496 "MSGestureEnd": Event;
18497 "MSGestureHold": Event;
18498 "MSGestureStart": Event;
18499 "MSGestureTap": Event;
18500 "MSInertiaStart": Event;
18501 "MSPointerCancel": Event;
18502 "MSPointerDown": Event;
18503 "MSPointerEnter": Event;
18504 "MSPointerLeave": Event;
18505 "MSPointerMove": Event;
18506 "MSPointerOut": Event;
18507 "MSPointerOver": Event;
18508 "MSPointerUp": Event;
18511 "orientationchange": Event;
18512 "pagehide": PageTransitionEvent;
18513 "pageshow": PageTransitionEvent;
18517 "popstate": PopStateEvent;
18518 "progress": ProgressEvent<Window>;
18519 "ratechange": Event;
18520 "readystatechange": ProgressEvent<Window>;
18528 "storage": StorageEvent;
18531 "timeupdate": Event;
18533 "volumechange": Event;
18534 "vrdisplayactivate": Event;
18535 "vrdisplayblur": Event;
18536 "vrdisplayconnect": Event;
18537 "vrdisplaydeactivate": Event;
18538 "vrdisplaydisconnect": Event;
18539 "vrdisplayfocus": Event;
18540 "vrdisplaypointerrestricted": Event;
18541 "vrdisplaypointerunrestricted": Event;
18542 "vrdisplaypresentchange": Event;
18546 /** A window containing a DOM document; the document property points to the DOM document loaded in that window. */
18547 interface Window extends EventTarget, AnimationFrameProvider, GlobalEventHandlers, WindowEventHandlers, WindowLocalStorage, WindowOrWorkerGlobalScope, WindowSessionStorage {
18548 readonly applicationCache: ApplicationCache;
18549 readonly clientInformation: Navigator;
18550 readonly closed: boolean;
18551 customElements: CustomElementRegistry;
18552 defaultStatus: string;
18553 readonly devicePixelRatio: number;
18554 readonly doNotTrack: string;
18555 readonly document: Document;
18557 readonly event: Event | undefined;
18559 readonly external: External;
18560 readonly frameElement: Element | null;
18561 readonly frames: Window;
18562 readonly history: History;
18563 readonly innerHeight: number;
18564 readonly innerWidth: number;
18565 readonly length: number;
18566 location: Location;
18567 readonly locationbar: BarProp;
18568 readonly menubar: BarProp;
18569 readonly msContentScript: ExtensionScriptApis;
18571 readonly navigator: Navigator;
18572 offscreenBuffering: string | boolean;
18573 oncompassneedscalibration: ((this: Window, ev: Event) => any) | null;
18574 ondevicelight: ((this: Window, ev: DeviceLightEvent) => any) | null;
18575 ondevicemotion: ((this: Window, ev: DeviceMotionEvent) => any) | null;
18576 ondeviceorientation: ((this: Window, ev: DeviceOrientationEvent) => any) | null;
18577 ondeviceorientationabsolute: ((this: Window, ev: DeviceOrientationEvent) => any) | null;
18578 ongamepadconnected: ((this: Window, ev: GamepadEvent) => any) | null;
18579 ongamepaddisconnected: ((this: Window, ev: GamepadEvent) => any) | null;
18580 onmousewheel: ((this: Window, ev: Event) => any) | null;
18581 onmsgesturechange: ((this: Window, ev: Event) => any) | null;
18582 onmsgesturedoubletap: ((this: Window, ev: Event) => any) | null;
18583 onmsgestureend: ((this: Window, ev: Event) => any) | null;
18584 onmsgesturehold: ((this: Window, ev: Event) => any) | null;
18585 onmsgesturestart: ((this: Window, ev: Event) => any) | null;
18586 onmsgesturetap: ((this: Window, ev: Event) => any) | null;
18587 onmsinertiastart: ((this: Window, ev: Event) => any) | null;
18588 onmspointercancel: ((this: Window, ev: Event) => any) | null;
18589 onmspointerdown: ((this: Window, ev: Event) => any) | null;
18590 onmspointerenter: ((this: Window, ev: Event) => any) | null;
18591 onmspointerleave: ((this: Window, ev: Event) => any) | null;
18592 onmspointermove: ((this: Window, ev: Event) => any) | null;
18593 onmspointerout: ((this: Window, ev: Event) => any) | null;
18594 onmspointerover: ((this: Window, ev: Event) => any) | null;
18595 onmspointerup: ((this: Window, ev: Event) => any) | null;
18597 onorientationchange: ((this: Window, ev: Event) => any) | null;
18598 onreadystatechange: ((this: Window, ev: ProgressEvent<Window>) => any) | null;
18599 onvrdisplayactivate: ((this: Window, ev: Event) => any) | null;
18600 onvrdisplayblur: ((this: Window, ev: Event) => any) | null;
18601 onvrdisplayconnect: ((this: Window, ev: Event) => any) | null;
18602 onvrdisplaydeactivate: ((this: Window, ev: Event) => any) | null;
18603 onvrdisplaydisconnect: ((this: Window, ev: Event) => any) | null;
18604 onvrdisplayfocus: ((this: Window, ev: Event) => any) | null;
18605 onvrdisplaypointerrestricted: ((this: Window, ev: Event) => any) | null;
18606 onvrdisplaypointerunrestricted: ((this: Window, ev: Event) => any) | null;
18607 onvrdisplaypresentchange: ((this: Window, ev: Event) => any) | null;
18610 readonly orientation: string | number;
18611 readonly outerHeight: number;
18612 readonly outerWidth: number;
18613 readonly pageXOffset: number;
18614 readonly pageYOffset: number;
18615 readonly parent: Window;
18616 readonly personalbar: BarProp;
18617 readonly screen: Screen;
18618 readonly screenLeft: number;
18619 readonly screenTop: number;
18620 readonly screenX: number;
18621 readonly screenY: number;
18622 readonly scrollX: number;
18623 readonly scrollY: number;
18624 readonly scrollbars: BarProp;
18625 readonly self: Window & typeof globalThis;
18626 readonly speechSynthesis: SpeechSynthesis;
18628 readonly statusbar: BarProp;
18629 readonly styleMedia: StyleMedia;
18630 readonly toolbar: BarProp;
18631 readonly top: Window;
18632 readonly visualViewport: VisualViewport;
18633 readonly window: Window & typeof globalThis;
18634 alert(message?: any): void;
18637 captureEvents(): void;
18639 confirm(message?: string): boolean;
18640 departFocus(navigationReason: NavigationReason, origin: FocusNavigationOrigin): void;
18642 getComputedStyle(elt: Element, pseudoElt?: string | null): CSSStyleDeclaration;
18643 getMatchedCSSRules(elt: Element, pseudoElt?: string | null): CSSRuleList;
18644 getSelection(): Selection | null;
18645 matchMedia(query: string): MediaQueryList;
18646 moveBy(x: number, y: number): void;
18647 moveTo(x: number, y: number): void;
18648 msWriteProfilerMark(profilerMarkName: string): void;
18649 open(url?: string, target?: string, features?: string, replace?: boolean): Window | null;
18650 postMessage(message: any, targetOrigin: string, transfer?: Transferable[]): void;
18652 prompt(message?: string, _default?: string): string | null;
18654 releaseEvents(): void;
18655 resizeBy(x: number, y: number): void;
18656 resizeTo(width: number, height: number): void;
18657 scroll(options?: ScrollToOptions): void;
18658 scroll(x: number, y: number): void;
18659 scrollBy(options?: ScrollToOptions): void;
18660 scrollBy(x: number, y: number): void;
18661 scrollTo(options?: ScrollToOptions): void;
18662 scrollTo(x: number, y: number): void;
18664 webkitCancelAnimationFrame(handle: number): void;
18665 webkitConvertPointFromNodeToPage(node: Node, pt: WebKitPoint): WebKitPoint;
18666 webkitConvertPointFromPageToNode(node: Node, pt: WebKitPoint): WebKitPoint;
18667 webkitRequestAnimationFrame(callback: FrameRequestCallback): number;
18668 addEventListener<K extends keyof WindowEventMap>(type: K, listener: (this: Window, ev: WindowEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
18669 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
18670 removeEventListener<K extends keyof WindowEventMap>(type: K, listener: (this: Window, ev: WindowEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
18671 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
18672 [index: number]: Window;
18675 declare var Window: {
18680 interface WindowEventHandlersEventMap {
18681 "afterprint": Event;
18682 "beforeprint": Event;
18683 "beforeunload": BeforeUnloadEvent;
18684 "hashchange": HashChangeEvent;
18685 "languagechange": Event;
18686 "message": MessageEvent;
18687 "messageerror": MessageEvent;
18690 "pagehide": PageTransitionEvent;
18691 "pageshow": PageTransitionEvent;
18692 "popstate": PopStateEvent;
18693 "rejectionhandled": PromiseRejectionEvent;
18694 "storage": StorageEvent;
18695 "unhandledrejection": PromiseRejectionEvent;
18699 interface WindowEventHandlers {
18700 onafterprint: ((this: WindowEventHandlers, ev: Event) => any) | null;
18701 onbeforeprint: ((this: WindowEventHandlers, ev: Event) => any) | null;
18702 onbeforeunload: ((this: WindowEventHandlers, ev: BeforeUnloadEvent) => any) | null;
18703 onhashchange: ((this: WindowEventHandlers, ev: HashChangeEvent) => any) | null;
18704 onlanguagechange: ((this: WindowEventHandlers, ev: Event) => any) | null;
18705 onmessage: ((this: WindowEventHandlers, ev: MessageEvent) => any) | null;
18706 onmessageerror: ((this: WindowEventHandlers, ev: MessageEvent) => any) | null;
18707 onoffline: ((this: WindowEventHandlers, ev: Event) => any) | null;
18708 ononline: ((this: WindowEventHandlers, ev: Event) => any) | null;
18709 onpagehide: ((this: WindowEventHandlers, ev: PageTransitionEvent) => any) | null;
18710 onpageshow: ((this: WindowEventHandlers, ev: PageTransitionEvent) => any) | null;
18711 onpopstate: ((this: WindowEventHandlers, ev: PopStateEvent) => any) | null;
18712 onrejectionhandled: ((this: WindowEventHandlers, ev: PromiseRejectionEvent) => any) | null;
18713 onstorage: ((this: WindowEventHandlers, ev: StorageEvent) => any) | null;
18714 onunhandledrejection: ((this: WindowEventHandlers, ev: PromiseRejectionEvent) => any) | null;
18715 onunload: ((this: WindowEventHandlers, ev: Event) => any) | null;
18716 addEventListener<K extends keyof WindowEventHandlersEventMap>(type: K, listener: (this: WindowEventHandlers, ev: WindowEventHandlersEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
18717 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
18718 removeEventListener<K extends keyof WindowEventHandlersEventMap>(type: K, listener: (this: WindowEventHandlers, ev: WindowEventHandlersEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
18719 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
18722 interface WindowLocalStorage {
18723 readonly localStorage: Storage;
18726 interface WindowOrWorkerGlobalScope {
18727 readonly caches: CacheStorage;
18728 readonly crypto: Crypto;
18729 readonly indexedDB: IDBFactory;
18730 readonly isSecureContext: boolean;
18731 readonly origin: string;
18732 readonly performance: Performance;
18733 atob(data: string): string;
18734 btoa(data: string): string;
18735 clearInterval(handle?: number): void;
18736 clearTimeout(handle?: number): void;
18737 createImageBitmap(image: ImageBitmapSource, options?: ImageBitmapOptions): Promise<ImageBitmap>;
18738 createImageBitmap(image: ImageBitmapSource, sx: number, sy: number, sw: number, sh: number, options?: ImageBitmapOptions): Promise<ImageBitmap>;
18739 fetch(input: RequestInfo, init?: RequestInit): Promise<Response>;
18740 queueMicrotask(callback: VoidFunction): void;
18741 setInterval(handler: TimerHandler, timeout?: number, ...arguments: any[]): number;
18742 setTimeout(handler: TimerHandler, timeout?: number, ...arguments: any[]): number;
18745 interface WindowSessionStorage {
18746 readonly sessionStorage: Storage;
18749 interface WorkerEventMap extends AbstractWorkerEventMap {
18750 "message": MessageEvent;
18751 "messageerror": MessageEvent;
18754 /** This Web Workers API interface represents a background task that can be easily created and can send messages back to its creator. Creating a worker is as simple as calling the Worker() constructor and specifying a script to be run in the worker thread. */
18755 interface Worker extends EventTarget, AbstractWorker {
18756 onmessage: ((this: Worker, ev: MessageEvent) => any) | null;
18757 onmessageerror: ((this: Worker, ev: MessageEvent) => any) | null;
18759 * Clones message and transmits it to worker's global environment. transfer can be passed as a list of objects that are to be transferred rather than cloned.
18761 postMessage(message: any, transfer: Transferable[]): void;
18762 postMessage(message: any, options?: PostMessageOptions): void;
18764 * Aborts worker's associated global environment.
18767 addEventListener<K extends keyof WorkerEventMap>(type: K, listener: (this: Worker, ev: WorkerEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
18768 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
18769 removeEventListener<K extends keyof WorkerEventMap>(type: K, listener: (this: Worker, ev: WorkerEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
18770 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
18773 declare var Worker: {
18775 new(stringUrl: string | URL, options?: WorkerOptions): Worker;
18778 interface Worklet {
18779 addModule(moduleURL: string, options?: WorkletOptions): Promise<void>;
18782 declare var Worklet: {
18783 prototype: Worklet;
18787 /** This Streams API interface provides a standard abstraction for writing streaming data to a destination, known as a sink. This object comes with built-in backpressure and queuing. */
18788 interface WritableStream<W = any> {
18789 readonly locked: boolean;
18790 abort(reason?: any): Promise<void>;
18791 getWriter(): WritableStreamDefaultWriter<W>;
18794 declare var WritableStream: {
18795 prototype: WritableStream;
18796 new<W = any>(underlyingSink?: UnderlyingSink<W>, strategy?: QueuingStrategy<W>): WritableStream<W>;
18799 /** This Streams API interface represents a controller allowing control of a WritableStream's state. When constructing a WritableStream, the underlying sink is given a corresponding WritableStreamDefaultController instance to manipulate. */
18800 interface WritableStreamDefaultController {
18801 error(e?: any): void;
18804 declare var WritableStreamDefaultController: {
18805 prototype: WritableStreamDefaultController;
18806 new(): WritableStreamDefaultController;
18809 /** This Streams API interface is the object returned by WritableStream.getWriter() and once created locks the < writer to the WritableStream ensuring that no other streams can write to the underlying sink. */
18810 interface WritableStreamDefaultWriter<W = any> {
18811 readonly closed: Promise<undefined>;
18812 readonly desiredSize: number | null;
18813 readonly ready: Promise<undefined>;
18814 abort(reason?: any): Promise<void>;
18815 close(): Promise<void>;
18816 releaseLock(): void;
18817 write(chunk: W): Promise<void>;
18820 declare var WritableStreamDefaultWriter: {
18821 prototype: WritableStreamDefaultWriter;
18822 new<W = any>(stream: WritableStream<W>): WritableStreamDefaultWriter<W>;
18825 /** An XML document. It inherits from the generic Document and does not add any specific methods or properties to it: nevertheless, several algorithms behave differently with the two types of documents. */
18826 interface XMLDocument extends Document {
18827 addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: XMLDocument, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
18828 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
18829 removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: XMLDocument, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
18830 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
18833 declare var XMLDocument: {
18834 prototype: XMLDocument;
18835 new(): XMLDocument;
18838 interface XMLHttpRequestEventMap extends XMLHttpRequestEventTargetEventMap {
18839 "readystatechange": Event;
18842 /** Use XMLHttpRequest (XHR) objects to interact with servers. You can retrieve data from a URL without having to do a full page refresh. This enables a Web page to update just part of a page without disrupting what the user is doing. */
18843 interface XMLHttpRequest extends XMLHttpRequestEventTarget {
18844 onreadystatechange: ((this: XMLHttpRequest, ev: Event) => any) | null;
18846 * Returns client's state.
18848 readonly readyState: number;
18850 * Returns the response's body.
18852 readonly response: any;
18854 * Returns the text response.
18856 * Throws an "InvalidStateError" DOMException if responseType is not the empty string or "text".
18858 readonly responseText: string;
18860 * Returns the response type.
18862 * Can be set to change the response type. Values are: the empty string (default), "arraybuffer", "blob", "document", "json", and "text".
18864 * When set: setting to "document" is ignored if current global object is not a Window object.
18866 * When set: throws an "InvalidStateError" DOMException if state is loading or done.
18868 * When set: throws an "InvalidAccessError" DOMException if the synchronous flag is set and current global object is a Window object.
18870 responseType: XMLHttpRequestResponseType;
18871 readonly responseURL: string;
18873 * Returns the document response.
18875 * Throws an "InvalidStateError" DOMException if responseType is not the empty string or "document".
18877 readonly responseXML: Document | null;
18878 readonly status: number;
18879 readonly statusText: string;
18881 * Can be set to a time in milliseconds. When set to a non-zero value will cause fetching to terminate after the given time has passed. When the time has passed, the request has not yet completed, and the synchronous flag is unset, a timeout event will then be dispatched, or a "TimeoutError" DOMException will be thrown otherwise (for the send() method).
18883 * When set: throws an "InvalidAccessError" DOMException if the synchronous flag is set and current global object is a Window object.
18887 * Returns the associated XMLHttpRequestUpload object. It can be used to gather transmission information when data is transferred to a server.
18889 readonly upload: XMLHttpRequestUpload;
18891 * True when credentials are to be included in a cross-origin request. False when they are to be excluded in a cross-origin request and when cookies are to be ignored in its response. Initially false.
18893 * When set: throws an "InvalidStateError" DOMException if state is not unsent or opened, or if the send() flag is set.
18895 withCredentials: boolean;
18897 * Cancels any network activity.
18900 getAllResponseHeaders(): string;
18901 getResponseHeader(name: string): string | null;
18903 * Sets the request method, request URL, and synchronous flag.
18905 * Throws a "SyntaxError" DOMException if either method is not a valid HTTP method or url cannot be parsed.
18907 * Throws a "SecurityError" DOMException if method is a case-insensitive match for `CONNECT`, `TRACE`, or `TRACK`.
18909 * Throws an "InvalidAccessError" DOMException if async is false, current global object is a Window object, and the timeout attribute is not zero or the responseType attribute is not the empty string.
18911 open(method: string, url: string): void;
18912 open(method: string, url: string, async: boolean, username?: string | null, password?: string | null): void;
18914 * Acts as if the `Content-Type` header value for response is mime. (It does not actually change the header though.)
18916 * Throws an "InvalidStateError" DOMException if state is loading or done.
18918 overrideMimeType(mime: string): void;
18920 * Initiates the request. The body argument provides the request body, if any, and is ignored if the request method is GET or HEAD.
18922 * Throws an "InvalidStateError" DOMException if either state is not opened or the send() flag is set.
18924 send(body?: Document | BodyInit | null): void;
18926 * Combines a header in author request headers.
18928 * Throws an "InvalidStateError" DOMException if either state is not opened or the send() flag is set.
18930 * Throws a "SyntaxError" DOMException if name is not a header name or if value is not a header value.
18932 setRequestHeader(name: string, value: string): void;
18933 readonly DONE: number;
18934 readonly HEADERS_RECEIVED: number;
18935 readonly LOADING: number;
18936 readonly OPENED: number;
18937 readonly UNSENT: number;
18938 addEventListener<K extends keyof XMLHttpRequestEventMap>(type: K, listener: (this: XMLHttpRequest, ev: XMLHttpRequestEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
18939 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
18940 removeEventListener<K extends keyof XMLHttpRequestEventMap>(type: K, listener: (this: XMLHttpRequest, ev: XMLHttpRequestEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
18941 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
18944 declare var XMLHttpRequest: {
18945 prototype: XMLHttpRequest;
18946 new(): XMLHttpRequest;
18947 readonly DONE: number;
18948 readonly HEADERS_RECEIVED: number;
18949 readonly LOADING: number;
18950 readonly OPENED: number;
18951 readonly UNSENT: number;
18954 interface XMLHttpRequestEventTargetEventMap {
18955 "abort": ProgressEvent<XMLHttpRequestEventTarget>;
18956 "error": ProgressEvent<XMLHttpRequestEventTarget>;
18957 "load": ProgressEvent<XMLHttpRequestEventTarget>;
18958 "loadend": ProgressEvent<XMLHttpRequestEventTarget>;
18959 "loadstart": ProgressEvent<XMLHttpRequestEventTarget>;
18960 "progress": ProgressEvent<XMLHttpRequestEventTarget>;
18961 "timeout": ProgressEvent<XMLHttpRequestEventTarget>;
18964 interface XMLHttpRequestEventTarget extends EventTarget {
18965 onabort: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
18966 onerror: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
18967 onload: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
18968 onloadend: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
18969 onloadstart: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
18970 onprogress: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
18971 ontimeout: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
18972 addEventListener<K extends keyof XMLHttpRequestEventTargetEventMap>(type: K, listener: (this: XMLHttpRequestEventTarget, ev: XMLHttpRequestEventTargetEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
18973 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
18974 removeEventListener<K extends keyof XMLHttpRequestEventTargetEventMap>(type: K, listener: (this: XMLHttpRequestEventTarget, ev: XMLHttpRequestEventTargetEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
18975 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
18978 declare var XMLHttpRequestEventTarget: {
18979 prototype: XMLHttpRequestEventTarget;
18980 new(): XMLHttpRequestEventTarget;
18983 interface XMLHttpRequestUpload extends XMLHttpRequestEventTarget {
18984 addEventListener<K extends keyof XMLHttpRequestEventTargetEventMap>(type: K, listener: (this: XMLHttpRequestUpload, ev: XMLHttpRequestEventTargetEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
18985 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
18986 removeEventListener<K extends keyof XMLHttpRequestEventTargetEventMap>(type: K, listener: (this: XMLHttpRequestUpload, ev: XMLHttpRequestEventTargetEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
18987 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
18990 declare var XMLHttpRequestUpload: {
18991 prototype: XMLHttpRequestUpload;
18992 new(): XMLHttpRequestUpload;
18995 /** Provides the serializeToString() method to construct an XML string representing a DOM tree. */
18996 interface XMLSerializer {
18997 serializeToString(root: Node): string;
19000 declare var XMLSerializer: {
19001 prototype: XMLSerializer;
19002 new(): XMLSerializer;
19005 /** The XPathEvaluator interface allows to compile and evaluate XPath expressions. */
19006 interface XPathEvaluator extends XPathEvaluatorBase {
19009 declare var XPathEvaluator: {
19010 prototype: XPathEvaluator;
19011 new(): XPathEvaluator;
19014 interface XPathEvaluatorBase {
19015 createExpression(expression: string, resolver?: XPathNSResolver | null): XPathExpression;
19016 createNSResolver(nodeResolver: Node): XPathNSResolver;
19017 evaluate(expression: string, contextNode: Node, resolver?: XPathNSResolver | null, type?: number, result?: XPathResult | null): XPathResult;
19020 /** This interface is a compiled XPath expression that can be evaluated on a document or specific node to return information its DOM tree. */
19021 interface XPathExpression {
19022 evaluate(contextNode: Node, type?: number, result?: XPathResult | null): XPathResult;
19025 declare var XPathExpression: {
19026 prototype: XPathExpression;
19027 new(): XPathExpression;
19030 /** The results generated by evaluating an XPath expression within the context of a given node. */
19031 interface XPathResult {
19032 readonly booleanValue: boolean;
19033 readonly invalidIteratorState: boolean;
19034 readonly numberValue: number;
19035 readonly resultType: number;
19036 readonly singleNodeValue: Node | null;
19037 readonly snapshotLength: number;
19038 readonly stringValue: string;
19039 iterateNext(): Node | null;
19040 snapshotItem(index: number): Node | null;
19041 readonly ANY_TYPE: number;
19042 readonly ANY_UNORDERED_NODE_TYPE: number;
19043 readonly BOOLEAN_TYPE: number;
19044 readonly FIRST_ORDERED_NODE_TYPE: number;
19045 readonly NUMBER_TYPE: number;
19046 readonly ORDERED_NODE_ITERATOR_TYPE: number;
19047 readonly ORDERED_NODE_SNAPSHOT_TYPE: number;
19048 readonly STRING_TYPE: number;
19049 readonly UNORDERED_NODE_ITERATOR_TYPE: number;
19050 readonly UNORDERED_NODE_SNAPSHOT_TYPE: number;
19053 declare var XPathResult: {
19054 prototype: XPathResult;
19055 new(): XPathResult;
19056 readonly ANY_TYPE: number;
19057 readonly ANY_UNORDERED_NODE_TYPE: number;
19058 readonly BOOLEAN_TYPE: number;
19059 readonly FIRST_ORDERED_NODE_TYPE: number;
19060 readonly NUMBER_TYPE: number;
19061 readonly ORDERED_NODE_ITERATOR_TYPE: number;
19062 readonly ORDERED_NODE_SNAPSHOT_TYPE: number;
19063 readonly STRING_TYPE: number;
19064 readonly UNORDERED_NODE_ITERATOR_TYPE: number;
19065 readonly UNORDERED_NODE_SNAPSHOT_TYPE: number;
19068 /** An XSLTProcessor applies an XSLT stylesheet transformation to an XML document to produce a new XML document as output. It has methods to load the XSLT stylesheet, to manipulate <xsl:param> parameter values, and to apply the transformation to documents. */
19069 interface XSLTProcessor {
19070 clearParameters(): void;
19071 getParameter(namespaceURI: string, localName: string): any;
19072 importStylesheet(style: Node): void;
19073 removeParameter(namespaceURI: string, localName: string): void;
19075 setParameter(namespaceURI: string, localName: string, value: any): void;
19076 transformToDocument(source: Node): Document;
19077 transformToFragment(source: Node, document: Document): DocumentFragment;
19080 declare var XSLTProcessor: {
19081 prototype: XSLTProcessor;
19082 new(): XSLTProcessor;
19085 interface webkitRTCPeerConnection extends RTCPeerConnection {
19086 addEventListener<K extends keyof RTCPeerConnectionEventMap>(type: K, listener: (this: webkitRTCPeerConnection, ev: RTCPeerConnectionEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
19087 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
19088 removeEventListener<K extends keyof RTCPeerConnectionEventMap>(type: K, listener: (this: webkitRTCPeerConnection, ev: RTCPeerConnectionEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
19089 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
19092 declare var webkitRTCPeerConnection: {
19093 prototype: webkitRTCPeerConnection;
19094 new(configuration: RTCConfiguration): webkitRTCPeerConnection;
19097 declare type EventListenerOrEventListenerObject = EventListener | EventListenerObject;
19099 interface Console {
19101 assert(condition?: boolean, ...data: any[]): void;
19103 count(label?: string): void;
19104 countReset(label?: string): void;
19105 debug(...data: any[]): void;
19106 dir(item?: any, options?: any): void;
19107 dirxml(...data: any[]): void;
19108 error(...data: any[]): void;
19109 exception(message?: string, ...optionalParams: any[]): void;
19110 group(...data: any[]): void;
19111 groupCollapsed(...data: any[]): void;
19113 info(...data: any[]): void;
19114 log(...data: any[]): void;
19115 table(tabularData?: any, properties?: string[]): void;
19116 time(label?: string): void;
19117 timeEnd(label?: string): void;
19118 timeLog(label?: string, ...data: any[]): void;
19119 timeStamp(label?: string): void;
19120 trace(...data: any[]): void;
19121 warn(...data: any[]): void;
19124 declare var console: Console;
19126 /** Holds useful CSS-related methods. No object with this interface are implemented: it contains only static methods and therefore is a utilitarian interface. */
19127 declare namespace CSS {
19128 function escape(ident: string): string;
19129 function supports(property: string, value: string): boolean;
19130 function supports(conditionText: string): boolean;
19133 declare namespace WebAssembly {
19134 interface CompileError {
19137 var CompileError: {
19138 prototype: CompileError;
19139 new(): CompileError;
19149 new(descriptor: GlobalDescriptor, v?: any): Global;
19152 interface Instance {
19153 readonly exports: Exports;
19157 prototype: Instance;
19158 new(module: Module, importObject?: Imports): Instance;
19161 interface LinkError {
19165 prototype: LinkError;
19170 readonly buffer: ArrayBuffer;
19171 grow(delta: number): number;
19176 new(descriptor: MemoryDescriptor): Memory;
19184 new(bytes: BufferSource): Module;
19185 customSections(moduleObject: Module, sectionName: string): ArrayBuffer[];
19186 exports(moduleObject: Module): ModuleExportDescriptor[];
19187 imports(moduleObject: Module): ModuleImportDescriptor[];
19190 interface RuntimeError {
19193 var RuntimeError: {
19194 prototype: RuntimeError;
19195 new(): RuntimeError;
19199 readonly length: number;
19200 get(index: number): Function | null;
19201 grow(delta: number): number;
19202 set(index: number, value: Function | null): void;
19207 new(descriptor: TableDescriptor): Table;
19210 interface GlobalDescriptor {
19215 interface MemoryDescriptor {
19220 interface ModuleExportDescriptor {
19221 kind: ImportExportKind;
19225 interface ModuleImportDescriptor {
19226 kind: ImportExportKind;
19231 interface TableDescriptor {
19232 element: TableKind;
19237 interface WebAssemblyInstantiatedSource {
19238 instance: Instance;
19242 type ImportExportKind = "function" | "global" | "memory" | "table";
19243 type TableKind = "anyfunc";
19244 type ValueType = "f32" | "f64" | "i32" | "i64";
19245 type ExportValue = Function | Global | Memory | Table;
19246 type Exports = Record<string, ExportValue>;
19247 type ImportValue = ExportValue | number;
19248 type ModuleImports = Record<string, ImportValue>;
19249 type Imports = Record<string, ModuleImports>;
19250 function compile(bytes: BufferSource): Promise<Module>;
19251 function compileStreaming(source: Response | Promise<Response>): Promise<Module>;
19252 function instantiate(bytes: BufferSource, importObject?: Imports): Promise<WebAssemblyInstantiatedSource>;
19253 function instantiate(moduleObject: Module, importObject?: Imports): Promise<Instance>;
19254 function instantiateStreaming(response: Response | PromiseLike<Response>, importObject?: Imports): Promise<WebAssemblyInstantiatedSource>;
19255 function validate(bytes: BufferSource): boolean;
19258 interface BlobCallback {
19259 (blob: Blob | null): void;
19262 interface CustomElementConstructor {
19263 new (...params: any[]): HTMLElement;
19266 interface DecodeErrorCallback {
19267 (error: DOMException): void;
19270 interface DecodeSuccessCallback {
19271 (decodedData: AudioBuffer): void;
19274 interface EventHandlerNonNull {
19275 (event: Event): any;
19278 interface ForEachCallback {
19279 (keyId: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer | null, status: MediaKeyStatus): void;
19282 interface FrameRequestCallback {
19283 (time: number): void;
19286 interface FunctionStringCallback {
19287 (data: string): void;
19290 interface IntersectionObserverCallback {
19291 (entries: IntersectionObserverEntry[], observer: IntersectionObserver): void;
19294 interface MSLaunchUriCallback {
19298 interface MutationCallback {
19299 (mutations: MutationRecord[], observer: MutationObserver): void;
19302 interface NavigatorUserMediaErrorCallback {
19303 (error: MediaStreamError): void;
19306 interface NavigatorUserMediaSuccessCallback {
19307 (stream: MediaStream): void;
19310 interface NotificationPermissionCallback {
19311 (permission: NotificationPermission): void;
19314 interface OnBeforeUnloadEventHandlerNonNull {
19315 (event: Event): string | null;
19318 interface OnErrorEventHandlerNonNull {
19319 (event: Event | string, source?: string, lineno?: number, colno?: number, error?: Error): any;
19322 interface PerformanceObserverCallback {
19323 (entries: PerformanceObserverEntryList, observer: PerformanceObserver): void;
19326 interface PositionCallback {
19327 (position: GeolocationPosition): void;
19330 interface PositionErrorCallback {
19331 (positionError: GeolocationPositionError): void;
19334 interface QueuingStrategySize<T = any> {
19335 (chunk: T): number;
19338 interface RTCPeerConnectionErrorCallback {
19339 (error: DOMException): void;
19342 interface RTCSessionDescriptionCallback {
19343 (description: RTCSessionDescriptionInit): void;
19346 interface RTCStatsCallback {
19347 (report: RTCStatsReport): void;
19350 interface ResizeObserverCallback {
19351 (entries: ResizeObserverEntry[], observer: ResizeObserver): void;
19354 interface TransformerFlushCallback<O> {
19355 (controller: TransformStreamDefaultController<O>): void | PromiseLike<void>;
19358 interface TransformerStartCallback<O> {
19359 (controller: TransformStreamDefaultController<O>): void | PromiseLike<void>;
19362 interface TransformerTransformCallback<I, O> {
19363 (chunk: I, controller: TransformStreamDefaultController<O>): void | PromiseLike<void>;
19366 interface UnderlyingSinkAbortCallback {
19367 (reason: any): void | PromiseLike<void>;
19370 interface UnderlyingSinkCloseCallback {
19371 (): void | PromiseLike<void>;
19374 interface UnderlyingSinkStartCallback {
19375 (controller: WritableStreamDefaultController): void | PromiseLike<void>;
19378 interface UnderlyingSinkWriteCallback<W> {
19379 (chunk: W, controller: WritableStreamDefaultController): void | PromiseLike<void>;
19382 interface UnderlyingSourceCancelCallback {
19383 (reason: any): void | PromiseLike<void>;
19386 interface UnderlyingSourcePullCallback<R> {
19387 (controller: ReadableStreamController<R>): void | PromiseLike<void>;
19390 interface UnderlyingSourceStartCallback<R> {
19391 (controller: ReadableStreamController<R>): void | PromiseLike<void>;
19394 interface VoidFunction {
19398 interface HTMLElementTagNameMap {
19399 "a": HTMLAnchorElement;
19400 "abbr": HTMLElement;
19401 "address": HTMLElement;
19402 "applet": HTMLAppletElement;
19403 "area": HTMLAreaElement;
19404 "article": HTMLElement;
19405 "aside": HTMLElement;
19406 "audio": HTMLAudioElement;
19408 "base": HTMLBaseElement;
19409 "basefont": HTMLBaseFontElement;
19410 "bdi": HTMLElement;
19411 "bdo": HTMLElement;
19412 "blockquote": HTMLQuoteElement;
19413 "body": HTMLBodyElement;
19414 "br": HTMLBRElement;
19415 "button": HTMLButtonElement;
19416 "canvas": HTMLCanvasElement;
19417 "caption": HTMLTableCaptionElement;
19418 "cite": HTMLElement;
19419 "code": HTMLElement;
19420 "col": HTMLTableColElement;
19421 "colgroup": HTMLTableColElement;
19422 "data": HTMLDataElement;
19423 "datalist": HTMLDataListElement;
19425 "del": HTMLModElement;
19426 "details": HTMLDetailsElement;
19427 "dfn": HTMLElement;
19428 "dialog": HTMLDialogElement;
19429 "dir": HTMLDirectoryElement;
19430 "div": HTMLDivElement;
19431 "dl": HTMLDListElement;
19434 "embed": HTMLEmbedElement;
19435 "fieldset": HTMLFieldSetElement;
19436 "figcaption": HTMLElement;
19437 "figure": HTMLElement;
19438 "font": HTMLFontElement;
19439 "footer": HTMLElement;
19440 "form": HTMLFormElement;
19441 "frame": HTMLFrameElement;
19442 "frameset": HTMLFrameSetElement;
19443 "h1": HTMLHeadingElement;
19444 "h2": HTMLHeadingElement;
19445 "h3": HTMLHeadingElement;
19446 "h4": HTMLHeadingElement;
19447 "h5": HTMLHeadingElement;
19448 "h6": HTMLHeadingElement;
19449 "head": HTMLHeadElement;
19450 "header": HTMLElement;
19451 "hgroup": HTMLElement;
19452 "hr": HTMLHRElement;
19453 "html": HTMLHtmlElement;
19455 "iframe": HTMLIFrameElement;
19456 "img": HTMLImageElement;
19457 "input": HTMLInputElement;
19458 "ins": HTMLModElement;
19459 "kbd": HTMLElement;
19460 "label": HTMLLabelElement;
19461 "legend": HTMLLegendElement;
19462 "li": HTMLLIElement;
19463 "link": HTMLLinkElement;
19464 "main": HTMLElement;
19465 "map": HTMLMapElement;
19466 "mark": HTMLElement;
19467 "marquee": HTMLMarqueeElement;
19468 "menu": HTMLMenuElement;
19469 "meta": HTMLMetaElement;
19470 "meter": HTMLMeterElement;
19471 "nav": HTMLElement;
19472 "noscript": HTMLElement;
19473 "object": HTMLObjectElement;
19474 "ol": HTMLOListElement;
19475 "optgroup": HTMLOptGroupElement;
19476 "option": HTMLOptionElement;
19477 "output": HTMLOutputElement;
19478 "p": HTMLParagraphElement;
19479 "param": HTMLParamElement;
19480 "picture": HTMLPictureElement;
19481 "pre": HTMLPreElement;
19482 "progress": HTMLProgressElement;
19483 "q": HTMLQuoteElement;
19486 "ruby": HTMLElement;
19488 "samp": HTMLElement;
19489 "script": HTMLScriptElement;
19490 "section": HTMLElement;
19491 "select": HTMLSelectElement;
19492 "slot": HTMLSlotElement;
19493 "small": HTMLElement;
19494 "source": HTMLSourceElement;
19495 "span": HTMLSpanElement;
19496 "strong": HTMLElement;
19497 "style": HTMLStyleElement;
19498 "sub": HTMLElement;
19499 "summary": HTMLElement;
19500 "sup": HTMLElement;
19501 "table": HTMLTableElement;
19502 "tbody": HTMLTableSectionElement;
19503 "td": HTMLTableDataCellElement;
19504 "template": HTMLTemplateElement;
19505 "textarea": HTMLTextAreaElement;
19506 "tfoot": HTMLTableSectionElement;
19507 "th": HTMLTableHeaderCellElement;
19508 "thead": HTMLTableSectionElement;
19509 "time": HTMLTimeElement;
19510 "title": HTMLTitleElement;
19511 "tr": HTMLTableRowElement;
19512 "track": HTMLTrackElement;
19514 "ul": HTMLUListElement;
19515 "var": HTMLElement;
19516 "video": HTMLVideoElement;
19517 "wbr": HTMLElement;
19520 interface HTMLElementDeprecatedTagNameMap {
19521 "listing": HTMLPreElement;
19522 "xmp": HTMLPreElement;
19525 interface SVGElementTagNameMap {
19527 "circle": SVGCircleElement;
19528 "clipPath": SVGClipPathElement;
19529 "defs": SVGDefsElement;
19530 "desc": SVGDescElement;
19531 "ellipse": SVGEllipseElement;
19532 "feBlend": SVGFEBlendElement;
19533 "feColorMatrix": SVGFEColorMatrixElement;
19534 "feComponentTransfer": SVGFEComponentTransferElement;
19535 "feComposite": SVGFECompositeElement;
19536 "feConvolveMatrix": SVGFEConvolveMatrixElement;
19537 "feDiffuseLighting": SVGFEDiffuseLightingElement;
19538 "feDisplacementMap": SVGFEDisplacementMapElement;
19539 "feDistantLight": SVGFEDistantLightElement;
19540 "feFlood": SVGFEFloodElement;
19541 "feFuncA": SVGFEFuncAElement;
19542 "feFuncB": SVGFEFuncBElement;
19543 "feFuncG": SVGFEFuncGElement;
19544 "feFuncR": SVGFEFuncRElement;
19545 "feGaussianBlur": SVGFEGaussianBlurElement;
19546 "feImage": SVGFEImageElement;
19547 "feMerge": SVGFEMergeElement;
19548 "feMergeNode": SVGFEMergeNodeElement;
19549 "feMorphology": SVGFEMorphologyElement;
19550 "feOffset": SVGFEOffsetElement;
19551 "fePointLight": SVGFEPointLightElement;
19552 "feSpecularLighting": SVGFESpecularLightingElement;
19553 "feSpotLight": SVGFESpotLightElement;
19554 "feTile": SVGFETileElement;
19555 "feTurbulence": SVGFETurbulenceElement;
19556 "filter": SVGFilterElement;
19557 "foreignObject": SVGForeignObjectElement;
19559 "image": SVGImageElement;
19560 "line": SVGLineElement;
19561 "linearGradient": SVGLinearGradientElement;
19562 "marker": SVGMarkerElement;
19563 "mask": SVGMaskElement;
19564 "metadata": SVGMetadataElement;
19565 "path": SVGPathElement;
19566 "pattern": SVGPatternElement;
19567 "polygon": SVGPolygonElement;
19568 "polyline": SVGPolylineElement;
19569 "radialGradient": SVGRadialGradientElement;
19570 "rect": SVGRectElement;
19571 "script": SVGScriptElement;
19572 "stop": SVGStopElement;
19573 "style": SVGStyleElement;
19574 "svg": SVGSVGElement;
19575 "switch": SVGSwitchElement;
19576 "symbol": SVGSymbolElement;
19577 "text": SVGTextElement;
19578 "textPath": SVGTextPathElement;
19579 "title": SVGTitleElement;
19580 "tspan": SVGTSpanElement;
19581 "use": SVGUseElement;
19582 "view": SVGViewElement;
19585 /** @deprecated Directly use HTMLElementTagNameMap or SVGElementTagNameMap as appropriate, instead. */
19586 type ElementTagNameMap = HTMLElementTagNameMap & Pick<SVGElementTagNameMap, Exclude<keyof SVGElementTagNameMap, keyof HTMLElementTagNameMap>>;
19588 declare var Audio: {
19589 new(src?: string): HTMLAudioElement;
19591 declare var Image: {
19592 new(width?: number, height?: number): HTMLImageElement;
19594 declare var Option: {
19595 new(text?: string, value?: string, defaultSelected?: boolean, selected?: boolean): HTMLOptionElement;
19597 declare var applicationCache: ApplicationCache;
19598 declare var clientInformation: Navigator;
19599 declare var closed: boolean;
19600 declare var customElements: CustomElementRegistry;
19601 declare var defaultStatus: string;
19602 declare var devicePixelRatio: number;
19603 declare var doNotTrack: string;
19604 declare var document: Document;
19606 declare var event: Event | undefined;
19608 declare var external: External;
19609 declare var frameElement: Element | null;
19610 declare var frames: Window;
19611 declare var history: History;
19612 declare var innerHeight: number;
19613 declare var innerWidth: number;
19614 declare var length: number;
19615 declare var location: Location;
19616 declare var locationbar: BarProp;
19617 declare var menubar: BarProp;
19618 declare var msContentScript: ExtensionScriptApis;
19620 declare const name: void;
19621 declare var navigator: Navigator;
19622 declare var offscreenBuffering: string | boolean;
19623 declare var oncompassneedscalibration: ((this: Window, ev: Event) => any) | null;
19624 declare var ondevicelight: ((this: Window, ev: DeviceLightEvent) => any) | null;
19625 declare var ondevicemotion: ((this: Window, ev: DeviceMotionEvent) => any) | null;
19626 declare var ondeviceorientation: ((this: Window, ev: DeviceOrientationEvent) => any) | null;
19627 declare var ondeviceorientationabsolute: ((this: Window, ev: DeviceOrientationEvent) => any) | null;
19628 declare var ongamepadconnected: ((this: Window, ev: GamepadEvent) => any) | null;
19629 declare var ongamepaddisconnected: ((this: Window, ev: GamepadEvent) => any) | null;
19630 declare var onmousewheel: ((this: Window, ev: Event) => any) | null;
19631 declare var onmsgesturechange: ((this: Window, ev: Event) => any) | null;
19632 declare var onmsgesturedoubletap: ((this: Window, ev: Event) => any) | null;
19633 declare var onmsgestureend: ((this: Window, ev: Event) => any) | null;
19634 declare var onmsgesturehold: ((this: Window, ev: Event) => any) | null;
19635 declare var onmsgesturestart: ((this: Window, ev: Event) => any) | null;
19636 declare var onmsgesturetap: ((this: Window, ev: Event) => any) | null;
19637 declare var onmsinertiastart: ((this: Window, ev: Event) => any) | null;
19638 declare var onmspointercancel: ((this: Window, ev: Event) => any) | null;
19639 declare var onmspointerdown: ((this: Window, ev: Event) => any) | null;
19640 declare var onmspointerenter: ((this: Window, ev: Event) => any) | null;
19641 declare var onmspointerleave: ((this: Window, ev: Event) => any) | null;
19642 declare var onmspointermove: ((this: Window, ev: Event) => any) | null;
19643 declare var onmspointerout: ((this: Window, ev: Event) => any) | null;
19644 declare var onmspointerover: ((this: Window, ev: Event) => any) | null;
19645 declare var onmspointerup: ((this: Window, ev: Event) => any) | null;
19647 declare var onorientationchange: ((this: Window, ev: Event) => any) | null;
19648 declare var onreadystatechange: ((this: Window, ev: ProgressEvent<Window>) => any) | null;
19649 declare var onvrdisplayactivate: ((this: Window, ev: Event) => any) | null;
19650 declare var onvrdisplayblur: ((this: Window, ev: Event) => any) | null;
19651 declare var onvrdisplayconnect: ((this: Window, ev: Event) => any) | null;
19652 declare var onvrdisplaydeactivate: ((this: Window, ev: Event) => any) | null;
19653 declare var onvrdisplaydisconnect: ((this: Window, ev: Event) => any) | null;
19654 declare var onvrdisplayfocus: ((this: Window, ev: Event) => any) | null;
19655 declare var onvrdisplaypointerrestricted: ((this: Window, ev: Event) => any) | null;
19656 declare var onvrdisplaypointerunrestricted: ((this: Window, ev: Event) => any) | null;
19657 declare var onvrdisplaypresentchange: ((this: Window, ev: Event) => any) | null;
19658 declare var opener: any;
19660 declare var orientation: string | number;
19661 declare var outerHeight: number;
19662 declare var outerWidth: number;
19663 declare var pageXOffset: number;
19664 declare var pageYOffset: number;
19665 declare var parent: Window;
19666 declare var personalbar: BarProp;
19667 declare var screen: Screen;
19668 declare var screenLeft: number;
19669 declare var screenTop: number;
19670 declare var screenX: number;
19671 declare var screenY: number;
19672 declare var scrollX: number;
19673 declare var scrollY: number;
19674 declare var scrollbars: BarProp;
19675 declare var self: Window & typeof globalThis;
19676 declare var speechSynthesis: SpeechSynthesis;
19677 declare var status: string;
19678 declare var statusbar: BarProp;
19679 declare var styleMedia: StyleMedia;
19680 declare var toolbar: BarProp;
19681 declare var top: Window;
19682 declare var visualViewport: VisualViewport;
19683 declare var window: Window & typeof globalThis;
19684 declare function alert(message?: any): void;
19685 declare function blur(): void;
19687 declare function captureEvents(): void;
19688 declare function close(): void;
19689 declare function confirm(message?: string): boolean;
19690 declare function departFocus(navigationReason: NavigationReason, origin: FocusNavigationOrigin): void;
19691 declare function focus(): void;
19692 declare function getComputedStyle(elt: Element, pseudoElt?: string | null): CSSStyleDeclaration;
19693 declare function getMatchedCSSRules(elt: Element, pseudoElt?: string | null): CSSRuleList;
19694 declare function getSelection(): Selection | null;
19695 declare function matchMedia(query: string): MediaQueryList;
19696 declare function moveBy(x: number, y: number): void;
19697 declare function moveTo(x: number, y: number): void;
19698 declare function msWriteProfilerMark(profilerMarkName: string): void;
19699 declare function open(url?: string, target?: string, features?: string, replace?: boolean): Window | null;
19700 declare function postMessage(message: any, targetOrigin: string, transfer?: Transferable[]): void;
19701 declare function print(): void;
19702 declare function prompt(message?: string, _default?: string): string | null;
19704 declare function releaseEvents(): void;
19705 declare function resizeBy(x: number, y: number): void;
19706 declare function resizeTo(width: number, height: number): void;
19707 declare function scroll(options?: ScrollToOptions): void;
19708 declare function scroll(x: number, y: number): void;
19709 declare function scrollBy(options?: ScrollToOptions): void;
19710 declare function scrollBy(x: number, y: number): void;
19711 declare function scrollTo(options?: ScrollToOptions): void;
19712 declare function scrollTo(x: number, y: number): void;
19713 declare function stop(): void;
19714 declare function webkitCancelAnimationFrame(handle: number): void;
19715 declare function webkitConvertPointFromNodeToPage(node: Node, pt: WebKitPoint): WebKitPoint;
19716 declare function webkitConvertPointFromPageToNode(node: Node, pt: WebKitPoint): WebKitPoint;
19717 declare function webkitRequestAnimationFrame(callback: FrameRequestCallback): number;
19718 declare function toString(): string;
19720 * Dispatches a synthetic event event to target and returns true if either event's cancelable attribute value is false or its preventDefault() method was not invoked, and false otherwise.
19722 declare function dispatchEvent(event: Event): boolean;
19723 declare var sessionStorage: Storage;
19724 declare var localStorage: Storage;
19726 * Fires when the user aborts the download.
19727 * @param ev The event.
19729 declare var onabort: ((this: Window, ev: UIEvent) => any) | null;
19730 declare var onanimationcancel: ((this: Window, ev: AnimationEvent) => any) | null;
19731 declare var onanimationend: ((this: Window, ev: AnimationEvent) => any) | null;
19732 declare var onanimationiteration: ((this: Window, ev: AnimationEvent) => any) | null;
19733 declare var onanimationstart: ((this: Window, ev: AnimationEvent) => any) | null;
19734 declare var onauxclick: ((this: Window, ev: MouseEvent) => any) | null;
19736 * Fires when the object loses the input focus.
19737 * @param ev The focus event.
19739 declare var onblur: ((this: Window, ev: FocusEvent) => any) | null;
19740 declare var oncancel: ((this: Window, ev: Event) => any) | null;
19742 * Occurs when playback is possible, but would require further buffering.
19743 * @param ev The event.
19745 declare var oncanplay: ((this: Window, ev: Event) => any) | null;
19746 declare var oncanplaythrough: ((this: Window, ev: Event) => any) | null;
19748 * Fires when the contents of the object or selection have changed.
19749 * @param ev The event.
19751 declare var onchange: ((this: Window, ev: Event) => any) | null;
19753 * Fires when the user clicks the left mouse button on the object
19754 * @param ev The mouse event.
19756 declare var onclick: ((this: Window, ev: MouseEvent) => any) | null;
19757 declare var onclose: ((this: Window, ev: Event) => any) | null;
19759 * Fires when the user clicks the right mouse button in the client area, opening the context menu.
19760 * @param ev The mouse event.
19762 declare var oncontextmenu: ((this: Window, ev: MouseEvent) => any) | null;
19763 declare var oncuechange: ((this: Window, ev: Event) => any) | null;
19765 * Fires when the user double-clicks the object.
19766 * @param ev The mouse event.
19768 declare var ondblclick: ((this: Window, ev: MouseEvent) => any) | null;
19770 * Fires on the source object continuously during a drag operation.
19771 * @param ev The event.
19773 declare var ondrag: ((this: Window, ev: DragEvent) => any) | null;
19775 * Fires on the source object when the user releases the mouse at the close of a drag operation.
19776 * @param ev The event.
19778 declare var ondragend: ((this: Window, ev: DragEvent) => any) | null;
19780 * Fires on the target element when the user drags the object to a valid drop target.
19781 * @param ev The drag event.
19783 declare var ondragenter: ((this: Window, ev: DragEvent) => any) | null;
19784 declare var ondragexit: ((this: Window, ev: Event) => any) | null;
19786 * Fires on the target object when the user moves the mouse out of a valid drop target during a drag operation.
19787 * @param ev The drag event.
19789 declare var ondragleave: ((this: Window, ev: DragEvent) => any) | null;
19791 * Fires on the target element continuously while the user drags the object over a valid drop target.
19792 * @param ev The event.
19794 declare var ondragover: ((this: Window, ev: DragEvent) => any) | null;
19796 * Fires on the source object when the user starts to drag a text selection or selected object.
19797 * @param ev The event.
19799 declare var ondragstart: ((this: Window, ev: DragEvent) => any) | null;
19800 declare var ondrop: ((this: Window, ev: DragEvent) => any) | null;
19802 * Occurs when the duration attribute is updated.
19803 * @param ev The event.
19805 declare var ondurationchange: ((this: Window, ev: Event) => any) | null;
19807 * Occurs when the media element is reset to its initial state.
19808 * @param ev The event.
19810 declare var onemptied: ((this: Window, ev: Event) => any) | null;
19812 * Occurs when the end of playback is reached.
19813 * @param ev The event
19815 declare var onended: ((this: Window, ev: Event) => any) | null;
19817 * Fires when an error occurs during object loading.
19818 * @param ev The event.
19820 declare var onerror: OnErrorEventHandler;
19822 * Fires when the object receives focus.
19823 * @param ev The event.
19825 declare var onfocus: ((this: Window, ev: FocusEvent) => any) | null;
19826 declare var ongotpointercapture: ((this: Window, ev: PointerEvent) => any) | null;
19827 declare var oninput: ((this: Window, ev: Event) => any) | null;
19828 declare var oninvalid: ((this: Window, ev: Event) => any) | null;
19830 * Fires when the user presses a key.
19831 * @param ev The keyboard event
19833 declare var onkeydown: ((this: Window, ev: KeyboardEvent) => any) | null;
19835 * Fires when the user presses an alphanumeric key.
19836 * @param ev The event.
19838 declare var onkeypress: ((this: Window, ev: KeyboardEvent) => any) | null;
19840 * Fires when the user releases a key.
19841 * @param ev The keyboard event
19843 declare var onkeyup: ((this: Window, ev: KeyboardEvent) => any) | null;
19845 * Fires immediately after the browser loads the object.
19846 * @param ev The event.
19848 declare var onload: ((this: Window, ev: Event) => any) | null;
19850 * Occurs when media data is loaded at the current playback position.
19851 * @param ev The event.
19853 declare var onloadeddata: ((this: Window, ev: Event) => any) | null;
19855 * Occurs when the duration and dimensions of the media have been determined.
19856 * @param ev The event.
19858 declare var onloadedmetadata: ((this: Window, ev: Event) => any) | null;
19860 * Occurs when Internet Explorer begins looking for media data.
19861 * @param ev The event.
19863 declare var onloadstart: ((this: Window, ev: Event) => any) | null;
19864 declare var onlostpointercapture: ((this: Window, ev: PointerEvent) => any) | null;
19866 * Fires when the user clicks the object with either mouse button.
19867 * @param ev The mouse event.
19869 declare var onmousedown: ((this: Window, ev: MouseEvent) => any) | null;
19870 declare var onmouseenter: ((this: Window, ev: MouseEvent) => any) | null;
19871 declare var onmouseleave: ((this: Window, ev: MouseEvent) => any) | null;
19873 * Fires when the user moves the mouse over the object.
19874 * @param ev The mouse event.
19876 declare var onmousemove: ((this: Window, ev: MouseEvent) => any) | null;
19878 * Fires when the user moves the mouse pointer outside the boundaries of the object.
19879 * @param ev The mouse event.
19881 declare var onmouseout: ((this: Window, ev: MouseEvent) => any) | null;
19883 * Fires when the user moves the mouse pointer into the object.
19884 * @param ev The mouse event.
19886 declare var onmouseover: ((this: Window, ev: MouseEvent) => any) | null;
19888 * Fires when the user releases a mouse button while the mouse is over the object.
19889 * @param ev The mouse event.
19891 declare var onmouseup: ((this: Window, ev: MouseEvent) => any) | null;
19893 * Occurs when playback is paused.
19894 * @param ev The event.
19896 declare var onpause: ((this: Window, ev: Event) => any) | null;
19898 * Occurs when the play method is requested.
19899 * @param ev The event.
19901 declare var onplay: ((this: Window, ev: Event) => any) | null;
19903 * Occurs when the audio or video has started playing.
19904 * @param ev The event.
19906 declare var onplaying: ((this: Window, ev: Event) => any) | null;
19907 declare var onpointercancel: ((this: Window, ev: PointerEvent) => any) | null;
19908 declare var onpointerdown: ((this: Window, ev: PointerEvent) => any) | null;
19909 declare var onpointerenter: ((this: Window, ev: PointerEvent) => any) | null;
19910 declare var onpointerleave: ((this: Window, ev: PointerEvent) => any) | null;
19911 declare var onpointermove: ((this: Window, ev: PointerEvent) => any) | null;
19912 declare var onpointerout: ((this: Window, ev: PointerEvent) => any) | null;
19913 declare var onpointerover: ((this: Window, ev: PointerEvent) => any) | null;
19914 declare var onpointerup: ((this: Window, ev: PointerEvent) => any) | null;
19916 * Occurs to indicate progress while downloading media data.
19917 * @param ev The event.
19919 declare var onprogress: ((this: Window, ev: ProgressEvent) => any) | null;
19921 * Occurs when the playback rate is increased or decreased.
19922 * @param ev The event.
19924 declare var onratechange: ((this: Window, ev: Event) => any) | null;
19926 * Fires when the user resets a form.
19927 * @param ev The event.
19929 declare var onreset: ((this: Window, ev: Event) => any) | null;
19930 declare var onresize: ((this: Window, ev: UIEvent) => any) | null;
19932 * Fires when the user repositions the scroll box in the scroll bar on the object.
19933 * @param ev The event.
19935 declare var onscroll: ((this: Window, ev: Event) => any) | null;
19936 declare var onsecuritypolicyviolation: ((this: Window, ev: SecurityPolicyViolationEvent) => any) | null;
19938 * Occurs when the seek operation ends.
19939 * @param ev The event.
19941 declare var onseeked: ((this: Window, ev: Event) => any) | null;
19943 * Occurs when the current playback position is moved.
19944 * @param ev The event.
19946 declare var onseeking: ((this: Window, ev: Event) => any) | null;
19948 * Fires when the current selection changes.
19949 * @param ev The event.
19951 declare var onselect: ((this: Window, ev: Event) => any) | null;
19952 declare var onselectionchange: ((this: Window, ev: Event) => any) | null;
19953 declare var onselectstart: ((this: Window, ev: Event) => any) | null;
19955 * Occurs when the download has stopped.
19956 * @param ev The event.
19958 declare var onstalled: ((this: Window, ev: Event) => any) | null;
19959 declare var onsubmit: ((this: Window, ev: Event) => any) | null;
19961 * Occurs if the load operation has been intentionally halted.
19962 * @param ev The event.
19964 declare var onsuspend: ((this: Window, ev: Event) => any) | null;
19966 * Occurs to indicate the current playback position.
19967 * @param ev The event.
19969 declare var ontimeupdate: ((this: Window, ev: Event) => any) | null;
19970 declare var ontoggle: ((this: Window, ev: Event) => any) | null;
19971 declare var ontouchcancel: ((this: Window, ev: TouchEvent) => any) | null | undefined;
19972 declare var ontouchend: ((this: Window, ev: TouchEvent) => any) | null | undefined;
19973 declare var ontouchmove: ((this: Window, ev: TouchEvent) => any) | null | undefined;
19974 declare var ontouchstart: ((this: Window, ev: TouchEvent) => any) | null | undefined;
19975 declare var ontransitioncancel: ((this: Window, ev: TransitionEvent) => any) | null;
19976 declare var ontransitionend: ((this: Window, ev: TransitionEvent) => any) | null;
19977 declare var ontransitionrun: ((this: Window, ev: TransitionEvent) => any) | null;
19978 declare var ontransitionstart: ((this: Window, ev: TransitionEvent) => any) | null;
19980 * Occurs when the volume is changed, or playback is muted or unmuted.
19981 * @param ev The event.
19983 declare var onvolumechange: ((this: Window, ev: Event) => any) | null;
19985 * Occurs when playback stops because the next frame of a video resource is not available.
19986 * @param ev The event.
19988 declare var onwaiting: ((this: Window, ev: Event) => any) | null;
19989 declare var onwheel: ((this: Window, ev: WheelEvent) => any) | null;
19990 declare function cancelAnimationFrame(handle: number): void;
19991 declare function requestAnimationFrame(callback: FrameRequestCallback): number;
19992 declare var caches: CacheStorage;
19993 declare var crypto: Crypto;
19994 declare var indexedDB: IDBFactory;
19995 declare var isSecureContext: boolean;
19996 declare var origin: string;
19997 declare var performance: Performance;
19998 declare function atob(data: string): string;
19999 declare function btoa(data: string): string;
20000 declare function clearInterval(handle?: number): void;
20001 declare function clearTimeout(handle?: number): void;
20002 declare function createImageBitmap(image: ImageBitmapSource, options?: ImageBitmapOptions): Promise<ImageBitmap>;
20003 declare function createImageBitmap(image: ImageBitmapSource, sx: number, sy: number, sw: number, sh: number, options?: ImageBitmapOptions): Promise<ImageBitmap>;
20004 declare function fetch(input: RequestInfo, init?: RequestInit): Promise<Response>;
20005 declare function queueMicrotask(callback: VoidFunction): void;
20006 declare function setInterval(handler: TimerHandler, timeout?: number, ...arguments: any[]): number;
20007 declare function setTimeout(handler: TimerHandler, timeout?: number, ...arguments: any[]): number;
20008 declare var onafterprint: ((this: Window, ev: Event) => any) | null;
20009 declare var onbeforeprint: ((this: Window, ev: Event) => any) | null;
20010 declare var onbeforeunload: ((this: Window, ev: BeforeUnloadEvent) => any) | null;
20011 declare var onhashchange: ((this: Window, ev: HashChangeEvent) => any) | null;
20012 declare var onlanguagechange: ((this: Window, ev: Event) => any) | null;
20013 declare var onmessage: ((this: Window, ev: MessageEvent) => any) | null;
20014 declare var onmessageerror: ((this: Window, ev: MessageEvent) => any) | null;
20015 declare var onoffline: ((this: Window, ev: Event) => any) | null;
20016 declare var ononline: ((this: Window, ev: Event) => any) | null;
20017 declare var onpagehide: ((this: Window, ev: PageTransitionEvent) => any) | null;
20018 declare var onpageshow: ((this: Window, ev: PageTransitionEvent) => any) | null;
20019 declare var onpopstate: ((this: Window, ev: PopStateEvent) => any) | null;
20020 declare var onrejectionhandled: ((this: Window, ev: PromiseRejectionEvent) => any) | null;
20021 declare var onstorage: ((this: Window, ev: StorageEvent) => any) | null;
20022 declare var onunhandledrejection: ((this: Window, ev: PromiseRejectionEvent) => any) | null;
20023 declare var onunload: ((this: Window, ev: Event) => any) | null;
20024 declare function addEventListener<K extends keyof WindowEventMap>(type: K, listener: (this: Window, ev: WindowEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
20025 declare function addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
20026 declare function removeEventListener<K extends keyof WindowEventMap>(type: K, listener: (this: Window, ev: WindowEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
20027 declare function removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
20028 type HeadersInit = Headers | string[][] | Record<string, string>;
20029 type BodyInit = Blob | BufferSource | FormData | URLSearchParams | ReadableStream<Uint8Array> | string;
20030 type RequestInfo = Request | string;
20031 type BlobPart = BufferSource | Blob | string;
20032 type DOMHighResTimeStamp = number;
20033 type RenderingContext = CanvasRenderingContext2D | ImageBitmapRenderingContext | WebGLRenderingContext | WebGL2RenderingContext;
20034 type HTMLOrSVGImageElement = HTMLImageElement | SVGImageElement;
20035 type CanvasImageSource = HTMLOrSVGImageElement | HTMLVideoElement | HTMLCanvasElement | ImageBitmap | OffscreenCanvas;
20036 type OffscreenRenderingContext = OffscreenCanvasRenderingContext2D | ImageBitmapRenderingContext | WebGLRenderingContext | WebGL2RenderingContext;
20037 type MessageEventSource = WindowProxy | MessagePort | ServiceWorker;
20038 type HTMLOrSVGScriptElement = HTMLScriptElement | SVGScriptElement;
20039 type ImageBitmapSource = CanvasImageSource | Blob | ImageData;
20040 type MediaProvider = MediaStream | MediaSource | Blob;
20041 type OnErrorEventHandler = OnErrorEventHandlerNonNull | null;
20042 type OnBeforeUnloadEventHandler = OnBeforeUnloadEventHandlerNonNull | null;
20043 type TimerHandler = string | Function;
20044 type ConstrainULong = number | ConstrainULongRange;
20045 type ConstrainDouble = number | ConstrainDoubleRange;
20046 type ConstrainBoolean = boolean | ConstrainBooleanParameters;
20047 type ConstrainDOMString = string | string[] | ConstrainDOMStringParameters;
20048 type PerformanceEntryList = PerformanceEntry[];
20049 type ReadableStreamReader<T> = ReadableStreamDefaultReader<T>;
20050 type ReadableStreamController<T> = ReadableStreamDefaultController<T>;
20051 type VibratePattern = number | number[];
20052 type COSEAlgorithmIdentifier = number;
20053 type UvmEntry = number[];
20054 type UvmEntries = UvmEntry[];
20055 type AlgorithmIdentifier = string | Algorithm;
20056 type HashAlgorithmIdentifier = AlgorithmIdentifier;
20057 type BigInteger = Uint8Array;
20058 type NamedCurve = string;
20059 type GLenum = number;
20060 type GLboolean = boolean;
20061 type GLbitfield = number;
20062 type GLint = number;
20063 type GLsizei = number;
20064 type GLintptr = number;
20065 type GLsizeiptr = number;
20066 type GLuint = number;
20067 type GLfloat = number;
20068 type GLclampf = number;
20069 type TexImageSource = ImageBitmap | ImageData | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement | OffscreenCanvas;
20070 type Float32List = Float32Array | GLfloat[];
20071 type Int32List = Int32Array | GLint[];
20072 type GLint64 = number;
20073 type GLuint64 = number;
20074 type Uint32List = Uint32Array | GLuint[];
20075 type BufferSource = ArrayBufferView | ArrayBuffer;
20076 type DOMTimeStamp = number;
20077 type LineAndPositionSetting = number | AutoKeyword;
20078 type FormDataEntryValue = File | string;
20079 type InsertPosition = "beforebegin" | "afterbegin" | "beforeend" | "afterend";
20080 type IDBValidKey = number | string | Date | BufferSource | IDBArrayKey;
20081 type MutationRecordType = "attributes" | "characterData" | "childList";
20082 type IDBKeyPath = string;
20083 type Transferable = ArrayBuffer | MessagePort | ImageBitmap | OffscreenCanvas;
20084 type RTCIceGatherCandidate = RTCIceCandidateDictionary | RTCIceCandidateComplete;
20085 type RTCTransport = RTCDtlsTransport | RTCSrtpSdesTransport;
20087 type MouseWheelEvent = WheelEvent;
20088 type WindowProxy = Window;
20089 type ReadableStreamDefaultReadResult<T> = ReadableStreamDefaultReadValueResult<T> | ReadableStreamDefaultReadDoneResult;
20090 type AlignSetting = "center" | "end" | "left" | "right" | "start";
20091 type AnimationPlayState = "finished" | "idle" | "paused" | "running";
20092 type AppendMode = "segments" | "sequence";
20093 type AttestationConveyancePreference = "direct" | "enterprise" | "indirect" | "none";
20094 type AudioContextLatencyCategory = "balanced" | "interactive" | "playback";
20095 type AudioContextState = "closed" | "running" | "suspended";
20096 type AuthenticatorAttachment = "cross-platform" | "platform";
20097 type AuthenticatorTransport = "ble" | "internal" | "nfc" | "usb";
20098 type AutoKeyword = "auto";
20099 type AutomationRate = "a-rate" | "k-rate";
20100 type BinaryType = "arraybuffer" | "blob";
20101 type BiquadFilterType = "allpass" | "bandpass" | "highpass" | "highshelf" | "lowpass" | "lowshelf" | "notch" | "peaking";
20102 type CanPlayTypeResult = "" | "maybe" | "probably";
20103 type CanvasDirection = "inherit" | "ltr" | "rtl";
20104 type CanvasFillRule = "evenodd" | "nonzero";
20105 type CanvasLineCap = "butt" | "round" | "square";
20106 type CanvasLineJoin = "bevel" | "miter" | "round";
20107 type CanvasTextAlign = "center" | "end" | "left" | "right" | "start";
20108 type CanvasTextBaseline = "alphabetic" | "bottom" | "hanging" | "ideographic" | "middle" | "top";
20109 type ChannelCountMode = "clamped-max" | "explicit" | "max";
20110 type ChannelInterpretation = "discrete" | "speakers";
20111 type ClientTypes = "all" | "sharedworker" | "window" | "worker";
20112 type ColorSpaceConversion = "default" | "none";
20113 type CompositeOperation = "accumulate" | "add" | "replace";
20114 type CompositeOperationOrAuto = "accumulate" | "add" | "auto" | "replace";
20115 type CredentialMediationRequirement = "optional" | "required" | "silent";
20116 type DOMParserSupportedType = "application/xhtml+xml" | "application/xml" | "image/svg+xml" | "text/html" | "text/xml";
20117 type DirectionSetting = "" | "lr" | "rl";
20118 type DisplayCaptureSurfaceType = "application" | "browser" | "monitor" | "window";
20119 type DistanceModelType = "exponential" | "inverse" | "linear";
20120 type DocumentReadyState = "complete" | "interactive" | "loading";
20121 type EndOfStreamError = "decode" | "network";
20122 type EndingType = "native" | "transparent";
20123 type FillMode = "auto" | "backwards" | "both" | "forwards" | "none";
20124 type FullscreenNavigationUI = "auto" | "hide" | "show";
20125 type GamepadHand = "" | "left" | "right";
20126 type GamepadHapticActuatorType = "vibration";
20127 type GamepadMappingType = "" | "standard";
20128 type IDBCursorDirection = "next" | "nextunique" | "prev" | "prevunique";
20129 type IDBRequestReadyState = "done" | "pending";
20130 type IDBTransactionMode = "readonly" | "readwrite" | "versionchange";
20131 type ImageOrientation = "flipY" | "none";
20132 type ImageSmoothingQuality = "high" | "low" | "medium";
20133 type IterationCompositeOperation = "accumulate" | "replace";
20134 type KeyFormat = "jwk" | "pkcs8" | "raw" | "spki";
20135 type KeyType = "private" | "public" | "secret";
20136 type KeyUsage = "decrypt" | "deriveBits" | "deriveKey" | "encrypt" | "sign" | "unwrapKey" | "verify" | "wrapKey";
20137 type LineAlignSetting = "center" | "end" | "start";
20138 type ListeningState = "active" | "disambiguation" | "inactive";
20139 type MSCredentialType = "FIDO_2_0";
20140 type MSTransportType = "BT" | "Embedded" | "NFC" | "USB";
20141 type MSWebViewPermissionState = "allow" | "defer" | "deny" | "unknown";
20142 type MSWebViewPermissionType = "geolocation" | "media" | "pointerlock" | "unlimitedIndexedDBQuota" | "webnotifications";
20143 type MediaDeviceKind = "audioinput" | "audiooutput" | "videoinput";
20144 type MediaKeyMessageType = "individualization-request" | "license-release" | "license-renewal" | "license-request";
20145 type MediaKeySessionType = "persistent-license" | "temporary";
20146 type MediaKeyStatus = "expired" | "internal-error" | "output-downscaled" | "output-restricted" | "released" | "status-pending" | "usable";
20147 type MediaKeysRequirement = "not-allowed" | "optional" | "required";
20148 type MediaStreamTrackState = "ended" | "live";
20149 type NavigationReason = "down" | "left" | "right" | "up";
20150 type NavigationType = "back_forward" | "navigate" | "prerender" | "reload";
20151 type NotificationDirection = "auto" | "ltr" | "rtl";
20152 type NotificationPermission = "default" | "denied" | "granted";
20153 type OffscreenRenderingContextId = "2d" | "bitmaprenderer" | "webgl" | "webgl2";
20154 type OrientationLockType = "any" | "landscape" | "landscape-primary" | "landscape-secondary" | "natural" | "portrait" | "portrait-primary" | "portrait-secondary";
20155 type OrientationType = "landscape-primary" | "landscape-secondary" | "portrait-primary" | "portrait-secondary";
20156 type OscillatorType = "custom" | "sawtooth" | "sine" | "square" | "triangle";
20157 type OverSampleType = "2x" | "4x" | "none";
20158 type PanningModelType = "HRTF" | "equalpower";
20159 type PaymentComplete = "fail" | "success" | "unknown";
20160 type PaymentShippingType = "delivery" | "pickup" | "shipping";
20161 type PermissionName = "accelerometer" | "ambient-light-sensor" | "background-fetch" | "background-sync" | "bluetooth" | "camera" | "clipboard-read" | "clipboard-write" | "device-info" | "display-capture" | "geolocation" | "gyroscope" | "magnetometer" | "microphone" | "midi" | "nfc" | "notifications" | "persistent-storage" | "push" | "speaker";
20162 type PermissionState = "denied" | "granted" | "prompt";
20163 type PlaybackDirection = "alternate" | "alternate-reverse" | "normal" | "reverse";
20164 type PositionAlignSetting = "auto" | "center" | "line-left" | "line-right";
20165 type PremultiplyAlpha = "default" | "none" | "premultiply";
20166 type PublicKeyCredentialType = "public-key";
20167 type PushEncryptionKeyName = "auth" | "p256dh";
20168 type PushPermissionState = "denied" | "granted" | "prompt";
20169 type RTCBundlePolicy = "balanced" | "max-bundle" | "max-compat";
20170 type RTCDataChannelState = "closed" | "closing" | "connecting" | "open";
20171 type RTCDegradationPreference = "balanced" | "maintain-framerate" | "maintain-resolution";
20172 type RTCDtlsRole = "auto" | "client" | "server";
20173 type RTCDtlsTransportState = "closed" | "connected" | "connecting" | "failed" | "new";
20174 type RTCDtxStatus = "disabled" | "enabled";
20175 type RTCErrorDetailType = "data-channel-failure" | "dtls-failure" | "fingerprint-failure" | "hardware-encoder-error" | "hardware-encoder-not-available" | "idp-bad-script-failure" | "idp-execution-failure" | "idp-load-failure" | "idp-need-login" | "idp-timeout" | "idp-tls-failure" | "idp-token-expired" | "idp-token-invalid" | "sctp-failure" | "sdp-syntax-error";
20176 type RTCIceCandidateType = "host" | "prflx" | "relay" | "srflx";
20177 type RTCIceComponent = "rtcp" | "rtp";
20178 type RTCIceConnectionState = "checking" | "closed" | "completed" | "connected" | "disconnected" | "failed" | "new";
20179 type RTCIceCredentialType = "oauth" | "password";
20180 type RTCIceGatherPolicy = "all" | "nohost" | "relay";
20181 type RTCIceGathererState = "complete" | "gathering" | "new";
20182 type RTCIceGatheringState = "complete" | "gathering" | "new";
20183 type RTCIceProtocol = "tcp" | "udp";
20184 type RTCIceRole = "controlled" | "controlling" | "unknown";
20185 type RTCIceTcpCandidateType = "active" | "passive" | "so";
20186 type RTCIceTransportPolicy = "all" | "relay";
20187 type RTCIceTransportState = "checking" | "closed" | "completed" | "connected" | "disconnected" | "failed" | "new";
20188 type RTCPeerConnectionState = "closed" | "connected" | "connecting" | "disconnected" | "failed" | "new";
20189 type RTCPriorityType = "high" | "low" | "medium" | "very-low";
20190 type RTCRtcpMuxPolicy = "negotiate" | "require";
20191 type RTCRtpTransceiverDirection = "inactive" | "recvonly" | "sendonly" | "sendrecv" | "stopped";
20192 type RTCSctpTransportState = "closed" | "connected" | "connecting";
20193 type RTCSdpType = "answer" | "offer" | "pranswer" | "rollback";
20194 type RTCSignalingState = "closed" | "have-local-offer" | "have-local-pranswer" | "have-remote-offer" | "have-remote-pranswer" | "stable";
20195 type RTCStatsIceCandidatePairState = "failed" | "frozen" | "in-progress" | "succeeded" | "waiting";
20196 type RTCStatsIceCandidateType = "host" | "peerreflexive" | "relayed" | "serverreflexive";
20197 type RTCStatsType = "candidate-pair" | "certificate" | "codec" | "csrc" | "data-channel" | "ice-server" | "inbound-rtp" | "local-candidate" | "media-source" | "outbound-rtp" | "peer-connection" | "receiver" | "remote-candidate" | "remote-inbound-rtp" | "remote-outbound-rtp" | "sctp-transport" | "sender" | "stream" | "track" | "transceiver" | "transport";
20198 type ReadyState = "closed" | "ended" | "open";
20199 type ReferrerPolicy = "" | "no-referrer" | "no-referrer-when-downgrade" | "origin" | "origin-when-cross-origin" | "same-origin" | "strict-origin" | "strict-origin-when-cross-origin" | "unsafe-url";
20200 type RequestCache = "default" | "force-cache" | "no-cache" | "no-store" | "only-if-cached" | "reload";
20201 type RequestCredentials = "include" | "omit" | "same-origin";
20202 type RequestDestination = "" | "audio" | "audioworklet" | "document" | "embed" | "font" | "image" | "manifest" | "object" | "paintworklet" | "report" | "script" | "sharedworker" | "style" | "track" | "video" | "worker" | "xslt";
20203 type RequestMode = "cors" | "navigate" | "no-cors" | "same-origin";
20204 type RequestRedirect = "error" | "follow" | "manual";
20205 type ResidentKeyRequirement = "discouraged" | "preferred" | "required";
20206 type ResizeObserverBoxOptions = "border-box" | "content-box" | "device-pixel-content-box";
20207 type ResizeQuality = "high" | "low" | "medium" | "pixelated";
20208 type ResponseType = "basic" | "cors" | "default" | "error" | "opaque" | "opaqueredirect";
20209 type ScopedCredentialType = "ScopedCred";
20210 type ScrollBehavior = "auto" | "smooth";
20211 type ScrollLogicalPosition = "center" | "end" | "nearest" | "start";
20212 type ScrollRestoration = "auto" | "manual";
20213 type ScrollSetting = "" | "up";
20214 type SelectionMode = "end" | "preserve" | "select" | "start";
20215 type ServiceWorkerState = "activated" | "activating" | "installed" | "installing" | "parsed" | "redundant";
20216 type ServiceWorkerUpdateViaCache = "all" | "imports" | "none";
20217 type ShadowRootMode = "closed" | "open";
20218 type SpeechRecognitionErrorCode = "aborted" | "audio-capture" | "bad-grammar" | "language-not-supported" | "network" | "no-speech" | "not-allowed" | "service-not-allowed";
20219 type SpeechSynthesisErrorCode = "audio-busy" | "audio-hardware" | "canceled" | "interrupted" | "invalid-argument" | "language-unavailable" | "network" | "not-allowed" | "synthesis-failed" | "synthesis-unavailable" | "text-too-long" | "voice-unavailable";
20220 type TextTrackKind = "captions" | "chapters" | "descriptions" | "metadata" | "subtitles";
20221 type TextTrackMode = "disabled" | "hidden" | "showing";
20222 type TouchType = "direct" | "stylus";
20223 type Transport = "ble" | "nfc" | "usb";
20224 type UserVerificationRequirement = "discouraged" | "preferred" | "required";
20225 type VRDisplayEventReason = "mounted" | "navigation" | "requested" | "unmounted";
20226 type VideoFacingModeEnum = "environment" | "left" | "right" | "user";
20227 type VisibilityState = "hidden" | "visible";
20228 type WebGLPowerPreference = "default" | "high-performance" | "low-power";
20229 type WorkerType = "classic" | "module";
20230 type XMLHttpRequestResponseType = "" | "arraybuffer" | "blob" | "document" | "json" | "text";