/*! *****************************************************************************

Copyright (c) Microsoft Corporation. All rights reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use

this file except in compliance with the License. You may obtain a copy of the

License at http://www.apache.org/licenses/LICENSE-2.0

THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED

WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,

MERCHANTABLITY OR NON-INFRINGEMENT.

See the Apache Version 2.0 License for specific language governing permissions

and limitations under the License.

***************************************************************************** */

/// <reference no-default-lib="true"/>

/////////////////////////////

/// IE DOM APIs

/////////////////////////////

interface Algorithm {

name: string;

}

interface AriaRequestEventInit extends EventInit {

attributeName?: string;

attributeValue?: string;

}

interface CommandEventInit extends EventInit {

commandName?: string;

detail?: string;

}

interface CompositionEventInit extends UIEventInit {

data?: string;

}

interface ConfirmSiteSpecificExceptionsInformation extends ExceptionInformation {

arrayOfDomainStrings?: string[];

}

interface ConstrainBooleanParameters {

exact?: boolean;

ideal?: boolean;

}

interface ConstrainDOMStringParameters {

exact?: string | string[];

ideal?: string | string[];

}

interface ConstrainDoubleRange extends DoubleRange {

exact?: number;

ideal?: number;

}

interface ConstrainLongRange extends LongRange {

exact?: number;

ideal?: number;

}

interface ConstrainVideoFacingModeParameters {

exact?: string | string[];

ideal?: string | string[];

}

interface CustomEventInit extends EventInit {

detail?: any;

}

interface DeviceAccelerationDict {

x?: number;

y?: number;

z?: number;

}

interface DeviceLightEventInit extends EventInit {

value?: number;

}

interface DeviceRotationRateDict {

alpha?: number;

beta?: number;

gamma?: number;

}

interface DoubleRange {

max?: number;

min?: number;

}

interface EventInit {

scoped?: boolean;

bubbles?: boolean;

cancelable?: boolean;

}

interface EventModifierInit extends UIEventInit {

ctrlKey?: boolean;

shiftKey?: boolean;

altKey?: boolean;

metaKey?: boolean;

modifierAltGraph?: boolean;

modifierCapsLock?: boolean;

modifierFn?: boolean;

modifierFnLock?: boolean;

modifierHyper?: boolean;

modifierNumLock?: boolean;

modifierOS?: boolean;

modifierScrollLock?: boolean;

modifierSuper?: boolean;

modifierSymbol?: boolean;

modifierSymbolLock?: boolean;

}

interface ExceptionInformation {

domain?: string;

}

interface FocusEventInit extends UIEventInit {

relatedTarget?: EventTarget;

}

interface HashChangeEventInit extends EventInit {

newURL?: string;

oldURL?: string;

}

interface IDBIndexParameters {

multiEntry?: boolean;

unique?: boolean;

}

interface IDBObjectStoreParameters {

autoIncrement?: boolean;

keyPath?: IDBKeyPath;

}

interface KeyAlgorithm {

name?: string;

}

interface KeyboardEventInit extends EventModifierInit {

code?: string;

key?: string;

location?: number;

repeat?: boolean;

}

interface LongRange {

max?: number;

min?: number;

}

interface MSAccountInfo {

rpDisplayName?: string;

userDisplayName?: string;

accountName?: string;

userId?: string;

accountImageUri?: string;

}

interface MSAudioLocalClientEvent extends MSLocalClientEventBase {

networkSendQualityEventRatio?: number;

networkDelayEventRatio?: number;

cpuInsufficientEventRatio?: number;

deviceHalfDuplexAECEventRatio?: number;

deviceRenderNotFunctioningEventRatio?: number;

deviceCaptureNotFunctioningEventRatio?: number;

deviceGlitchesEventRatio?: number;

deviceLowSNREventRatio?: number;

deviceLowSpeechLevelEventRatio?: number;

deviceClippingEventRatio?: number;

deviceEchoEventRatio?: number;

deviceNearEndToEchoRatioEventRatio?: number;

deviceRenderZeroVolumeEventRatio?: number;

deviceRenderMuteEventRatio?: number;

deviceMultipleEndpointsEventCount?: number;

deviceHowlingEventCount?: number;

}

interface MSAudioRecvPayload extends MSPayloadBase {

samplingRate?: number;

signal?: MSAudioRecvSignal;

packetReorderRatio?: number;

packetReorderDepthAvg?: number;

packetReorderDepthMax?: number;

burstLossLength1?: number;

burstLossLength2?: number;

burstLossLength3?: number;

burstLossLength4?: number;

burstLossLength5?: number;

burstLossLength6?: number;

burstLossLength7?: number;

burstLossLength8OrHigher?: number;

fecRecvDistance1?: number;

fecRecvDistance2?: number;

fecRecvDistance3?: number;

ratioConcealedSamplesAvg?: number;

ratioStretchedSamplesAvg?: number;

ratioCompressedSamplesAvg?: number;

}

interface MSAudioRecvSignal {

initialSignalLevelRMS?: number;

recvSignalLevelCh1?: number;

recvNoiseLevelCh1?: number;

renderSignalLevel?: number;

renderNoiseLevel?: number;

renderLoopbackSignalLevel?: number;

}

interface MSAudioSendPayload extends MSPayloadBase {

samplingRate?: number;

signal?: MSAudioSendSignal;

audioFECUsed?: boolean;

sendMutePercent?: number;

}

interface MSAudioSendSignal {

noiseLevel?: number;

sendSignalLevelCh1?: number;

sendNoiseLevelCh1?: number;

}

interface MSConnectivity {

iceType?: string;

iceWarningFlags?: MSIceWarningFlags;

relayAddress?: MSRelayAddress;

}

interface MSCredentialFilter {

accept?: MSCredentialSpec[];

}

interface MSCredentialParameters {

type?: string;

}

interface MSCredentialSpec {

type?: string;

id?: string;

}

interface MSDelay {

roundTrip?: number;

roundTripMax?: number;

}

interface MSDescription extends RTCStats {

connectivity?: MSConnectivity;

transport?: string;

networkconnectivity?: MSNetworkConnectivityInfo;

localAddr?: MSIPAddressInfo;

remoteAddr?: MSIPAddressInfo;

deviceDevName?: string;

reflexiveLocalIPAddr?: MSIPAddressInfo;

}

interface MSFIDOCredentialParameters extends MSCredentialParameters {

algorithm?: string | Algorithm;

authenticators?: AAGUID[];

}

interface MSIPAddressInfo {

ipAddr?: string;

port?: number;

manufacturerMacAddrMask?: string;

}

interface MSIceWarningFlags {

turnTcpTimedOut?: boolean;

turnUdpAllocateFailed?: boolean;

turnUdpSendFailed?: boolean;

turnTcpAllocateFailed?: boolean;

turnTcpSendFailed?: boolean;

udpLocalConnectivityFailed?: boolean;

udpNatConnectivityFailed?: boolean;

udpRelayConnectivityFailed?: boolean;

tcpNatConnectivityFailed?: boolean;

tcpRelayConnectivityFailed?: boolean;

connCheckMessageIntegrityFailed?: boolean;

allocationMessageIntegrityFailed?: boolean;

connCheckOtherError?: boolean;

turnAuthUnknownUsernameError?: boolean;

noRelayServersConfigured?: boolean;

multipleRelayServersAttempted?: boolean;

portRangeExhausted?: boolean;

alternateServerReceived?: boolean;

pseudoTLSFailure?: boolean;

turnTurnTcpConnectivityFailed?: boolean;

useCandidateChecksFailed?: boolean;

fipsAllocationFailure?: boolean;

}

interface MSJitter {

interArrival?: number;

interArrivalMax?: number;

interArrivalSD?: number;

}

interface MSLocalClientEventBase extends RTCStats {

networkReceiveQualityEventRatio?: number;

networkBandwidthLowEventRatio?: number;

}

interface MSNetwork extends RTCStats {

jitter?: MSJitter;

delay?: MSDelay;

packetLoss?: MSPacketLoss;

utilization?: MSUtilization;

}

interface MSNetworkConnectivityInfo {

vpn?: boolean;

linkspeed?: number;

networkConnectionDetails?: string;

}

interface MSNetworkInterfaceType {

interfaceTypeEthernet?: boolean;

interfaceTypeWireless?: boolean;

interfaceTypePPP?: boolean;

interfaceTypeTunnel?: boolean;

interfaceTypeWWAN?: boolean;

}

interface MSOutboundNetwork extends MSNetwork {

appliedBandwidthLimit?: number;

}

interface MSPacketLoss {

lossRate?: number;

lossRateMax?: number;

}

interface MSPayloadBase extends RTCStats {

payloadDescription?: string;

}

interface MSRelayAddress {

relayAddress?: string;

port?: number;

}

interface MSSignatureParameters {

userPrompt?: string;

}

interface MSTransportDiagnosticsStats extends RTCStats {

baseAddress?: string;

localAddress?: string;

localSite?: string;

networkName?: string;

remoteAddress?: string;

remoteSite?: string;

localMR?: string;

remoteMR?: string;

iceWarningFlags?: MSIceWarningFlags;

portRangeMin?: number;

portRangeMax?: number;

localMRTCPPort?: number;

remoteMRTCPPort?: number;

stunVer?: number;

numConsentReqSent?: number;

numConsentReqReceived?: number;

numConsentRespSent?: number;

numConsentRespReceived?: number;

interfaces?: MSNetworkInterfaceType;

baseInterface?: MSNetworkInterfaceType;

protocol?: string;

localInterface?: MSNetworkInterfaceType;

localAddrType?: string;

remoteAddrType?: string;

iceRole?: string;

rtpRtcpMux?: boolean;

allocationTimeInMs?: number;

msRtcEngineVersion?: string;

}

interface MSUtilization {

packets?: number;

bandwidthEstimation?: number;

bandwidthEstimationMin?: number;

bandwidthEstimationMax?: number;

bandwidthEstimationStdDev?: number;

bandwidthEstimationAvg?: number;

}

interface MSVideoPayload extends MSPayloadBase {

resoluton?: string;

videoBitRateAvg?: number;

videoBitRateMax?: number;

videoFrameRateAvg?: number;

videoPacketLossRate?: number;

durationSeconds?: number;

}

interface MSVideoRecvPayload extends MSVideoPayload {

videoFrameLossRate?: number;

recvCodecType?: string;

recvResolutionWidth?: number;

recvResolutionHeight?: number;

videoResolutions?: MSVideoResolutionDistribution;

recvFrameRateAverage?: number;

recvBitRateMaximum?: number;

recvBitRateAverage?: number;

recvVideoStreamsMax?: number;

recvVideoStreamsMin?: number;

recvVideoStreamsMode?: number;

videoPostFECPLR?: number;

lowBitRateCallPercent?: number;

lowFrameRateCallPercent?: number;

reorderBufferTotalPackets?: number;

recvReorderBufferReorderedPackets?: number;

recvReorderBufferPacketsDroppedDueToBufferExhaustion?: number;

recvReorderBufferMaxSuccessfullyOrderedExtent?: number;

recvReorderBufferMaxSuccessfullyOrderedLateTime?: number;

recvReorderBufferPacketsDroppedDueToTimeout?: number;

recvFpsHarmonicAverage?: number;

recvNumResSwitches?: number;

}

interface MSVideoResolutionDistribution {

cifQuality?: number;

vgaQuality?: number;

h720Quality?: number;

h1080Quality?: number;

h1440Quality?: number;

h2160Quality?: number;

}

interface MSVideoSendPayload extends MSVideoPayload {

sendFrameRateAverage?: number;

sendBitRateMaximum?: number;

sendBitRateAverage?: number;

sendVideoStreamsMax?: number;

sendResolutionWidth?: number;

sendResolutionHeight?: number;

}

interface MediaEncryptedEventInit extends EventInit {

initDataType?: string;

initData?: ArrayBuffer;

}

interface MediaKeyMessageEventInit extends EventInit {

messageType?: string;

message?: ArrayBuffer;

}

interface MediaKeySystemConfiguration {

initDataTypes?: string[];

audioCapabilities?: MediaKeySystemMediaCapability[];

videoCapabilities?: MediaKeySystemMediaCapability[];

distinctiveIdentifier?: string;

persistentState?: string;

}

interface MediaKeySystemMediaCapability {

contentType?: string;

robustness?: string;

}

interface MediaStreamConstraints {

video?: boolean | MediaTrackConstraints;

audio?: boolean | MediaTrackConstraints;

}

interface MediaStreamErrorEventInit extends EventInit {

error?: MediaStreamError;

}

interface MediaStreamTrackEventInit extends EventInit {

track?: MediaStreamTrack;

}

interface MediaTrackCapabilities {

width?: number | LongRange;

height?: number | LongRange;

aspectRatio?: number | DoubleRange;

frameRate?: number | DoubleRange;

facingMode?: string;

volume?: number | DoubleRange;

sampleRate?: number | LongRange;

sampleSize?: number | LongRange;

echoCancellation?: boolean[];

deviceId?: string;

groupId?: string;

}

interface MediaTrackConstraintSet {

width?: number | ConstrainLongRange;

height?: number | ConstrainLongRange;

aspectRatio?: number | ConstrainDoubleRange;

frameRate?: number | ConstrainDoubleRange;

facingMode?: string | string[] | ConstrainDOMStringParameters;

volume?: number | ConstrainDoubleRange;

sampleRate?: number | ConstrainLongRange;

sampleSize?: number | ConstrainLongRange;

echoCancelation?: boolean | ConstrainBooleanParameters;

deviceId?: string | string[] | ConstrainDOMStringParameters;

groupId?: string | string[] | ConstrainDOMStringParameters;

}

interface MediaTrackConstraints extends MediaTrackConstraintSet {

advanced?: MediaTrackConstraintSet[];

}

interface MediaTrackSettings {

width?: number;

height?: number;

aspectRatio?: number;

frameRate?: number;

facingMode?: string;

volume?: number;

sampleRate?: number;

sampleSize?: number;

echoCancellation?: boolean;

deviceId?: string;

groupId?: string;

}

interface MediaTrackSupportedConstraints {

width?: boolean;

height?: boolean;

aspectRatio?: boolean;

frameRate?: boolean;

facingMode?: boolean;

volume?: boolean;

sampleRate?: boolean;

sampleSize?: boolean;

echoCancellation?: boolean;

deviceId?: boolean;

groupId?: boolean;

}

interface MouseEventInit extends EventModifierInit {

screenX?: number;

screenY?: number;

clientX?: number;

clientY?: number;

button?: number;

buttons?: number;

relatedTarget?: EventTarget;

}

interface MsZoomToOptions {

contentX?: number;

contentY?: number;

viewportX?: string;

viewportY?: string;

scaleFactor?: number;

animate?: string;

}

interface MutationObserverInit {

childList?: boolean;

attributes?: boolean;

characterData?: boolean;

subtree?: boolean;

attributeOldValue?: boolean;

characterDataOldValue?: boolean;

attributeFilter?: string[];

}

interface ObjectURLOptions {

oneTimeOnly?: boolean;

}

interface PeriodicWaveConstraints {

disableNormalization?: boolean;

}

interface PointerEventInit extends MouseEventInit {

pointerId?: number;

width?: number;

height?: number;

pressure?: number;

tiltX?: number;

tiltY?: number;

pointerType?: string;

isPrimary?: boolean;

}

interface PositionOptions {

enableHighAccuracy?: boolean;

timeout?: number;

maximumAge?: number;

}

interface RTCDTMFToneChangeEventInit extends EventInit {

tone?: string;

}

interface RTCDtlsFingerprint {

algorithm?: string;

value?: string;

}

interface RTCDtlsParameters {

role?: string;

fingerprints?: RTCDtlsFingerprint[];

}

interface RTCIceCandidate {

foundation?: string;

priority?: number;

ip?: string;

protocol?: string;

port?: number;

type?: string;

tcpType?: string;

relatedAddress?: string;

relatedPort?: number;

}

interface RTCIceCandidateAttributes extends RTCStats {

ipAddress?: string;

portNumber?: number;

transport?: string;

candidateType?: string;

priority?: number;

addressSourceUrl?: string;

}

interface RTCIceCandidateComplete {

}

interface RTCIceCandidatePair {

local?: RTCIceCandidate;

remote?: RTCIceCandidate;

}

interface RTCIceCandidatePairStats extends RTCStats {

transportId?: string;

localCandidateId?: string;

remoteCandidateId?: string;

state?: string;

priority?: number;

nominated?: boolean;

writable?: boolean;

readable?: boolean;

bytesSent?: number;

bytesReceived?: number;

roundTripTime?: number;

availableOutgoingBitrate?: number;

availableIncomingBitrate?: number;

}

interface RTCIceGatherOptions {

gatherPolicy?: string;

iceservers?: RTCIceServer[];

}

interface RTCIceParameters {

usernameFragment?: string;

password?: string;

}

interface RTCIceServer {

urls?: any;

username?: string;

credential?: string;

}

interface RTCInboundRTPStreamStats extends RTCRTPStreamStats {

packetsReceived?: number;

bytesReceived?: number;

packetsLost?: number;

jitter?: number;

fractionLost?: number;

}

interface RTCMediaStreamTrackStats extends RTCStats {

trackIdentifier?: string;

remoteSource?: boolean;

ssrcIds?: string[];

frameWidth?: number;

frameHeight?: number;

framesPerSecond?: number;

framesSent?: number;

framesReceived?: number;

framesDecoded?: number;

framesDropped?: number;

framesCorrupted?: number;

audioLevel?: number;

echoReturnLoss?: number;

echoReturnLossEnhancement?: number;

}

interface RTCOutboundRTPStreamStats extends RTCRTPStreamStats {

packetsSent?: number;

bytesSent?: number;

targetBitrate?: number;

roundTripTime?: number;

}

interface RTCRTPStreamStats extends RTCStats {

ssrc?: string;

associateStatsId?: string;

isRemote?: boolean;

mediaTrackId?: string;

transportId?: string;

codecId?: string;

firCount?: number;

pliCount?: number;

nackCount?: number;

sliCount?: number;

}

interface RTCRtcpFeedback {

type?: string;

parameter?: string;

}

interface RTCRtcpParameters {

ssrc?: number;

cname?: string;

reducedSize?: boolean;

mux?: boolean;

}

interface RTCRtpCapabilities {

codecs?: RTCRtpCodecCapability[];

headerExtensions?: RTCRtpHeaderExtension[];

fecMechanisms?: string[];

}

interface RTCRtpCodecCapability {

name?: string;

kind?: string;

clockRate?: number;

preferredPayloadType?: number;

maxptime?: number;

numChannels?: number;

rtcpFeedback?: RTCRtcpFeedback[];

parameters?: any;

options?: any;

maxTemporalLayers?: number;

maxSpatialLayers?: number;

svcMultiStreamSupport?: boolean;

}

interface RTCRtpCodecParameters {

name?: string;

payloadType?: any;

clockRate?: number;

maxptime?: number;

numChannels?: number;

rtcpFeedback?: RTCRtcpFeedback[];

parameters?: any;

}

interface RTCRtpContributingSource {

timestamp?: number;

csrc?: number;

audioLevel?: number;

}

interface RTCRtpEncodingParameters {

ssrc?: number;

codecPayloadType?: number;

fec?: RTCRtpFecParameters;

rtx?: RTCRtpRtxParameters;

priority?: number;

maxBitrate?: number;

minQuality?: number;

framerateBias?: number;

resolutionScale?: number;

framerateScale?: number;

active?: boolean;

encodingId?: string;

dependencyEncodingIds?: string[];

ssrcRange?: RTCSsrcRange;

}

interface RTCRtpFecParameters {

ssrc?: number;

mechanism?: string;

}

interface RTCRtpHeaderExtension {

kind?: string;

uri?: string;

preferredId?: number;

preferredEncrypt?: boolean;

}

interface RTCRtpHeaderExtensionParameters {

uri?: string;

id?: number;

encrypt?: boolean;

}

interface RTCRtpParameters {

muxId?: string;

codecs?: RTCRtpCodecParameters[];

headerExtensions?: RTCRtpHeaderExtensionParameters[];

encodings?: RTCRtpEncodingParameters[];

rtcp?: RTCRtcpParameters;

}

interface RTCRtpRtxParameters {

ssrc?: number;

}

interface RTCRtpUnhandled {

ssrc?: number;

payloadType?: number;

muxId?: string;

}

interface RTCSrtpKeyParam {

keyMethod?: string;

keySalt?: string;

lifetime?: string;

mkiValue?: number;

mkiLength?: number;

}

interface RTCSrtpSdesParameters {

tag?: number;

cryptoSuite?: string;

keyParams?: RTCSrtpKeyParam[];

sessionParams?: string[];

}

interface RTCSsrcRange {

min?: number;

max?: number;

}

interface RTCStats {

timestamp?: number;

type?: string;

id?: string;

msType?: string;

}

interface RTCStatsReport {

}

interface RTCTransportStats extends RTCStats {

bytesSent?: number;

bytesReceived?: number;

rtcpTransportStatsId?: string;

activeConnection?: boolean;

selectedCandidatePairId?: string;

localCertificateId?: string;

remoteCertificateId?: string;

}

interface StoreExceptionsInformation extends ExceptionInformation {

siteName?: string;

explanationString?: string;

detailURI?: string;

}

interface StoreSiteSpecificExceptionsInformation extends StoreExceptionsInformation {

arrayOfDomainStrings?: string[];

}

interface UIEventInit extends EventInit {

view?: Window;

detail?: number;

}

interface WebGLContextAttributes {

failIfMajorPerformanceCaveat?: boolean;

alpha?: boolean;

depth?: boolean;

stencil?: boolean;

antialias?: boolean;

premultipliedAlpha?: boolean;

preserveDrawingBuffer?: boolean;

}

interface WebGLContextEventInit extends EventInit {

statusMessage?: string;

}

interface WheelEventInit extends MouseEventInit {

deltaX?: number;

deltaY?: number;

deltaZ?: number;

deltaMode?: number;

}

interface EventListener {

(evt: Event): void;

}

interface ANGLE_instanced_arrays {

drawArraysInstancedANGLE(mode: number, first: number, count: number, primcount: number): void;

drawElementsInstancedANGLE(mode: number, count: number, type: number, offset: number, primcount: number): void;

vertexAttribDivisorANGLE(index: number, divisor: number): void;

readonly VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE: number;

}

declare var ANGLE_instanced_arrays: {

prototype: ANGLE_instanced_arrays;

new(): ANGLE_instanced_arrays;

readonly VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE: number;

}

interface AnalyserNode extends AudioNode {

fftSize: number;

readonly frequencyBinCount: number;

maxDecibels: number;

minDecibels: number;

smoothingTimeConstant: number;

getByteFrequencyData(array: Uint8Array): void;

getByteTimeDomainData(array: Uint8Array): void;

getFloatFrequencyData(array: Float32Array): void;

getFloatTimeDomainData(array: Float32Array): void;

}

declare var AnalyserNode: {

prototype: AnalyserNode;

new(): AnalyserNode;

}

interface AnimationEvent extends Event {

readonly animationName: string;

readonly elapsedTime: number;

initAnimationEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, animationNameArg: string, elapsedTimeArg: number): void;

}

declare var AnimationEvent: {

prototype: AnimationEvent;

new(): AnimationEvent;

}

interface ApplicationCacheEventMap {

"cached": Event;

"checking": Event;

"downloading": Event;

"error": ErrorEvent;

"noupdate": Event;

"obsolete": Event;

"progress": ProgressEvent;

"updateready": Event;

}

interface ApplicationCache extends EventTarget {

oncached: (this: ApplicationCache, ev: Event) => any;

onchecking: (this: ApplicationCache, ev: Event) => any;

ondownloading: (this: ApplicationCache, ev: Event) => any;

onerror: (this: ApplicationCache, ev: ErrorEvent) => any;

onnoupdate: (this: ApplicationCache, ev: Event) => any;

onobsolete: (this: ApplicationCache, ev: Event) => any;

onprogress: (this: ApplicationCache, ev: ProgressEvent) => any;

onupdateready: (this: ApplicationCache, ev: Event) => any;

readonly status: number;

abort(): void;

swapCache(): void;

update(): void;

readonly CHECKING: number;

readonly DOWNLOADING: number;

readonly IDLE: number;

readonly OBSOLETE: number;

readonly UNCACHED: number;

readonly UPDATEREADY: number;

addEventListener<K extends keyof ApplicationCacheEventMap>(type: K, listener: (this: ApplicationCache, ev: ApplicationCacheEventMap[K]) => any, useCapture?: boolean): void;

addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;

}

declare var ApplicationCache: {

prototype: ApplicationCache;

new(): ApplicationCache;

readonly CHECKING: number;

readonly DOWNLOADING: number;

readonly IDLE: number;

readonly OBSOLETE: number;

readonly UNCACHED: number;

readonly UPDATEREADY: number;

}

interface AriaRequestEvent extends Event {

readonly attributeName: string;

attributeValue: string | null;

}

declare var AriaRequestEvent: {

prototype: AriaRequestEvent;

new(type: string, eventInitDict?: AriaRequestEventInit): AriaRequestEvent;

}

interface Attr extends Node {

readonly name: string;

readonly ownerElement: Element;

readonly prefix: string | null;

readonly specified: boolean;