diff --git a/.gitignore b/.gitignore index 936f02ba0800..35df15ca591e 100644 --- a/.gitignore +++ b/.gitignore @@ -83,6 +83,7 @@ browser/components/asrouter/node_modules/ browser/components/newtab/node_modules/ browser/components/aboutwelcome/node_modules/ tools/esmify/node_modules/ +tools/ts/node_modules/ # Ignore newtab component build assets browser/components/newtab/logs/ @@ -333,6 +334,9 @@ tools/esmify/jscodeshift.cmd tools/esmify/jscodeshift.ps1 tools/esmify/package-lock.json +# Ignore TypeScript declarations reference file updated by tooling. +tools/@types/index.d.ts + # Ignore support files for en-US dictionary updates extensions/spellcheck/locales/en-US/hunspell/dictionary-sources/scowl extensions/spellcheck/locales/en-US/hunspell/dictionary-sources/support_files/ diff --git a/.hgignore b/.hgignore index ae96829d6436..fdc9913e65a6 100644 --- a/.hgignore +++ b/.hgignore @@ -75,6 +75,7 @@ ^browser/components/newtab/node_modules/ ^browser/components/aboutwelcome/node_modules/ ^tools/esmify/node_modules/ +^tools/ts/node_modules/ # Ignore newtab component build assets ^browser/components/newtab/logs/ @@ -325,6 +326,9 @@ tps_result\.json$ ^tools/esmify/jscodeshift\.ps1 ^tools/esmify/package-lock\.json +# Ignore TypeScript declarations reference file updated by tooling. +^tools/@types/index.d.ts + # Ignore support files for en-US dictionary updates ^extensions/spellcheck/locales/en-US/hunspell/dictionary-sources/scowl ^extensions/spellcheck/locales/en-US/hunspell/dictionary-sources/support_files/ diff --git a/.prettierignore b/.prettierignore index 1581e680da35..85a1f534746c 100644 --- a/.prettierignore +++ b/.prettierignore @@ -1488,5 +1488,6 @@ toolkit/components/uniffi-js/UniFFIFixtureScaffolding.cpp toolkit/components/uniffi-bindgen-gecko-js/fixtures/generated tools/browsertime/package.json tools/browsertime/package-lock.json +tools/ts/error_list.json try_task_config.json xpcom/idl-parser/xpidl/fixtures/xpctest.d.json diff --git a/package-lock.json b/package-lock.json index f38a50aa9216..d069bbf0f5e0 100644 --- a/package-lock.json +++ b/package-lock.json @@ -8,6 +8,7 @@ "license": "MPL-2.0", "devDependencies": { "@microsoft/eslint-plugin-sdl": "0.2.2", + "@types/gecko": "file:tools/@types", "eslint": "8.57.0", "eslint-config-prettier": "8.8.0", "eslint-plugin-eslint-plugin": "5.4.0", @@ -554,6 +555,10 @@ "node": ">= 8" } }, + "node_modules/@types/gecko": { + "resolved": "tools/@types", + "link": true + }, "node_modules/@types/json-schema": { "version": "7.0.15", "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.15.tgz", @@ -5968,6 +5973,11 @@ "url": "https://github.com/sponsors/sindresorhus" } }, + "tools/@types": { + "version": "1.0.0", + "dev": true, + "license": "MPL-2.0" + }, "tools/lint/eslint/eslint-plugin-mozilla": { "version": "3.7.1", "dev": true, diff --git a/package.json b/package.json index e8c455c03954..2153b1b9e8fd 100644 --- a/package.json +++ b/package.json @@ -5,6 +5,7 @@ "license": "MPL-2.0", "devDependencies": { "@microsoft/eslint-plugin-sdl": "0.2.2", + "@types/gecko": "file:tools/@types", "eslint": "8.57.0", "eslint-config-prettier": "8.8.0", "eslint-plugin-eslint-plugin": "5.4.0", diff --git a/python/mach/mach/command_util.py b/python/mach/mach/command_util.py index 1c2b064f84f9..e8238bd83e2a 100644 --- a/python/mach/mach/command_util.py +++ b/python/mach/mach/command_util.py @@ -204,6 +204,7 @@ MACH_COMMANDS = { ), "tps-build": MachCommandReference("testing/tps/mach_commands.py"), "try": MachCommandReference("tools/tryselect/mach_commands.py"), + "ts": MachCommandReference("tools/ts/mach_commands.py"), "uniffi": MachCommandReference( "toolkit/components/uniffi-bindgen-gecko-js/mach_commands.py" ), diff --git a/tools/@types/lib.gecko.dom.d.ts b/tools/@types/lib.gecko.dom.d.ts new file mode 100644 index 000000000000..2f6028d43b35 --- /dev/null +++ b/tools/@types/lib.gecko.dom.d.ts @@ -0,0 +1,36605 @@ +///////////////////////////// +/// Window APIs +///////////////////////////// + +/// +/// +/// + +interface ActivateMenuItemOptions { + altKey?: boolean; + button?: number; + ctrlKey?: boolean; + metaKey?: boolean; + shiftKey?: boolean; +} + +interface AddEventListenerOptions extends EventListenerOptions { + once?: boolean; + passive?: boolean; + signal?: AbortSignal; + wantUntrusted?: boolean; +} + +interface AddonEventInit extends EventInit { + id: string; +} + +interface AddressErrors { + addressLine?: string; + city?: string; + country?: string; + dependentLocality?: string; + organization?: string; + phone?: string; + postalCode?: string; + recipient?: string; + region?: string; + regionCode?: string; + sortingCode?: string; +} + +interface AnalyserOptions extends AudioNodeOptions { + fftSize?: number; + maxDecibels?: number; + minDecibels?: number; + smoothingTimeConstant?: number; +} + +interface AnimationEventInit extends EventInit { + animationName?: string; + elapsedTime?: number; + pseudoElement?: string; +} + +interface AnimationPlaybackEventInit extends EventInit { + currentTime?: number | null; + timelineTime?: number | null; +} + +interface AnimationPropertyDetails { + property: string; + runningOnCompositor: boolean; + values: AnimationPropertyValueDetails[]; + warning?: string; +} + +interface AnimationPropertyValueDetails { + composite: CompositeOperation; + easing?: UTF8String; + offset: number; + value?: UTF8String; +} + +interface AssignedNodesOptions { + flatten?: boolean; +} + +interface AttributeNameValue { + name: UTF8String; + value: UTF8String; +} + +interface AudioBufferOptions { + length: number; + numberOfChannels?: number; + sampleRate: number; +} + +interface AudioBufferSourceOptions { + buffer?: AudioBuffer | null; + detune?: number; + loop?: boolean; + loopEnd?: number; + loopStart?: number; + playbackRate?: number; +} + +interface AudioConfiguration { + bitrate?: number; + channels?: string; + contentType: string; + samplerate?: number; +} + +interface AudioContextOptions { + sampleRate?: number; +} + +interface AudioNodeOptions { + channelCount?: number; + channelCountMode?: ChannelCountMode; + channelInterpretation?: ChannelInterpretation; +} + +interface AudioOutputOptions { + deviceId?: string; +} + +interface AudioSinkDebugInfo { + audioEnded?: boolean; + hasErrored?: boolean; + isPlaying?: boolean; + isStarted?: boolean; + lastGoodPosition?: number; + outputRate?: number; + playbackComplete?: boolean; + startTime?: number; + written?: number; +} + +interface AudioSinkWrapperDebugInfo { + audioEnded?: boolean; + audioSink?: AudioSinkDebugInfo; + isPlaying?: boolean; + isStarted?: boolean; +} + +interface AudioTimestamp { + contextTime?: number; + performanceTime?: DOMHighResTimeStamp; +} + +interface AudioWorkletNodeOptions extends AudioNodeOptions { + numberOfInputs?: number; + numberOfOutputs?: number; + outputChannelCount?: number[]; + parameterData?: Record; + processorOptions?: any; +} + +interface AuthenticationExtensionsClientInputs { + appid?: string; + credProps?: boolean; + hmacCreateSecret?: boolean; + minPinLength?: boolean; +} + +interface AuthenticationExtensionsClientInputsJSON { + appid?: string; + credProps?: boolean; + hmacCreateSecret?: boolean; + minPinLength?: boolean; +} + +interface AuthenticationExtensionsClientOutputs { + appid?: boolean; + credProps?: CredentialPropertiesOutput; + hmacCreateSecret?: boolean; +} + +interface AuthenticatorSelectionCriteria { + authenticatorAttachment?: string; + requireResidentKey?: boolean; + residentKey?: string; + userVerification?: string; +} + +interface AutocompleteInfo { + addressType?: string; + canAutomaticallyPersist?: boolean; + contactType?: string; + credentialType?: string; + fieldName?: string; + section?: string; +} + +interface AvcEncoderConfig { + format?: AvcBitstreamFormat; +} + +interface Base64URLDecodeOptions { + padding: Base64URLDecodePadding; +} + +interface Base64URLEncodeOptions { + pad: boolean; +} + +interface BiquadFilterOptions extends AudioNodeOptions { + Q?: number; + detune?: number; + frequency?: number; + gain?: number; + type?: BiquadFilterType; +} + +interface BlobEventInit extends EventInit { + data: Blob; +} + +interface BlobPropertyBag { + endings?: EndingType; + type?: string; +} + +interface BlockParsingOptions { + blockScriptCreated?: boolean; +} + +interface BoxQuadOptions { + box?: CSSBoxType; + createFramesForSuppressedWhitespace?: boolean; + relativeTo?: GeometryNode; +} + +interface BufferRange { + end?: number; + start?: number; +} + +interface CDMInformation { + capabilities: string; + clearlead: boolean; + keySystemName: string; +} + +interface CSSStyleSheetInit { + baseURL?: UTF8String; + disabled?: boolean; + media?: MediaList | UTF8String; +} + +interface CacheQueryOptions { + ignoreMethod?: boolean; + ignoreSearch?: boolean; + ignoreVary?: boolean; +} + +interface CanvasRenderingContext2DSettings { + alpha?: boolean; + colorSpace?: PredefinedColorSpace; + desynchronized?: boolean; + willReadFrequently?: boolean; +} + +interface CaretStateChangedEventInit extends EventInit { + boundingClientRect?: DOMRectReadOnly | null; + caretVisible?: boolean; + caretVisuallyVisible?: boolean; + clientX?: number; + clientY?: number; + collapsed?: boolean; + reason?: CaretChangedReason; + selectedTextContent?: string; + selectionEditable?: boolean; + selectionVisible?: boolean; +} + +interface ChannelMergerOptions extends AudioNodeOptions { + numberOfInputs?: number; +} + +interface ChannelSplitterOptions extends AudioNodeOptions { + numberOfOutputs?: number; +} + +interface CheckVisibilityOptions { + checkOpacity?: boolean; + checkVisibilityCSS?: boolean; + contentVisibilityAuto?: boolean; + flush?: boolean; + opacityProperty?: boolean; + visibilityProperty?: boolean; +} + +interface CheckerboardReport { + log?: string; + reason?: CheckerboardReason; + severity?: number; + timestamp?: DOMTimeStamp; +} + +interface ChildProcInfoDictionary { + childID?: number; + cpuCycleCount?: number; + cpuTime?: number; + memory?: number; + origin?: UTF8String; + pid?: number; + threads?: ThreadInfoDictionary[]; + type?: WebIDLProcType; + utilityActors?: UtilityActorsDictionary[]; + windows?: WindowInfoDictionary[]; +} + +interface ChromeFilePropertyBag extends FilePropertyBag { + existenceCheck?: boolean; + name?: string; +} + +interface ClientQueryOptions { + includeUncontrolled?: boolean; + type?: ClientType; +} + +interface ClientRectsAndTexts { + rectList: DOMRectList; + textList: string[]; +} + +interface ClipboardEventInit extends EventInit { + data?: string; + dataType?: string; +} + +interface ClipboardItemOptions { + presentationStyle?: PresentationStyle; +} + +interface CloseEventInit extends EventInit { + code?: number; + reason?: string; + wasClean?: boolean; +} + +interface CollectedData { + children?: any[]; + id?: Record; + innerHTML?: string; + scroll?: string; + url?: string; + xpath?: Record; +} + +interface CompileScriptOptionsDictionary { + charset?: string; + hasReturnValue?: boolean; + lazilyParse?: boolean; +} + +interface CompositionEventInit extends UIEventInit { + data?: string; +} + +interface ComputedEffectTiming extends EffectTiming { + activeDuration?: number; + currentIteration?: number | null; + endTime?: number; + localTime?: number | null; + progress?: number | null; +} + +interface ConsoleInstanceOptions { + consoleID?: string; + dump?: ConsoleInstanceDumpCallback; + innerID?: string; + maxLogLevel?: ConsoleLogLevel; + maxLogLevelPref?: string; + prefix?: string; +} + +interface ConstantSourceOptions { + offset?: number; +} + +interface ConstrainBooleanParameters { + exact?: boolean; + ideal?: boolean; +} + +interface ConstrainDOMStringParameters { + exact?: string | string[]; + ideal?: string | string[]; +} + +interface ConstrainDoubleRange { + exact?: number; + ideal?: number; + max?: number; + min?: number; +} + +interface ConstrainLongRange { + exact?: number; + ideal?: number; + max?: number; + min?: number; +} + +interface ContentVisibilityAutoStateChangeEventInit extends EventInit { + skipped?: boolean; +} + +interface ConvertCoordinateOptions { + fromBox?: CSSBoxType; + toBox?: CSSBoxType; +} + +interface ConvolverOptions extends AudioNodeOptions { + buffer?: AudioBuffer | null; + disableNormalization?: boolean; +} + +interface CopyOptions { + noOverwrite?: boolean; + recursive?: boolean; +} + +interface CredentialCreationOptions { + publicKey?: PublicKeyCredentialCreationOptions; + signal?: AbortSignal; +} + +interface CredentialPropertiesOutput { + rk?: boolean; +} + +interface CredentialRequestOptions { + identity?: IdentityCredentialRequestOptions; + mediation?: CredentialMediationRequirement; + publicKey?: PublicKeyCredentialRequestOptions; + signal?: AbortSignal; +} + +interface CustomEventInit extends EventInit { + detail?: any; +} + +interface DOMMatrix2DInit { + a?: number; + b?: number; + c?: number; + d?: number; + e?: number; + f?: number; + m11?: number; + m12?: number; + m21?: number; + m22?: number; + m41?: number; + m42?: number; +} + +interface DOMMatrixInit extends DOMMatrix2DInit { + is2D?: boolean; + m13?: number; + m14?: number; + m23?: number; + m24?: number; + m31?: number; + m32?: number; + m33?: number; + m34?: number; + m43?: number; + m44?: number; +} + +interface DOMPointInit { + w?: number; + x?: number; + y?: number; + z?: number; +} + +interface DOMQuadInit { + p1?: DOMPointInit; + p2?: DOMPointInit; + p3?: DOMPointInit; + p4?: DOMPointInit; +} + +interface DOMRectInit { + height?: number; + width?: number; + x?: number; + y?: number; +} + +interface DateTimeValue { + day?: number; + hour?: number; + minute?: number; + month?: number; + year?: number; +} + +interface DecodedStreamDataDebugInfo { + audioFramesWritten?: number; + haveSentFinishAudio?: boolean; + haveSentFinishVideo?: boolean; + instance?: string; + lastVideoEndTime?: number; + lastVideoStartTime?: number; + nextAudioTime?: number; + streamAudioWritten?: number; + streamVideoWritten?: number; +} + +interface DecodedStreamDebugInfo { + audioQueueFinished?: boolean; + audioQueueSize?: number; + data?: DecodedStreamDataDebugInfo; + instance?: string; + lastAudio?: number; + lastOutputTime?: number; + playing?: number; + startTime?: number; +} + +interface DelayOptions extends AudioNodeOptions { + delayTime?: number; + maxDelayTime?: number; +} + +interface DeviceAccelerationInit { + x?: number | null; + y?: number | null; + z?: number | null; +} + +interface DeviceLightEventInit extends EventInit { + value?: number; +} + +interface DeviceMotionEventInit extends EventInit { + acceleration?: DeviceAccelerationInit; + accelerationIncludingGravity?: DeviceAccelerationInit; + interval?: number | null; + rotationRate?: DeviceRotationRateInit; +} + +interface DeviceOrientationEventInit extends EventInit { + absolute?: boolean; + alpha?: number | null; + beta?: number | null; + gamma?: number | null; +} + +interface DeviceRotationRateInit { + alpha?: number | null; + beta?: number | null; + gamma?: number | null; +} + +interface DictWithAllowSharedBufferSource { + allowSharedArrayBuffer?: ArrayBuffer; + allowSharedArrayBufferView?: ArrayBufferView; + arrayBuffer?: ArrayBuffer; + arrayBufferView?: ArrayBufferView; +} + +interface DisplayMediaStreamConstraints { + audio?: boolean | MediaTrackConstraints; + video?: boolean | MediaTrackConstraints; +} + +interface DisplayNameOptions { + calendar?: string; + keys?: string[]; + style?: string; + type?: string; +} + +interface DisplayNameResult { + calendar?: string; + locale?: string; + style?: string; + type?: string; + values?: string[]; +} + +interface DocumentTimelineOptions { + originTime?: DOMHighResTimeStamp; +} + +interface DragEventInit extends MouseEventInit { + dataTransfer?: DataTransfer | null; +} + +interface DynamicsCompressorOptions extends AudioNodeOptions { + attack?: number; + knee?: number; + ratio?: number; + release?: number; + threshold?: number; +} + +interface EMEDebugInfo { + keySystem?: string; + sessionsInfo?: string; +} + +interface EffectTiming { + delay?: number; + direction?: PlaybackDirection; + duration?: number | string; + easing?: UTF8String; + endDelay?: number; + fill?: FillMode; + iterationStart?: number; + iterations?: number; +} + +interface ElementCreationOptions { + is?: string; + pseudo?: string; +} + +interface ElementDefinitionOptions { + extends?: string; +} + +interface EncodedVideoChunkInit { + data: ArrayBufferView | ArrayBuffer; + duration?: number; + timestamp: number; + type: EncodedVideoChunkType; +} + +interface EncodedVideoChunkMetadata { + decoderConfig?: VideoDecoderConfig; + svc?: SvcOutputMetadata; +} + +interface ErrorEventInit extends EventInit { + colno?: number; + error?: any; + filename?: string; + lineno?: number; + message?: string; +} + +interface EventInit { + bubbles?: boolean; + cancelable?: boolean; + composed?: boolean; +} + +interface EventListenerOptions { + capture?: boolean; + mozSystemGroup?: boolean; +} + +interface EventModifierInit extends UIEventInit { + altKey?: boolean; + ctrlKey?: boolean; + metaKey?: boolean; + modifierAltGraph?: boolean; + modifierCapsLock?: boolean; + modifierFn?: boolean; + modifierFnLock?: boolean; + modifierNumLock?: boolean; + modifierOS?: boolean; + modifierScrollLock?: boolean; + modifierSymbol?: boolean; + modifierSymbolLock?: boolean; + shiftKey?: boolean; +} + +interface EventSourceInit { + withCredentials?: boolean; +} + +interface ExecuteInGlobalOptions { + reportExceptions?: boolean; +} + +interface ExtendableEventInit extends EventInit { +} + +interface ExtendableMessageEventInit extends ExtendableEventInit { + data?: any; + lastEventId?: string; + origin?: string; + ports?: MessagePort[]; + source?: Client | ServiceWorker | MessagePort | null; +} + +interface FailedCertSecurityInfo { + certChainStrings?: string[]; + certValidityRangeNotAfter?: DOMTimeStamp; + certValidityRangeNotBefore?: DOMTimeStamp; + errorCodeString?: string; + errorMessage?: string; + hasHPKP?: boolean; + hasHSTS?: boolean; + issuerCommonName?: string; + overridableErrorCategory?: OverridableErrorCategory; + validNotAfter?: DOMTimeStamp; + validNotBefore?: DOMTimeStamp; +} + +interface FdMapping { + dst: number; + src: number; +} + +interface FetchEventInit extends EventInit { + clientId?: string; + request: Request; + resultingClientId?: string; +} + +interface FileInfo { + creationTime?: number; + lastAccessed?: number; + lastModified?: number; + path?: string; + permissions?: number; + size?: number; + type?: FileType; +} + +interface FilePropertyBag extends BlobPropertyBag { + lastModified?: number; +} + +interface FileSourceOptions { + addResourceOptions?: FluentBundleAddResourceOptions; +} + +interface FileSystemCreateWritableOptions { + keepExistingData?: boolean; +} + +interface FileSystemFlags { + create?: boolean; + exclusive?: boolean; +} + +interface FileSystemGetDirectoryOptions { + create?: boolean; +} + +interface FileSystemGetFileOptions { + create?: boolean; +} + +interface FileSystemReadWriteOptions { + at?: number; +} + +interface FileSystemRemoveOptions { + recursive?: boolean; +} + +interface FluentBundleAddResourceOptions { + allowOverrides?: boolean; +} + +interface FluentBundleIteratorResult { + done: boolean; + value: FluentBundle | null; +} + +interface FluentBundleOptions { + pseudoStrategy?: UTF8String; + useIsolating?: boolean; +} + +interface FluentMessage { + attributes: Record; + value?: FluentPattern | null; +} + +interface FluentTextElementItem { + attr?: UTF8String; + id?: UTF8String; + text?: UTF8String; +} + +interface FocusEventInit extends UIEventInit { + relatedTarget?: EventTarget | null; +} + +interface FocusOptions { + focusVisible?: boolean; + preventScroll?: boolean; +} + +interface FontFaceDescriptors { + ascentOverride?: UTF8String; + descentOverride?: UTF8String; + display?: UTF8String; + featureSettings?: UTF8String; + lineGapOverride?: UTF8String; + sizeAdjust?: UTF8String; + stretch?: UTF8String; + style?: UTF8String; + unicodeRange?: UTF8String; + variant?: UTF8String; + variationSettings?: UTF8String; + weight?: UTF8String; +} + +interface FontFaceSetIteratorResult { + done: boolean; + value: any; +} + +interface FontFaceSetLoadEventInit extends EventInit { + fontfaces?: FontFace[]; +} + +interface FormAutofillConfidences { + ccName?: number; + ccNumber?: number; +} + +interface FormDataEventInit extends EventInit { + formData: FormData; +} + +interface FrameCrashedEventInit extends EventInit { + browsingContextId?: number; + childID?: number; + isTopFrame?: boolean; +} + +interface GPUBindGroupDescriptor extends GPUObjectDescriptorBase { + entries: GPUBindGroupEntry[]; + layout: GPUBindGroupLayout; +} + +interface GPUBindGroupEntry { + binding: GPUIndex32; + resource: GPUBindingResource; +} + +interface GPUBindGroupLayoutDescriptor extends GPUObjectDescriptorBase { + entries: GPUBindGroupLayoutEntry[]; +} + +interface GPUBindGroupLayoutEntry { + binding: GPUIndex32; + buffer?: GPUBufferBindingLayout; + sampler?: GPUSamplerBindingLayout; + storageTexture?: GPUStorageTextureBindingLayout; + texture?: GPUTextureBindingLayout; + visibility: GPUShaderStageFlags; +} + +interface GPUBlendComponent { + dstFactor?: GPUBlendFactor; + operation?: GPUBlendOperation; + srcFactor?: GPUBlendFactor; +} + +interface GPUBlendState { + alpha: GPUBlendComponent; + color: GPUBlendComponent; +} + +interface GPUBufferBinding { + buffer: GPUBuffer; + offset?: GPUSize64; + size?: GPUSize64; +} + +interface GPUBufferBindingLayout { + hasDynamicOffset?: boolean; + minBindingSize?: GPUSize64; + type?: GPUBufferBindingType; +} + +interface GPUBufferDescriptor extends GPUObjectDescriptorBase { + mappedAtCreation?: boolean; + size: GPUSize64; + usage: GPUBufferUsageFlags; +} + +interface GPUCanvasConfiguration { + alphaMode?: GPUCanvasAlphaMode; + device: GPUDevice; + format: GPUTextureFormat; + usage?: GPUTextureUsageFlags; + viewFormats?: GPUTextureFormat[]; +} + +interface GPUColorDict { + a: number; + b: number; + g: number; + r: number; +} + +interface GPUColorTargetState { + blend?: GPUBlendState; + format: GPUTextureFormat; + writeMask?: GPUColorWriteFlags; +} + +interface GPUCommandBufferDescriptor extends GPUObjectDescriptorBase { +} + +interface GPUCommandEncoderDescriptor extends GPUObjectDescriptorBase { +} + +interface GPUComputePassDescriptor extends GPUObjectDescriptorBase { +} + +interface GPUComputePipelineDescriptor extends GPUPipelineDescriptorBase { + compute: GPUProgrammableStage; +} + +interface GPUDepthStencilState { + depthBias?: GPUDepthBias; + depthBiasClamp?: number; + depthBiasSlopeScale?: number; + depthCompare?: GPUCompareFunction; + depthWriteEnabled?: boolean; + format: GPUTextureFormat; + stencilBack?: GPUStencilFaceState; + stencilFront?: GPUStencilFaceState; + stencilReadMask?: GPUStencilValue; + stencilWriteMask?: GPUStencilValue; +} + +interface GPUDeviceDescriptor extends GPUObjectDescriptorBase { + defaultQueue?: GPUQueueDescriptor; + requiredFeatures?: GPUFeatureName[]; + requiredLimits?: Record; +} + +interface GPUExtent3DDict { + depthOrArrayLayers?: GPUIntegerCoordinate; + height?: GPUIntegerCoordinate; + width: GPUIntegerCoordinate; +} + +interface GPUFragmentState extends GPUProgrammableStage { + targets: GPUColorTargetState[]; +} + +interface GPUImageCopyBuffer extends GPUImageDataLayout { + buffer: GPUBuffer; +} + +interface GPUImageCopyExternalImage { + flipY?: boolean; + origin?: GPUOrigin2D; + source: ImageBitmap | HTMLCanvasElement | OffscreenCanvas; +} + +interface GPUImageCopyTexture { + aspect?: GPUTextureAspect; + mipLevel?: GPUIntegerCoordinate; + origin?: GPUOrigin3D; + texture: GPUTexture; +} + +interface GPUImageCopyTextureTagged extends GPUImageCopyTexture { + premultipliedAlpha?: boolean; +} + +interface GPUImageDataLayout { + bytesPerRow?: GPUSize32; + offset?: GPUSize64; + rowsPerImage?: GPUSize32; +} + +interface GPUMultisampleState { + alphaToCoverageEnabled?: boolean; + count?: GPUSize32; + mask?: GPUSampleMask; +} + +interface GPUObjectDescriptorBase { + label?: string; +} + +interface GPUOrigin2DDict { + x?: GPUIntegerCoordinate; + y?: GPUIntegerCoordinate; +} + +interface GPUOrigin3DDict { + x?: GPUIntegerCoordinate; + y?: GPUIntegerCoordinate; + z?: GPUIntegerCoordinate; +} + +interface GPUPipelineDescriptorBase extends GPUObjectDescriptorBase { + layout: GPUPipelineLayout | GPUAutoLayoutMode; +} + +interface GPUPipelineLayoutDescriptor extends GPUObjectDescriptorBase { + bindGroupLayouts: GPUBindGroupLayout[]; +} + +interface GPUPrimitiveState { + cullMode?: GPUCullMode; + frontFace?: GPUFrontFace; + stripIndexFormat?: GPUIndexFormat; + topology?: GPUPrimitiveTopology; + unclippedDepth?: boolean; +} + +interface GPUProgrammableStage { + entryPoint: string; + module: GPUShaderModule; +} + +interface GPUQueueDescriptor extends GPUObjectDescriptorBase { +} + +interface GPURenderBundleDescriptor extends GPUObjectDescriptorBase { +} + +interface GPURenderBundleEncoderDescriptor extends GPURenderPassLayout { + depthReadOnly?: boolean; + stencilReadOnly?: boolean; +} + +interface GPURenderPassColorAttachment { + clearValue?: GPUColor; + loadOp: GPULoadOp; + resolveTarget?: GPUTextureView; + storeOp: GPUStoreOp; + view: GPUTextureView; +} + +interface GPURenderPassDepthStencilAttachment { + depthClearValue?: number; + depthLoadOp?: GPULoadOp; + depthReadOnly?: boolean; + depthStoreOp?: GPUStoreOp; + stencilClearValue?: GPUStencilValue; + stencilLoadOp?: GPULoadOp; + stencilReadOnly?: boolean; + stencilStoreOp?: GPUStoreOp; + view: GPUTextureView; +} + +interface GPURenderPassDescriptor extends GPUObjectDescriptorBase { + colorAttachments: GPURenderPassColorAttachment[]; + depthStencilAttachment?: GPURenderPassDepthStencilAttachment; + occlusionQuerySet?: GPUQuerySet; +} + +interface GPURenderPassLayout extends GPUObjectDescriptorBase { + colorFormats: GPUTextureFormat[]; + depthStencilFormat?: GPUTextureFormat; + sampleCount?: GPUSize32; +} + +interface GPURenderPipelineDescriptor extends GPUPipelineDescriptorBase { + depthStencil?: GPUDepthStencilState; + fragment?: GPUFragmentState; + multisample?: GPUMultisampleState; + primitive?: GPUPrimitiveState; + vertex: GPUVertexState; +} + +interface GPURequestAdapterOptions { + forceFallbackAdapter?: boolean; + powerPreference?: GPUPowerPreference; +} + +interface GPUSamplerBindingLayout { + type?: GPUSamplerBindingType; +} + +interface GPUSamplerDescriptor extends GPUObjectDescriptorBase { + addressModeU?: GPUAddressMode; + addressModeV?: GPUAddressMode; + addressModeW?: GPUAddressMode; + compare?: GPUCompareFunction; + lodMaxClamp?: number; + lodMinClamp?: number; + magFilter?: GPUFilterMode; + maxAnisotropy?: number; + minFilter?: GPUFilterMode; + mipmapFilter?: GPUMipmapFilterMode; +} + +interface GPUShaderModuleDescriptor extends GPUObjectDescriptorBase { + code: UTF8String; + sourceMap?: any; +} + +interface GPUStencilFaceState { + compare?: GPUCompareFunction; + depthFailOp?: GPUStencilOperation; + failOp?: GPUStencilOperation; + passOp?: GPUStencilOperation; +} + +interface GPUStorageTextureBindingLayout { + access?: GPUStorageTextureAccess; + format: GPUTextureFormat; + viewDimension?: GPUTextureViewDimension; +} + +interface GPUTextureBindingLayout { + multisampled?: boolean; + sampleType?: GPUTextureSampleType; + viewDimension?: GPUTextureViewDimension; +} + +interface GPUTextureDescriptor extends GPUObjectDescriptorBase { + dimension?: GPUTextureDimension; + format: GPUTextureFormat; + mipLevelCount?: GPUIntegerCoordinate; + sampleCount?: GPUSize32; + size: GPUExtent3D; + usage: GPUTextureUsageFlags; + viewFormats?: GPUTextureFormat[]; +} + +interface GPUTextureViewDescriptor extends GPUObjectDescriptorBase { + arrayLayerCount?: GPUIntegerCoordinate; + aspect?: GPUTextureAspect; + baseArrayLayer?: GPUIntegerCoordinate; + baseMipLevel?: GPUIntegerCoordinate; + dimension?: GPUTextureViewDimension; + format?: GPUTextureFormat; + mipLevelCount?: GPUIntegerCoordinate; +} + +interface GPUUncapturedErrorEventInit extends EventInit { + error: GPUError; +} + +interface GPUVertexAttribute { + format: GPUVertexFormat; + offset: GPUSize64; + shaderLocation: GPUIndex32; +} + +interface GPUVertexBufferLayout { + arrayStride: GPUSize64; + attributes: GPUVertexAttribute[]; + stepMode?: GPUVertexStepMode; +} + +interface GPUVertexState extends GPUProgrammableStage { + buffers?: (GPUVertexBufferLayout | null)[]; +} + +interface GainOptions extends AudioNodeOptions { + gain?: number; +} + +interface GamepadAxisMoveEventInit extends GamepadEventInit { + axis?: number; + value?: number; +} + +interface GamepadButtonEventInit extends GamepadEventInit { + button?: number; +} + +interface GamepadEventInit extends EventInit { + gamepad?: Gamepad | null; +} + +interface GamepadLightColor { + blue: number; + green: number; + red: number; +} + +interface GetAnimationsOptions { + subtree?: boolean; +} + +interface GetChildrenOptions { + ignoreAbsent?: boolean; +} + +interface GetNotificationOptions { + tag?: string; +} + +interface GetRootNodeOptions { + composed?: boolean; +} + +interface GleanDistributionData { + sum: number; + values: Record; +} + +interface GleanEventRecord { + category: UTF8String; + extra?: Record; + name: UTF8String; + timestamp: number; +} + +interface GleanRateData { + denominator: number; + numerator: number; +} + +interface HTMLMediaElementDebugInfo { + EMEInfo?: EMEDebugInfo; + compositorDroppedFrames?: number; + decoder?: MediaDecoderDebugInfo; +} + +interface HashChangeEventInit extends EventInit { + newURL?: string; + oldURL?: string; +} + +interface HeapSnapshotBoundaries { + debugger?: any; + globals?: any[]; + runtime?: boolean; +} + +interface IDBIndexParameters { + locale?: string | null; + multiEntry?: boolean; + unique?: boolean; +} + +interface IDBObjectStoreParameters { + autoIncrement?: boolean; + keyPath?: string | string[] | null; +} + +interface IDBOpenDBOptions { + version?: number; +} + +interface IDBVersionChangeEventInit extends EventInit { + newVersion?: number | null; + oldVersion?: number; +} + +interface IIRFilterOptions extends AudioNodeOptions { + feedback: number[]; + feedforward: number[]; +} + +interface IOActivityDataDictionary { + location?: string; + rx?: number; + tx?: number; +} + +interface IdentityCredentialLogoutRPsRequest { + accountId: UTF8String; + url: UTF8String; +} + +interface IdentityCredentialRequestOptions { + providers?: IdentityProviderConfig[]; +} + +interface IdentityProviderConfig { + clientId: string; + configURL: UTF8String; + nonce?: string; +} + +interface IdleRequestOptions { + timeout?: number; +} + +interface ImageBitmapOptions { + colorSpaceConversion?: ColorSpaceConversion; + imageOrientation?: ImageOrientation; + premultiplyAlpha?: PremultiplyAlpha; + resizeHeight?: number; + resizeWidth?: number; +} + +interface ImageCaptureErrorEventInit extends EventInit { + imageCaptureError?: ImageCaptureError | null; +} + +interface ImageEncodeOptions { + quality?: number; + type?: string; +} + +interface ImageText { + confidence: number; + quad: DOMQuad; + string: string; +} + +interface ImportESModuleOptionsDictionary { + loadInDevToolsLoader?: boolean; +} + +interface InputEventInit extends UIEventInit { + data?: string | null; + dataTransfer?: DataTransfer | null; + inputType?: string; + isComposing?: boolean; + targetRanges?: StaticRange[]; +} + +interface InspectorCSSPropertyDefinition { + fromJS: boolean; + inherits: boolean; + initialValue: UTF8String | null; + name: UTF8String; + syntax: UTF8String; +} + +interface InspectorFontFeature { + languageSystem: string; + script: string; + tag: string; +} + +interface InspectorRGBATuple { + a?: number; + b?: number; + g?: number; + r?: number; +} + +interface InspectorVariationAxis { + defaultValue: number; + maxValue: number; + minValue: number; + name: string; + tag: string; +} + +interface InspectorVariationInstance { + name: string; + values: InspectorVariationValue[]; +} + +interface InspectorVariationValue { + axis: string; + value: number; +} + +interface InstallTriggerData { + Hash?: string | null; + IconURL?: string | null; + URL?: string; +} + +interface InteractionData { + interactionCount?: number; + interactionTimeInMilliseconds?: number; + scrollingDistanceInPixels?: number; +} + +interface IntersectionObserverInit { + root?: Element | Document | null; + rootMargin?: UTF8String; + threshold?: number | number[]; +} + +interface InvokeEventInit extends EventInit { + action?: string; + invoker?: Element | null; +} + +interface KeyboardEventInit extends EventModifierInit { + charCode?: number; + code?: string; + isComposing?: boolean; + key?: string; + keyCode?: number; + location?: number; + repeat?: boolean; + which?: number; +} + +interface KeyframeAnimationOptions extends KeyframeEffectOptions { + id?: string; +} + +interface KeyframeEffectOptions extends EffectTiming { + composite?: CompositeOperation; + iterationComposite?: IterationCompositeOperation; + pseudoElement?: string | null; +} + +interface L10nFileSourceMockFile { + path: UTF8String; + source: UTF8String; +} + +interface L10nIdArgs { + args?: L10nArgs | null; + id?: UTF8String | null; +} + +interface L10nMessage { + attributes?: AttributeNameValue[] | null; + value?: UTF8String | null; +} + +interface L10nOverlaysError { + code?: number; + l10nName?: string; + sourceElementName?: string; + translatedElementName?: string; +} + +interface L10nRegistryOptions { + bundleOptions?: FluentBundleOptions; +} + +interface LaunchOptions { + disclaim?: boolean; + environment: UnixString[]; + fdMap?: FdMapping[]; + workdir?: UnixString; +} + +interface LibcConstants { + AT_EACCESS?: number; + EACCES?: number; + EAGAIN?: number; + EINTR?: number; + EINVAL?: number; + ENOSYS?: number; + FD_CLOEXEC?: number; + F_SETFD?: number; + F_SETFL?: number; + O_CREAT?: number; + O_NONBLOCK?: number; + O_WRONLY?: number; + POLLERR?: number; + POLLHUP?: number; + POLLIN?: number; + POLLNVAL?: number; + POLLOUT?: number; + PR_CAPBSET_READ?: number; + WNOHANG?: number; +} + +interface LoadURIOptions { + baseURI?: URI | null; + cancelContentJSEpoch?: number; + csp?: ContentSecurityPolicy | null; + hasValidUserGestureActivation?: boolean; + headers?: InputStream | null; + loadFlags?: number; + postData?: InputStream | null; + referrerInfo?: ReferrerInfo | null; + remoteTypeOverride?: UTF8String | null; + triggeringPrincipal?: Principal | null; + triggeringRemoteType?: UTF8String | null; + triggeringSandboxFlags?: number; + triggeringStorageAccess?: boolean; + triggeringWindowId?: number; + wasSchemelessInput?: boolean; +} + +interface LockInfo { + clientId?: string; + mode?: LockMode; + name?: string; +} + +interface LockManagerSnapshot { + held?: LockInfo[]; + pending?: LockInfo[]; +} + +interface LockOptions { + ifAvailable?: boolean; + mode?: LockMode; + signal?: AbortSignal; + steal?: boolean; +} + +interface MIDIConnectionEventInit extends EventInit { + port?: MIDIPort | null; +} + +interface MIDIMessageEventInit extends EventInit { + data?: Uint8Array; +} + +interface MIDIOptions { + software?: boolean; + sysex?: boolean; +} + +interface MakeDirectoryOptions { + createAncestors?: boolean; + ignoreExisting?: boolean; + permissions?: number; +} + +interface MatchPatternOptions { + ignorePath?: boolean; + restrictSchemes?: boolean; +} + +interface MediaCacheStreamDebugInfo { + cacheSuspended?: boolean; + channelEnded?: boolean; + channelOffset?: number; + loadID?: number; + streamLength?: number; +} + +interface MediaConfiguration { + audio?: AudioConfiguration; + video?: VideoConfiguration; +} + +interface MediaDecoderDebugInfo { + PlayState?: string; + channels?: number; + containerType?: string; + hasAudio?: boolean; + hasVideo?: boolean; + instance?: string; + rate?: number; + reader?: MediaFormatReaderDebugInfo; + resource?: MediaResourceDebugInfo; + stateMachine?: MediaDecoderStateMachineDebugInfo; +} + +interface MediaDecoderStateMachineDebugInfo { + audioCompleted?: boolean; + audioRequestStatus?: string; + clock?: number; + decodedAudioEndTime?: number; + decodedVideoEndTime?: number; + duration?: number; + isPlaying?: boolean; + mediaSink?: MediaSinkDebugInfo; + mediaTime?: number; + playState?: number; + sentFirstFrameLoadedEvent?: boolean; + state?: string; + stateObj?: MediaDecoderStateMachineDecodingStateDebugInfo; + videoCompleted?: boolean; + videoRequestStatus?: string; +} + +interface MediaDecoderStateMachineDecodingStateDebugInfo { + isPrerolling?: boolean; +} + +interface MediaDecodingConfiguration extends MediaConfiguration { + type: MediaDecodingType; +} + +interface MediaElementAudioSourceOptions { + mediaElement: HTMLMediaElement; +} + +interface MediaEncodingConfiguration extends MediaConfiguration { + type: MediaEncodingType; +} + +interface MediaFormatReaderDebugInfo { + audioChannels?: number; + audioDecoderName?: string; + audioFramesDecoded?: number; + audioRate?: number; + audioState?: MediaStateDebugInfo; + audioType?: string; + frameStats?: MediaFrameStats; + videoDecoderName?: string; + videoHardwareAccelerated?: boolean; + videoHeight?: number; + videoNumSamplesOutputTotal?: number; + videoNumSamplesSkippedTotal?: number; + videoRate?: number; + videoState?: MediaStateDebugInfo; + videoType?: string; + videoWidth?: number; +} + +interface MediaFrameStats { + droppedCompositorFrames?: number; + droppedDecodedFrames?: number; + droppedSinkFrames?: number; +} + +interface MediaImage { + sizes?: string; + src: string; + type?: string; +} + +interface MediaKeyMessageEventInit extends EventInit { + message: ArrayBuffer; + messageType: MediaKeyMessageType; +} + +interface MediaKeyNeededEventInit extends EventInit { + initData?: ArrayBuffer | null; + initDataType?: string; +} + +interface MediaKeySystemConfiguration { + audioCapabilities?: MediaKeySystemMediaCapability[]; + distinctiveIdentifier?: MediaKeysRequirement; + initDataTypes?: string[]; + label?: string; + persistentState?: MediaKeysRequirement; + sessionTypes?: string[]; + videoCapabilities?: MediaKeySystemMediaCapability[]; +} + +interface MediaKeySystemMediaCapability { + contentType?: string; + encryptionScheme?: string | null; + robustness?: string; +} + +interface MediaKeysPolicy { + minHdcpVersion?: string; +} + +interface MediaMetadataInit { + album?: string; + artist?: string; + artwork?: MediaImage[]; + title?: string; +} + +interface MediaPositionState { + duration?: number; + playbackRate?: number; + position?: number; +} + +interface MediaQueryListEventInit extends EventInit { + matches?: boolean; + media?: UTF8String; +} + +interface MediaRecorderErrorEventInit extends EventInit { + error: DOMException; +} + +interface MediaRecorderOptions { + audioBitsPerSecond?: number; + bitsPerSecond?: number; + mimeType?: string; + videoBitsPerSecond?: number; +} + +interface MediaResourceDebugInfo { + cacheStream?: MediaCacheStreamDebugInfo; +} + +interface MediaSessionActionDetails { + action: MediaSessionAction; + fastSeek?: boolean; + seekOffset?: number; + seekTime?: number; +} + +interface MediaSinkDebugInfo { + audioSinkWrapper?: AudioSinkWrapperDebugInfo; + decodedStream?: DecodedStreamDebugInfo; + videoSink?: VideoSinkDebugInfo; +} + +interface MediaSourceDecoderDebugInfo { + demuxer?: MediaSourceDemuxerDebugInfo; + reader?: MediaFormatReaderDebugInfo; +} + +interface MediaSourceDemuxerDebugInfo { + audioTrack?: TrackBuffersManagerDebugInfo; + videoTrack?: TrackBuffersManagerDebugInfo; +} + +interface MediaStateDebugInfo { + demuxEOS?: number; + demuxQueueSize?: number; + drainState?: number; + hasDecoder?: boolean; + hasDemuxRequest?: boolean; + hasPromise?: boolean; + lastStreamSourceID?: number; + needInput?: boolean; + numSamplesInput?: number; + numSamplesOutput?: number; + pending?: number; + queueSize?: number; + timeTreshold?: number; + timeTresholdHasSeeked?: boolean; + waitingForData?: boolean; + waitingForKey?: boolean; + waitingPromise?: boolean; +} + +interface MediaStreamAudioSourceOptions { + mediaStream: MediaStream; +} + +interface MediaStreamConstraints { + audio?: boolean | MediaTrackConstraints; + fake?: boolean; + peerIdentity?: string | null; + picture?: boolean; + video?: boolean | MediaTrackConstraints; +} + +interface MediaStreamEventInit extends EventInit { + stream?: MediaStream | null; +} + +interface MediaStreamTrackAudioSourceOptions { + mediaStreamTrack: MediaStreamTrack; +} + +interface MediaStreamTrackEventInit extends EventInit { + track: MediaStreamTrack; +} + +interface MediaTrackConstraintSet { + autoGainControl?: ConstrainBoolean; + browserWindow?: number; + channelCount?: ConstrainLong; + deviceId?: ConstrainDOMString; + echoCancellation?: ConstrainBoolean; + facingMode?: ConstrainDOMString; + frameRate?: ConstrainDouble; + groupId?: ConstrainDOMString; + height?: ConstrainLong; + mediaSource?: string; + noiseSuppression?: ConstrainBoolean; + scrollWithPage?: boolean; + viewportHeight?: ConstrainLong; + viewportOffsetX?: ConstrainLong; + viewportOffsetY?: ConstrainLong; + viewportWidth?: ConstrainLong; + width?: ConstrainLong; +} + +interface MediaTrackConstraints extends MediaTrackConstraintSet { + advanced?: MediaTrackConstraintSet[]; +} + +interface MediaTrackSettings { + autoGainControl?: boolean; + browserWindow?: number; + channelCount?: number; + deviceId?: string; + echoCancellation?: boolean; + facingMode?: string; + frameRate?: number; + groupId?: string; + height?: number; + mediaSource?: string; + noiseSuppression?: boolean; + scrollWithPage?: boolean; + viewportHeight?: number; + viewportOffsetX?: number; + viewportOffsetY?: number; + viewportWidth?: number; + width?: number; +} + +interface MediaTrackSupportedConstraints { + aspectRatio?: boolean; + autoGainControl?: boolean; + browserWindow?: boolean; + channelCount?: boolean; + deviceId?: boolean; + echoCancellation?: boolean; + facingMode?: boolean; + frameRate?: boolean; + groupId?: boolean; + height?: boolean; + latency?: boolean; + mediaSource?: boolean; + noiseSuppression?: boolean; + sampleRate?: boolean; + sampleSize?: boolean; + scrollWithPage?: boolean; + viewportHeight?: boolean; + viewportOffsetX?: boolean; + viewportOffsetY?: boolean; + viewportWidth?: boolean; + volume?: boolean; + width?: boolean; +} + +interface MerchantValidationEventInit extends EventInit { + methodName?: string; + validationURL?: string; +} + +interface MessageEventInit extends EventInit { + data?: any; + lastEventId?: string; + origin?: string; + ports?: MessagePort[]; + source?: MessageEventSource | null; +} + +interface MouseEventInit extends EventModifierInit { + button?: number; + buttons?: number; + clientX?: number; + clientY?: number; + movementX?: number; + movementY?: number; + relatedTarget?: EventTarget | null; + screenX?: number; + screenY?: number; +} + +interface MoveOptions { + noOverwrite?: boolean; +} + +interface MozApplicationEventInit extends EventInit { + application?: DOMApplication | null; +} + +interface MozDocumentMatcherInit { + allFrames?: boolean; + checkPermissions?: boolean; + excludeGlobs?: MatchGlobOrString[] | null; + excludeMatches?: MatchPatternSetOrStringSequence | null; + frameID?: number | null; + hasActiveTabPermission?: boolean; + includeGlobs?: MatchGlobOrString[] | null; + matchAboutBlank?: boolean; + matches: MatchPatternSetOrStringSequence; + originAttributesPatterns?: OriginAttributesPatternDictionary[] | null; +} + +interface MozFrameAncestorInfo { + frameId: number; + url: string; +} + +interface MozHTTPHeader { + name: string; + value: string; +} + +interface MozPluginParameter { + name?: string; + value?: string; +} + +interface MozProxyInfo { + connectionIsolationKey?: string | null; + failoverTimeout?: number; + host: string; + port: number; + proxyAuthorizationHeader?: string | null; + proxyDNS: boolean; + type: string; + username?: string | null; +} + +interface MozRequestFilter { + incognito?: boolean | null; + types?: MozContentPolicyType[] | null; + urls?: MatchPatternSet | null; +} + +interface MozRequestMatchOptions { + isProxy?: boolean; +} + +interface MozUrlClassification { + firstParty: MozUrlClassificationFlags[]; + thirdParty: MozUrlClassificationFlags[]; +} + +interface MozXMLHttpRequestParameters { + mozAnon?: boolean; + mozSystem?: boolean; +} + +interface MultiCacheQueryOptions extends CacheQueryOptions { + cacheName?: string; +} + +interface MutationObserverInit { + animations?: boolean; + attributeFilter?: string[]; + attributeOldValue?: boolean; + attributes?: boolean; + characterData?: boolean; + characterDataOldValue?: boolean; + childList?: boolean; + chromeOnlyNodes?: boolean; + subtree?: boolean; +} + +interface MutationObservingInfo extends MutationObserverInit { + observedNode?: Node | null; +} + +interface NavigationPreloadState { + enabled?: boolean; + headerValue?: string; +} + +interface NetErrorInfo { + errorCodeString?: string; +} + +interface NotificationBehavior { + noclear?: boolean; + noscreen?: boolean; + showOnlyOnce?: boolean; + soundFile?: string; + vibrationPattern?: number[]; +} + +interface NotificationEventInit extends ExtendableEventInit { + notification: Notification; +} + +interface NotificationOptions { + body?: string; + data?: any; + dir?: NotificationDirection; + icon?: string; + lang?: string; + mozbehavior?: NotificationBehavior; + requireInteraction?: boolean; + silent?: boolean; + tag?: string; + vibrate?: VibratePattern; +} + +interface ObservableArrayCallbacks { + deleteBooleanCallback?: SetDeleteBooleanCallback; + deleteInterfaceCallback?: SetDeleteInterfaceCallback; + deleteObjectCallback?: SetDeleteObjectCallback; + setBooleanCallback?: SetDeleteBooleanCallback; + setInterfaceCallback?: SetDeleteInterfaceCallback; + setObjectCallback?: SetDeleteObjectCallback; +} + +interface OfflineAudioCompletionEventInit extends EventInit { + renderedBuffer: AudioBuffer; +} + +interface OfflineAudioContextOptions { + length: number; + numberOfChannels?: number; + sampleRate: number; +} + +interface OpenPopupOptions { + attributesOverride?: boolean; + isContextMenu?: boolean; + position?: string; + triggerEvent?: Event | null; + x?: number; + y?: number; +} + +interface OptionalEffectTiming { + delay?: number; + direction?: PlaybackDirection; + duration?: number | string; + easing?: UTF8String; + endDelay?: number; + fill?: FillMode; + iterationStart?: number; + iterations?: number; +} + +interface OriginAttributesDictionary { + firstPartyDomain?: string; + geckoViewSessionContextId?: string; + inIsolatedMozBrowser?: boolean; + partitionKey?: string; + privateBrowsingId?: number; + userContextId?: number; +} + +interface OriginAttributesPatternDictionary { + firstPartyDomain?: string; + geckoViewSessionContextId?: string; + inIsolatedMozBrowser?: boolean; + partitionKey?: string; + partitionKeyPattern?: PartitionKeyPatternDictionary; + privateBrowsingId?: number; + userContextId?: number; +} + +interface OscillatorOptions extends AudioNodeOptions { + detune?: number; + frequency?: number; + periodicWave?: PeriodicWave; + type?: OscillatorType; +} + +interface PCErrorData { + message: string; + name: PCError; +} + +interface PageTransitionEventInit extends EventInit { + inFrameSwap?: boolean; + persisted?: boolean; +} + +interface PannerOptions extends AudioNodeOptions { + coneInnerAngle?: number; + coneOuterAngle?: number; + coneOuterGain?: number; + distanceModel?: DistanceModelType; + maxDistance?: number; + orientationX?: number; + orientationY?: number; + orientationZ?: number; + panningModel?: PanningModelType; + positionX?: number; + positionY?: number; + positionZ?: number; + refDistance?: number; + rolloffFactor?: number; +} + +interface ParentProcInfoDictionary { + children?: ChildProcInfoDictionary[]; + cpuCycleCount?: number; + cpuTime?: number; + memory?: number; + pid?: number; + threads?: ThreadInfoDictionary[]; + type?: WebIDLProcType; +} + +interface PartitionKeyPatternDictionary { + baseDomain?: string; + port?: number; + scheme?: string; +} + +interface PayerErrors { + email?: string; + name?: string; + phone?: string; +} + +interface PaymentCurrencyAmount { + currency: string; + value: string; +} + +interface PaymentDetailsBase { + displayItems?: PaymentItem[]; + modifiers?: PaymentDetailsModifier[]; + shippingOptions?: PaymentShippingOption[]; +} + +interface PaymentDetailsInit extends PaymentDetailsBase { + id?: string; + total: PaymentItem; +} + +interface PaymentDetailsModifier { + additionalDisplayItems?: PaymentItem[]; + data?: any; + supportedMethods: string; + total?: PaymentItem; +} + +interface PaymentDetailsUpdate extends PaymentDetailsBase { + error?: string; + payerErrors?: PayerErrors; + paymentMethodErrors?: any; + shippingAddressErrors?: AddressErrors; + total?: PaymentItem; +} + +interface PaymentItem { + amount: PaymentCurrencyAmount; + label: string; + pending?: boolean; +} + +interface PaymentMethodChangeEventInit extends PaymentRequestUpdateEventInit { + methodDetails?: any; + methodName?: string; +} + +interface PaymentMethodData { + data?: any; + supportedMethods: string; +} + +interface PaymentOptions { + requestBillingAddress?: boolean; + requestPayerEmail?: boolean; + requestPayerName?: boolean; + requestPayerPhone?: boolean; + requestShipping?: boolean; + shippingType?: PaymentShippingType; +} + +interface PaymentRequestUpdateEventInit extends EventInit { +} + +interface PaymentShippingOption { + amount: PaymentCurrencyAmount; + id: string; + label: string; + selected?: boolean; +} + +interface PaymentValidationErrors { + error?: string; + payer?: PayerErrors; + paymentMethod?: any; + shippingAddress?: AddressErrors; +} + +interface PerformanceEntryEventInit extends EventInit { + duration?: DOMHighResTimeStamp; + entryType?: string; + epoch?: number; + name?: string; + origin?: string; + startTime?: DOMHighResTimeStamp; +} + +interface PerformanceEntryFilterOptions { + entryType?: string; + initiatorType?: string; + name?: string; +} + +interface PerformanceMarkOptions { + detail?: any; + startTime?: DOMHighResTimeStamp; +} + +interface PerformanceMeasureOptions { + detail?: any; + duration?: DOMHighResTimeStamp; + end?: string | DOMHighResTimeStamp; + start?: string | DOMHighResTimeStamp; +} + +interface PerformanceObserverInit { + buffered?: boolean; + durationThreshold?: DOMHighResTimeStamp; + entryTypes?: string[]; + type?: string; +} + +interface PeriodicWaveConstraints { + disableNormalization?: boolean; +} + +interface PeriodicWaveOptions extends PeriodicWaveConstraints { + imag?: number[] | Float32Array; + real?: number[] | Float32Array; +} + +interface PlacesBookmarkAdditionInit { + dateAdded: number; + frecency: number; + guid: string; + hidden: boolean; + id: number; + index: number; + isTagging: boolean; + itemType: number; + lastVisitDate: number | null; + parentGuid: string; + parentId: number; + source: number; + tags: string | null; + targetFolderGuid: string | null; + targetFolderItemId: number; + targetFolderTitle: string | null; + title: string; + url: string; + visitCount: number; +} + +interface PlacesBookmarkGuidInit { + guid: string; + id: number; + isTagging: boolean; + itemType: number; + lastModified: number; + parentGuid: string; + source: number; + url?: string | null; +} + +interface PlacesBookmarkKeywordInit { + guid: string; + id: number; + isTagging: boolean; + itemType: number; + keyword: string; + lastModified: number; + parentGuid: string; + source: number; + url?: string | null; +} + +interface PlacesBookmarkMovedInit { + dateAdded: number; + frecency: number; + guid: string; + hidden: boolean; + id: number; + index: number; + isTagging: boolean; + itemType: number; + lastVisitDate: number | null; + oldIndex: number; + oldParentGuid: string; + parentGuid: string; + source: number; + tags: string | null; + title: string; + url?: string | null; + visitCount: number; +} + +interface PlacesBookmarkRemovedInit { + guid: string; + id: number; + index: number; + isDescendantRemoval?: boolean; + isTagging: boolean; + itemType: number; + parentGuid: string; + parentId: number; + source: number; + title: string; + url: string; +} + +interface PlacesBookmarkTagsInit { + guid: string; + id: number; + isTagging: boolean; + itemType: number; + lastModified: number; + parentGuid: string; + source: number; + tags: string[]; + url?: string | null; +} + +interface PlacesBookmarkTimeInit { + dateAdded: number; + guid: string; + id: number; + isTagging: boolean; + itemType: number; + lastModified: number; + parentGuid: string; + source: number; + url?: string | null; +} + +interface PlacesBookmarkTitleInit { + guid: string; + id: number; + isTagging: boolean; + itemType: number; + lastModified: number; + parentGuid: string; + source: number; + title: string; + url?: string | null; +} + +interface PlacesBookmarkUrlInit { + guid: string; + id: number; + isTagging: boolean; + itemType: number; + lastModified: number; + parentGuid: string; + source: number; + url: string; +} + +interface PlacesFaviconInit { + faviconUrl: string; + pageGuid: string; + url: string; +} + +interface PlacesVisitRemovedInit { + isPartialVisistsRemoval?: boolean; + isRemovedFromStore?: boolean; + pageGuid: string; + reason: number; + transitionType?: number; + url: string; +} + +interface PlacesVisitTitleInit { + pageGuid: string; + title: string; + url: string; +} + +interface PlaneLayout { + offset: number; + stride: number; +} + +interface PluginCrashedEventInit extends EventInit { + gmpPlugin?: boolean; + pluginDumpID?: string; + pluginFilename?: string | null; + pluginID?: number; + pluginName?: string; + submittedCrashReport?: boolean; +} + +interface PointerEventInit extends MouseEventInit { + coalescedEvents?: PointerEvent[]; + height?: number; + isPrimary?: boolean; + pointerId?: number; + pointerType?: string; + predictedEvents?: PointerEvent[]; + pressure?: number; + tangentialPressure?: number; + tiltX?: number; + tiltY?: number; + twist?: number; + width?: number; +} + +interface PopStateEventInit extends EventInit { + state?: any; +} + +interface PopupBlockedEventInit extends EventInit { + popupWindowFeatures?: string; + popupWindowName?: string; + popupWindowURI?: URI | null; + requestingWindow?: Window | null; +} + +interface PopupPositionedEventInit extends EventInit { + alignmentOffset?: number; + alignmentPosition?: string; + isAnchored?: boolean; + popupAlignment?: string; +} + +interface PositionOptions { + enableHighAccuracy?: boolean; + maximumAge?: number; + timeout?: number; +} + +interface PositionStateEventInit extends EventInit { + duration: number; + playbackRate: number; + position: number; +} + +interface ProcessActorChildOptions extends ProcessActorSidedOptions { + observers?: string[]; +} + +interface ProcessActorOptions { + child?: ProcessActorChildOptions; + includeParent?: boolean; + loadInDevToolsLoader?: boolean; + parent?: ProcessActorSidedOptions; + remoteTypes?: UTF8String[]; +} + +interface ProcessActorSidedOptions { + esModuleURI?: string; + moduleURI?: string; +} + +interface ProfilerMarkerOptions { + captureStack?: boolean; + category?: string; + innerWindowId?: number; + startTime?: DOMHighResTimeStamp; +} + +interface ProgressEventInit extends EventInit { + lengthComputable?: boolean; + loaded?: number; + total?: number; +} + +interface PromiseDebuggingStateHolder { + reason?: any; + state?: PromiseDebuggingState; + value?: any; +} + +interface PromiseRejectionEventInit extends EventInit { + promise: Promise; + reason?: any; +} + +interface PropertyDefinition { + inherits: boolean; + initialValue?: UTF8String; + name: UTF8String; + syntax?: UTF8String; +} + +interface PropertyNamesOptions { + includeAliases?: boolean; + includeExperimentals?: boolean; + includeShorthands?: boolean; +} + +interface PropertyPref { + name: string; + pref: string; +} + +interface PublicKeyCredentialCreationOptions { + attestation?: string; + authenticatorSelection?: AuthenticatorSelectionCriteria; + challenge: BufferSource; + excludeCredentials?: PublicKeyCredentialDescriptor[]; + extensions?: AuthenticationExtensionsClientInputs; + pubKeyCredParams: PublicKeyCredentialParameters[]; + rp: PublicKeyCredentialRpEntity; + timeout?: number; + user: PublicKeyCredentialUserEntity; +} + +interface PublicKeyCredentialCreationOptionsJSON { + attestation?: string; + attestationFormats?: string[]; + authenticatorSelection?: AuthenticatorSelectionCriteria; + challenge: Base64URLString; + excludeCredentials?: PublicKeyCredentialDescriptorJSON[]; + extensions?: AuthenticationExtensionsClientInputsJSON; + hints?: string[]; + pubKeyCredParams: PublicKeyCredentialParameters[]; + rp: PublicKeyCredentialRpEntity; + timeout?: number; + user: PublicKeyCredentialUserEntityJSON; +} + +interface PublicKeyCredentialDescriptor { + id: BufferSource; + transports?: string[]; + type: string; +} + +interface PublicKeyCredentialDescriptorJSON { + id: Base64URLString; + transports?: string[]; + type: string; +} + +interface PublicKeyCredentialEntity { + name: string; +} + +interface PublicKeyCredentialParameters { + alg: COSEAlgorithmIdentifier; + type: string; +} + +interface PublicKeyCredentialRequestOptions { + allowCredentials?: PublicKeyCredentialDescriptor[]; + challenge: BufferSource; + extensions?: AuthenticationExtensionsClientInputs; + rpId?: string; + timeout?: number; + userVerification?: string; +} + +interface PublicKeyCredentialRequestOptionsJSON { + allowCredentials?: PublicKeyCredentialDescriptorJSON[]; + attestation?: string; + attestationFormats?: string[]; + challenge: Base64URLString; + extensions?: AuthenticationExtensionsClientInputsJSON; + hints?: string[]; + rpId?: string; + timeout?: number; + userVerification?: string; +} + +interface PublicKeyCredentialRpEntity extends PublicKeyCredentialEntity { + id?: string; +} + +interface PublicKeyCredentialUserEntity extends PublicKeyCredentialEntity { + displayName: string; + id: BufferSource; +} + +interface PublicKeyCredentialUserEntityJSON { + displayName: string; + id: Base64URLString; + name: string; +} + +interface PushEventInit extends ExtendableEventInit { + data?: PushMessageDataInit; +} + +interface PushSubscriptionInit { + appServerKey?: BufferSource | null; + authSecret?: ArrayBuffer | null; + endpoint: string; + expirationTime?: EpochTimeStamp | null; + p256dhKey?: ArrayBuffer | null; + scope: string; +} + +interface PushSubscriptionJSON { + endpoint?: string; + expirationTime?: EpochTimeStamp | null; + keys?: PushSubscriptionKeys; +} + +interface PushSubscriptionKeys { + auth?: string; + p256dh?: string; +} + +interface PushSubscriptionOptionsInit { + applicationServerKey?: BufferSource | string | null; +} + +interface QueuingStrategy { + highWaterMark?: number; + size?: QueuingStrategySize; +} + +interface QueuingStrategyInit { + highWaterMark: number; +} + +interface RTCBandwidthEstimationInternal { + maxPaddingBps?: number; + pacerDelayMs?: number; + receiveBandwidthBps?: number; + rttMs?: number; + sendBandwidthBps?: number; + trackIdentifier: string; +} + +interface RTCCodecStats extends RTCStats { + channels?: number; + clockRate?: number; + codecType?: RTCCodecType; + mimeType: string; + payloadType: number; + sdpFmtpLine?: string; + transportId: string; +} + +interface RTCConfiguration { + bundlePolicy?: RTCBundlePolicy; + certificates?: RTCCertificate[]; + iceServers?: RTCIceServer[]; + iceTransportPolicy?: RTCIceTransportPolicy; + peerIdentity?: string | null; + sdpSemantics?: string; +} + +interface RTCConfigurationInternal { + bundlePolicy?: RTCBundlePolicy; + certificatesProvided: boolean; + iceServers?: RTCIceServerInternal[]; + iceTransportPolicy?: RTCIceTransportPolicy; + peerIdentityProvided: boolean; + sdpSemantics?: string; +} + +interface RTCDTMFToneChangeEventInit extends EventInit { + tone?: string; +} + +interface RTCDataChannelEventInit extends EventInit { + channel: RTCDataChannel; +} + +interface RTCDataChannelInit { + id?: number; + maxPacketLifeTime?: number; + maxRetransmitTime?: number; + maxRetransmits?: number; + negotiated?: boolean; + ordered?: boolean; + protocol?: string; +} + +interface RTCDataChannelStats extends RTCStats { + bytesReceived?: number; + bytesSent?: number; + dataChannelIdentifier?: number; + label?: string; + messagesReceived?: number; + messagesSent?: number; + protocol?: string; + state?: RTCDataChannelState; +} + +interface RTCEncodedAudioFrameMetadata { + contributingSources?: number[]; + payloadType?: number; + sequenceNumber?: number; + synchronizationSource?: number; +} + +interface RTCEncodedVideoFrameMetadata { + contributingSources?: number[]; + dependencies?: number[]; + frameId?: number; + height?: number; + payloadType?: number; + spatialIndex?: number; + synchronizationSource?: number; + temporalIndex?: number; + timestamp?: number; + width?: number; +} + +interface RTCFecParameters { + ssrc?: number; +} + +interface RTCIceCandidateInit { + candidate?: string; + sdpMLineIndex?: number | null; + sdpMid?: string | null; + usernameFragment?: string | null; +} + +interface RTCIceCandidatePairStats extends RTCStats { + bytesReceived?: number; + bytesSent?: number; + componentId?: number; + lastPacketReceivedTimestamp?: DOMHighResTimeStamp; + lastPacketSentTimestamp?: DOMHighResTimeStamp; + localCandidateId?: string; + nominated?: boolean; + priority?: number; + readable?: boolean; + remoteCandidateId?: string; + selected?: boolean; + state?: RTCStatsIceCandidatePairState; + transportId?: string; + writable?: boolean; +} + +interface RTCIceCandidateStats extends RTCStats { + address?: string; + candidateType?: RTCIceCandidateType; + port?: number; + priority?: number; + protocol?: string; + proxied?: string; + relayProtocol?: string; + transportId?: string; +} + +interface RTCIceServer { + credential?: string; + credentialType?: RTCIceCredentialType; + url?: string; + urls?: string | string[]; + username?: string; +} + +interface RTCIceServerInternal { + credentialProvided: boolean; + urls?: string[]; + userNameProvided: boolean; +} + +interface RTCIdentityAssertion { + idp?: string; + name?: string; +} + +interface RTCIdentityAssertionResult { + assertion: string; + idp: RTCIdentityProviderDetails; +} + +interface RTCIdentityProvider { + generateAssertion: GenerateAssertionCallback; + validateAssertion: ValidateAssertionCallback; +} + +interface RTCIdentityProviderDetails { + domain: string; + protocol?: string; +} + +interface RTCIdentityProviderOptions { + peerIdentity?: string; + protocol?: string; + usernameHint?: string; +} + +interface RTCIdentityValidationResult { + contents: string; + identity: string; +} + +interface RTCInboundRtpStreamStats extends RTCReceivedRtpStreamStats { + audioLevel?: number; + bytesReceived?: number; + concealedSamples?: number; + concealmentEvents?: number; + fecPacketsDiscarded?: number; + fecPacketsReceived?: number; + firCount?: number; + frameHeight?: number; + frameWidth?: number; + framesDecoded?: number; + framesDropped?: number; + framesPerSecond?: number; + framesReceived?: number; + headerBytesReceived?: number; + insertedSamplesForDeceleration?: number; + jitterBufferDelay?: number; + jitterBufferEmittedCount?: number; + lastPacketReceivedTimestamp?: DOMHighResTimeStamp; + nackCount?: number; + pliCount?: number; + qpSum?: number; + remoteId?: string; + removedSamplesForAcceleration?: number; + silentConcealedSamples?: number; + totalAudioEnergy?: number; + totalDecodeTime?: number; + totalInterFrameDelay?: number; + totalProcessingDelay?: number; + totalSamplesDuration?: number; + totalSamplesReceived?: number; + totalSquaredInterFrameDelay?: number; + trackIdentifier: string; +} + +interface RTCMediaSourceStats extends RTCStats { + kind: string; + trackIdentifier: string; +} + +interface RTCOfferAnswerOptions { +} + +interface RTCOfferOptions extends RTCOfferAnswerOptions { + iceRestart?: boolean; + offerToReceiveAudio?: boolean; + offerToReceiveVideo?: boolean; +} + +interface RTCOutboundRtpStreamStats extends RTCSentRtpStreamStats { + firCount?: number; + frameHeight?: number; + frameWidth?: number; + framesEncoded?: number; + framesPerSecond?: number; + framesSent?: number; + headerBytesSent?: number; + hugeFramesSent?: number; + nackCount?: number; + pliCount?: number; + qpSum?: number; + remoteId?: string; + retransmittedBytesSent?: number; + retransmittedPacketsSent?: number; + totalEncodeTime?: number; + totalEncodedBytesTarget?: number; +} + +interface RTCPeerConnectionIceEventInit extends EventInit { + candidate?: RTCIceCandidate | null; +} + +interface RTCPeerConnectionStats extends RTCStats { + dataChannelsClosed?: number; + dataChannelsOpened?: number; +} + +interface RTCRTPContributingSourceStats extends RTCStats { + contributorSsrc?: number; + inboundRtpStreamId?: string; +} + +interface RTCReceivedRtpStreamStats extends RTCRtpStreamStats { + discardedPackets?: number; + jitter?: number; + packetsDiscarded?: number; + packetsLost?: number; + packetsReceived?: number; +} + +interface RTCRemoteInboundRtpStreamStats extends RTCReceivedRtpStreamStats { + fractionLost?: number; + localId?: string; + roundTripTime?: number; + roundTripTimeMeasurements?: number; + totalRoundTripTime?: number; +} + +interface RTCRemoteOutboundRtpStreamStats extends RTCSentRtpStreamStats { + localId?: string; + remoteTimestamp?: DOMHighResTimeStamp; +} + +interface RTCRtcpParameters { + cname?: string; + reducedSize?: boolean; +} + +interface RTCRtpCapabilities { + codecs: RTCRtpCodecCapability[]; + headerExtensions: RTCRtpHeaderExtensionCapability[]; +} + +interface RTCRtpCodec { + channels?: number; + clockRate: number; + mimeType: string; + sdpFmtpLine?: string; +} + +interface RTCRtpCodecCapability extends RTCRtpCodec { +} + +interface RTCRtpCodecParameters { + channels?: number; + clockRate?: number; + mimeType?: string; + payloadType?: number; + sdpFmtpLine?: string; +} + +interface RTCRtpContributingSource { + audioLevel?: number; + rtpTimestamp: number; + source: number; + timestamp: DOMHighResTimeStamp; +} + +interface RTCRtpEncodingParameters { + active?: boolean; + fec?: RTCFecParameters; + maxBitrate?: number; + maxFramerate?: number; + priority?: RTCPriorityType; + rid?: string; + rtx?: RTCRtxParameters; + scaleResolutionDownBy?: number; + ssrc?: number; +} + +interface RTCRtpHeaderExtensionCapability { + uri: string; +} + +interface RTCRtpHeaderExtensionParameters { + encrypted?: boolean; + id?: number; + uri?: string; +} + +interface RTCRtpParameters { + codecs?: RTCRtpCodecParameters[]; + headerExtensions?: RTCRtpHeaderExtensionParameters[]; + rtcp?: RTCRtcpParameters; +} + +interface RTCRtpSendParameters extends RTCRtpParameters { + encodings: RTCRtpEncodingParameters[]; + transactionId?: string; +} + +interface RTCRtpStreamStats extends RTCStats { + codecId?: string; + kind: string; + mediaType?: string; + ssrc: number; + transportId?: string; +} + +interface RTCRtpSynchronizationSource extends RTCRtpContributingSource { + voiceActivityFlag?: boolean | null; +} + +interface RTCRtpTransceiverInit { + direction?: RTCRtpTransceiverDirection; + sendEncodings?: RTCRtpEncodingParameters[]; + streams?: MediaStream[]; +} + +interface RTCRtxParameters { + ssrc?: number; +} + +interface RTCSdpHistoryEntryInternal { + errors?: RTCSdpParsingErrorInternal[]; + isLocal: boolean; + sdp: string; + timestamp: DOMHighResTimeStamp; +} + +interface RTCSdpHistoryInternal { + pcid: string; + sdpHistory?: RTCSdpHistoryEntryInternal[]; +} + +interface RTCSdpParsingErrorInternal { + error: string; + lineNumber: number; +} + +interface RTCSentRtpStreamStats extends RTCRtpStreamStats { + bytesSent?: number; + packetsSent?: number; +} + +interface RTCSessionDescriptionInit { + sdp?: string; + type?: RTCSdpType; +} + +interface RTCStats { + id?: string; + timestamp?: DOMHighResTimeStamp; + type?: RTCStatsType; +} + +interface RTCStatsCollection { + bandwidthEstimations?: RTCBandwidthEstimationInternal[]; + codecStats?: RTCCodecStats[]; + dataChannelStats?: RTCDataChannelStats[]; + iceCandidatePairStats?: RTCIceCandidatePairStats[]; + iceCandidateStats?: RTCIceCandidateStats[]; + inboundRtpStreamStats?: RTCInboundRtpStreamStats[]; + mediaSourceStats?: RTCMediaSourceStats[]; + outboundRtpStreamStats?: RTCOutboundRtpStreamStats[]; + peerConnectionStats?: RTCPeerConnectionStats[]; + rawLocalCandidates?: string[]; + rawRemoteCandidates?: string[]; + remoteInboundRtpStreamStats?: RTCRemoteInboundRtpStreamStats[]; + remoteOutboundRtpStreamStats?: RTCRemoteOutboundRtpStreamStats[]; + rtpContributingSourceStats?: RTCRTPContributingSourceStats[]; + trickledIceCandidateStats?: RTCIceCandidateStats[]; + videoFrameHistories?: RTCVideoFrameHistoryInternal[]; + videoSourceStats?: RTCVideoSourceStats[]; +} + +interface RTCStatsReportInternal extends RTCStatsCollection { + browserId: number; + callDurationMs?: number; + closed: boolean; + configuration?: RTCConfigurationInternal; + iceRestarts: number; + iceRollbacks: number; + jsepSessionErrors?: string; + offerer?: boolean; + pcid: string; + sdpHistory?: RTCSdpHistoryEntryInternal[]; + timestamp: DOMHighResTimeStamp; +} + +interface RTCTrackEventInit extends EventInit { + receiver: RTCRtpReceiver; + streams?: MediaStream[]; + track: MediaStreamTrack; + transceiver: RTCRtpTransceiver; +} + +interface RTCTransformEventInit extends EventInit { + transformer: RTCRtpScriptTransformer; +} + +interface RTCVideoFrameHistoryEntryInternal { + consecutiveFrames: number; + firstFrameTimestamp: DOMHighResTimeStamp; + height: number; + lastFrameTimestamp: DOMHighResTimeStamp; + localSsrc: number; + remoteSsrc: number; + rotationAngle: number; + width: number; +} + +interface RTCVideoFrameHistoryInternal { + entries?: RTCVideoFrameHistoryEntryInternal[]; + trackIdentifier: string; +} + +interface RTCVideoSourceStats extends RTCMediaSourceStats { + frames?: number; + framesPerSecond?: number; + height?: number; + width?: number; +} + +interface ReadOptions extends ReadUTF8Options { + maxBytes?: number | null; + offset?: number; +} + +interface ReadUTF8Options { + decompress?: boolean; +} + +interface ReadableStreamGetReaderOptions { + mode?: ReadableStreamReaderMode; +} + +interface ReadableStreamIteratorOptions { + preventCancel?: boolean; +} + +interface ReadableStreamReadResult { + done?: boolean; + value?: any; +} + +interface ReadableWritablePair { + readable: ReadableStream; + writable: WritableStream; +} + +interface ReceiveMessageArgument { + data?: any; + json?: any; + name: string; + ports?: MessagePort[]; + sync: boolean; + target: nsISupports; + targetFrameLoader?: FrameLoader; +} + +interface RegistrationOptions { + scope?: string; + updateViaCache?: ServiceWorkerUpdateViaCache; +} + +interface RemotenessOptions { + pendingSwitchID?: number; + remoteType: UTF8String | null; + switchingInProgressLoad?: boolean; +} + +interface RemoveOptions { + ignoreAbsent?: boolean; + recursive?: boolean; + retryReadonly?: boolean; +} + +interface ReportingObserverOptions { + buffered?: boolean; + types?: string[]; +} + +interface RequestInit { + body?: BodyInit | null; + cache?: RequestCache; + credentials?: RequestCredentials; + headers?: HeadersInit; + integrity?: string; + method?: string; + mode?: RequestMode; + mozErrors?: boolean; + observe?: ObserverCallback; + redirect?: RequestRedirect; + referrer?: string; + referrerPolicy?: ReferrerPolicy; + signal?: AbortSignal | null; +} + +interface ResizeObserverOptions { + box?: ResizeObserverBoxOptions; +} + +interface ResourceId { + optional?: boolean; + path: UTF8String; +} + +interface ResponseInit { + headers?: HeadersInit; + status?: number; + statusText?: string; +} + +interface SVGBoundingBoxOptions { + clipped?: boolean; + fill?: boolean; + markers?: boolean; + stroke?: boolean; +} + +interface SanitizerAttributeNamespace { + name: string; + namespace?: string | null; +} + +interface SanitizerConfig { + attributes?: SanitizerAttribute[]; + comments?: boolean; + customElements?: boolean; + elements?: SanitizerElementWithAttributes[]; + removeAttributes?: SanitizerAttribute[]; + removeElements?: SanitizerElement[]; + replaceWithChildrenElements?: SanitizerElement[]; + unknownMarkup?: boolean; +} + +interface SanitizerElementNamespace { + name: string; + namespace?: string | null; +} + +interface SanitizerElementNamespaceWithAttributes extends SanitizerElementNamespace { + attributes?: SanitizerAttribute[]; + removeAttributes?: SanitizerAttribute[]; +} + +interface SchedulerPostTaskOptions { + delay?: number; + priority?: TaskPriority; + signal?: AbortSignal; +} + +interface ScrollIntoViewOptions extends ScrollOptions { + block?: ScrollLogicalPosition; + inline?: ScrollLogicalPosition; +} + +interface ScrollOptions { + behavior?: ScrollBehavior; +} + +interface ScrollToOptions extends ScrollOptions { + left?: number; + top?: number; +} + +interface ScrollViewChangeEventInit extends EventInit { + state?: ScrollState; +} + +interface SecurityPolicyViolationEventInit extends EventInit { + blockedURI?: string; + columnNumber?: number; + disposition?: SecurityPolicyViolationEventDisposition; + documentURI?: string; + effectiveDirective?: string; + lineNumber?: number; + originalPolicy?: string; + referrer?: string; + sample?: string; + sourceFile?: string; + statusCode?: number; + violatedDirective?: string; +} + +interface SelectorWarning { + index: number; + kind: SelectorWarningKind; +} + +interface ServerSocketOptions { + binaryType?: TCPSocketBinaryType; +} + +interface SetHTMLOptions { + sanitizer?: SanitizerConfig; +} + +interface ShadowRootInit { + clonable?: boolean; + delegatesFocus?: boolean; + mode: ShadowRootMode; + slotAssignment?: SlotAssignmentMode; +} + +interface ShareData { + files?: File[]; + text?: string; + title?: string; + url?: string; +} + +interface SizeToContentConstraints { + maxHeight?: number; + maxWidth?: number; + prefWidth?: number; +} + +interface SocketOptions { + binaryType?: TCPSocketBinaryType; + useSecureTransport?: boolean; +} + +interface SpeechRecognitionErrorInit extends EventInit { + error?: SpeechRecognitionErrorCode; + message?: string; +} + +interface SpeechRecognitionEventInit extends EventInit { + emma?: Document | null; + interpretation?: any; + resultIndex?: number; + results?: SpeechRecognitionResultList | null; +} + +interface SpeechSynthesisErrorEventInit extends SpeechSynthesisEventInit { + error: SpeechSynthesisErrorCode; +} + +interface SpeechSynthesisEventInit extends EventInit { + charIndex?: number; + charLength?: number | null; + elapsedTime?: number; + name?: string; + utterance: SpeechSynthesisUtterance; +} + +interface SplitRelativeOptions { + allowCurrentDir?: boolean; + allowEmpty?: boolean; + allowParentDir?: boolean; +} + +interface StaticRangeInit { + endContainer: Node; + endOffset: number; + startContainer: Node; + startOffset: number; +} + +interface StereoPannerOptions extends AudioNodeOptions { + pan?: number; +} + +interface StorageEstimate { + quota?: number; + usage?: number; +} + +interface StorageEventInit extends EventInit { + key?: string | null; + newValue?: string | null; + oldValue?: string | null; + storageArea?: Storage | null; + url?: string; +} + +interface StreamFilterDataEventInit extends EventInit { + data: ArrayBuffer; +} + +interface StreamPipeOptions { + preventAbort?: boolean; + preventCancel?: boolean; + preventClose?: boolean; + signal?: AbortSignal; +} + +interface StructuredSerializeOptions { + transfer?: any[]; +} + +interface StyleSheetApplicableStateChangeEventInit extends EventInit { + applicable?: boolean; + stylesheet?: CSSStyleSheet | null; +} + +interface StyleSheetRemovedEventInit extends EventInit { + stylesheet?: CSSStyleSheet | null; +} + +interface SubmitEventInit extends EventInit { + submitter?: HTMLElement | null; +} + +interface SupportsOptions { + chrome?: boolean; + quirks?: boolean; + userAgent?: boolean; +} + +interface SvcOutputMetadata { + temporalLayerId?: number; +} + +interface TCPServerSocketEventInit extends EventInit { + socket?: TCPSocket | null; +} + +interface TCPSocketErrorEventInit extends EventInit { + errorCode?: number; + message?: string; + name?: string; +} + +interface TCPSocketEventInit extends EventInit { + data?: any; +} + +interface TaskControllerInit { + priority?: TaskPriority; +} + +interface TaskPriorityChangeEventInit extends EventInit { + previousPriority: TaskPriority; +} + +interface TelemetryStopwatchOptions { + inSeconds?: boolean; +} + +interface TestInterfaceAsyncIterableSingleOptions { + failToInit?: boolean; +} + +interface TestInterfaceAsyncIteratorOptions { + blockingPromises?: Promise[]; + failNextAfter?: number; + multiplier?: number; + throwFromNext?: boolean; + throwFromReturn?: TestThrowingCallback; +} + +interface TestInterfaceJSDictionary { + anyMember?: any; + anySequenceMember?: any[]; + innerDictionary?: TestInterfaceJSDictionary2; + objectMember?: any; + objectOrStringMember?: any; + objectRecordMember?: Record; +} + +interface TestInterfaceJSDictionary2 { + innerObject?: any; +} + +interface TestInterfaceJSUnionableDictionary { + anyMember?: any; + objectMember?: any; +} + +interface TextDecodeOptions { + stream?: boolean; +} + +interface TextDecoderOptions { + fatal?: boolean; + ignoreBOM?: boolean; +} + +interface TextEncoderEncodeIntoResult { + read?: number; + written?: number; +} + +interface ThreadInfoDictionary { + cpuCycleCount?: number; + cpuTime?: number; + name?: string; + tid?: number; +} + +interface ToggleEventInit extends EventInit { + newState?: string; + oldState?: string; +} + +interface TouchEventInit extends EventModifierInit { + changedTouches?: Touch[]; + targetTouches?: Touch[]; + touches?: Touch[]; +} + +interface TouchInit { + clientX?: number; + clientY?: number; + force?: number; + identifier: number; + pageX?: number; + pageY?: number; + radiusX?: number; + radiusY?: number; + rotationAngle?: number; + screenX?: number; + screenY?: number; + target: EventTarget; +} + +interface TrackBuffersManagerDebugInfo { + bufferSize?: number; + evictable?: number; + nextGetSampleIndex?: number; + nextInsertionIndex?: number; + nextSampleTime?: number; + numSamples?: number; + ranges?: BufferRange[]; + type?: string; +} + +interface TrackEventInit extends EventInit { + track?: VideoTrack | AudioTrack | TextTrack | null; +} + +interface TransitionEventInit extends EventInit { + elapsedTime?: number; + propertyName?: string; + pseudoElement?: string; +} + +interface TreeCellInfo { + childElt?: string; + col?: TreeColumn | null; + row?: number; +} + +interface UDPMessageEventInit extends EventInit { + data?: any; + remoteAddress?: string; + remotePort?: number; +} + +interface UDPOptions { + addressReuse?: boolean; + localAddress?: string; + localPort?: number; + loopback?: boolean; + remoteAddress?: string; + remotePort?: number; +} + +interface UIEventInit extends EventInit { + detail?: number; + view?: Window | null; +} + +interface UniFFIScaffoldingCallResult { + code: UniFFIScaffoldingCallCode; + data?: UniFFIScaffoldingType; + internalErrorMessage?: string; +} + +interface UserProximityEventInit extends EventInit { + near?: boolean; +} + +interface UtilityActorsDictionary { + actorName?: WebIDLUtilityActorName; +} + +interface VRDisplayEventInit extends EventInit { + display: VRDisplay; + reason?: VRDisplayEventReason; +} + +interface VRLayer { + leftBounds?: number[] | Float32Array; + rightBounds?: number[] | Float32Array; + source?: HTMLCanvasElement | null; +} + +interface ValidityStateFlags { + badInput?: boolean; + customError?: boolean; + patternMismatch?: boolean; + rangeOverflow?: boolean; + rangeUnderflow?: boolean; + stepMismatch?: boolean; + tooLong?: boolean; + tooShort?: boolean; + typeMismatch?: boolean; + valueMissing?: boolean; +} + +interface VideoColorSpaceInit { + fullRange?: boolean | null; + matrix?: VideoMatrixCoefficients | null; + primaries?: VideoColorPrimaries | null; + transfer?: VideoTransferCharacteristics | null; +} + +interface VideoConfiguration { + bitrate: number; + colorGamut?: ColorGamut; + contentType: string; + framerate: number; + hasAlphaChannel?: boolean; + hdrMetadataType?: HdrMetadataType; + height: number; + scalabilityMode?: string; + transferFunction?: TransferFunction; + width: number; +} + +interface VideoDecoderConfig { + codec: string; + codedHeight?: number; + codedWidth?: number; + colorSpace?: VideoColorSpaceInit; + description?: ArrayBufferView | ArrayBuffer; + displayAspectHeight?: number; + displayAspectWidth?: number; + hardwareAcceleration?: HardwareAcceleration; + optimizeForLatency?: boolean; +} + +interface VideoDecoderInit { + error: WebCodecsErrorCallback; + output: VideoFrameOutputCallback; +} + +interface VideoDecoderSupport { + config?: VideoDecoderConfig; + supported?: boolean; +} + +interface VideoEncoderConfig { + alpha?: AlphaOption; + avc?: AvcEncoderConfig; + bitrate?: number; + bitrateMode?: VideoEncoderBitrateMode; + codec: string; + contentHint?: string; + displayHeight?: number; + displayWidth?: number; + framerate?: number; + hardwareAcceleration?: HardwareAcceleration; + height: number; + latencyMode?: LatencyMode; + scalabilityMode?: string; + width: number; +} + +interface VideoEncoderEncodeOptions { + avc?: VideoEncoderEncodeOptionsForAvc; + keyFrame?: boolean; +} + +interface VideoEncoderEncodeOptionsForAvc { + quantizer?: number | null; +} + +interface VideoEncoderInit { + error: WebCodecsErrorCallback; + output: EncodedVideoChunkOutputCallback; +} + +interface VideoEncoderSupport { + config?: VideoEncoderConfig; + supported?: boolean; +} + +interface VideoFrameBufferInit { + codedHeight: number; + codedWidth: number; + colorSpace?: VideoColorSpaceInit; + displayHeight?: number; + displayWidth?: number; + duration?: number; + format: VideoPixelFormat; + layout?: PlaneLayout[]; + timestamp: number; + visibleRect?: DOMRectInit; +} + +interface VideoFrameCopyToOptions { + layout?: PlaneLayout[]; + rect?: DOMRectInit; +} + +interface VideoFrameInit { + alpha?: AlphaOption; + displayHeight?: number; + displayWidth?: number; + duration?: number; + timestamp?: number; + visibleRect?: DOMRectInit; +} + +interface VideoSinkDebugInfo { + endPromiseHolderIsEmpty?: boolean; + finished?: boolean; + hasVideo?: boolean; + isPlaying?: boolean; + isStarted?: boolean; + size?: number; + videoFrameEndTime?: number; + videoSinkEndRequestExists?: boolean; +} + +interface WaveShaperOptions extends AudioNodeOptions { + curve?: number[] | Float32Array; + oversample?: OverSampleType; +} + +interface WebAccessibleResourceInit { + extension_ids?: string[] | null; + matches?: MatchPatternSetOrStringSequence | null; + resources: MatchGlobOrString[]; +} + +interface WebExtensionContentScriptInit extends MozDocumentMatcherInit { + cssPaths?: string[]; + jsPaths?: string[]; + runAt?: ContentScriptRunAt; +} + +interface WebExtensionInit { + allowedOrigins: MatchPatternSetOrStringSequence; + backgroundScripts?: string[] | null; + backgroundTypeModule?: boolean; + backgroundWorkerScript?: string | null; + baseURL: string; + contentScripts?: WebExtensionContentScriptInit[]; + extensionPageCSP?: string | null; + id: string; + ignoreQuarantine?: boolean; + isPrivileged?: boolean; + localizeCallback: WebExtensionLocalizeCallback; + manifestVersion?: number; + mozExtensionHostname: string; + name?: string; + permissions?: string[]; + readyPromise?: Promise; + temporarilyInstalled?: boolean; + type?: string; + webAccessibleResources?: WebAccessibleResourceInit[]; +} + +interface WebGLContextAttributes { + alpha?: GLboolean; + antialias?: GLboolean; + colorSpace?: PredefinedColorSpace; + depth?: GLboolean; + failIfMajorPerformanceCaveat?: GLboolean; + powerPreference?: WebGLPowerPreference; + premultipliedAlpha?: GLboolean; + preserveDrawingBuffer?: GLboolean; + stencil?: GLboolean; + xrCompatible?: boolean; +} + +interface WebGLContextEventInit extends EventInit { + statusMessage?: string; +} + +interface WebTransportCloseInfo { + closeCode?: number; + reason?: UTF8String; +} + +interface WebTransportDatagramStats { + droppedIncoming?: number; + expiredOutgoing?: number; + lostOutgoing?: number; + timestamp?: DOMHighResTimeStamp; +} + +interface WebTransportErrorInit { + message?: string; + streamErrorCode?: number; +} + +interface WebTransportHash { + algorithm?: string; + value?: BufferSource; +} + +interface WebTransportOptions { + allowPooling?: boolean; + congestionControl?: WebTransportCongestionControl; + requireUnreliable?: boolean; + serverCertificateHashes?: WebTransportHash[]; +} + +interface WebTransportReceiveStreamStats { + bytesRead?: number; + bytesReceived?: number; + timestamp?: DOMHighResTimeStamp; +} + +interface WebTransportSendStreamOptions { + sendOrder?: number | null; +} + +interface WebTransportSendStreamStats { + bytesAcknowledged?: number; + bytesSent?: number; + bytesWritten?: number; + timestamp?: DOMHighResTimeStamp; +} + +interface WebTransportStats { + bytesReceived?: number; + bytesSent?: number; + datagrams?: WebTransportDatagramStats; + minRtt?: DOMHighResTimeStamp; + numIncomingStreamsCreated?: number; + numOutgoingStreamsCreated?: number; + packetsLost?: number; + packetsReceived?: number; + packetsSent?: number; + rttVariation?: DOMHighResTimeStamp; + smoothedRtt?: DOMHighResTimeStamp; + timestamp?: DOMHighResTimeStamp; +} + +interface WebrtcGlobalMediaContext { + hasH264Hardware: boolean; +} + +interface WebrtcGlobalStatisticsReport { + reports?: RTCStatsReportInternal[]; + sdpHistories?: RTCSdpHistoryInternal[]; +} + +interface WheelEventInit extends MouseEventInit { + deltaMode?: number; + deltaX?: number; + deltaY?: number; + deltaZ?: number; +} + +interface WindowActorChildOptions extends WindowActorSidedOptions { + events?: Record; + observers?: string[]; +} + +interface WindowActorEventListenerOptions extends AddEventListenerOptions { + createActor?: boolean; +} + +interface WindowActorOptions { + allFrames?: boolean; + child?: WindowActorChildOptions; + includeChrome?: boolean; + matches?: string[]; + messageManagerGroups?: string[]; + parent?: WindowActorSidedOptions; + remoteTypes?: UTF8String[]; +} + +interface WindowActorSidedOptions { + esModuleURI?: string; + moduleURI?: string; +} + +interface WindowInfoDictionary { + documentTitle?: string; + documentURI?: URI | null; + isInProcess?: boolean; + isProcessRoot?: boolean; + outerWindowId?: number; +} + +interface WindowPostMessageOptions extends StructuredSerializeOptions { + targetOrigin?: string; +} + +interface WindowsFileAttributes { + hidden?: boolean; + readOnly?: boolean; + system?: boolean; +} + +interface Wireframe { + canvasBackground?: number; + rects?: WireframeTaggedRect[]; + version?: number; +} + +interface WireframeTaggedRect { + color?: number; + height?: number; + node?: Node | null; + type?: WireframeRectType; + width?: number; + x?: number; + y?: number; +} + +interface WorkerOptions { + credentials?: RequestCredentials; + name?: string; + type?: WorkerType; +} + +interface WorkletOptions { + credentials?: RequestCredentials; +} + +interface WriteOptions { + backupFile?: string; + compress?: boolean; + flush?: boolean; + mode?: WriteMode; + tmpPath?: string; +} + +interface WriteParams { + data?: BufferSource | Blob | UTF8String | null; + position?: number | null; + size?: number | null; + type: WriteCommandType; +} + +interface XRInputSourceEventInit extends EventInit { + frame: XRFrame; + inputSource: XRInputSource; +} + +interface XRInputSourcesChangeEventInit extends EventInit { + added: XRInputSource[]; + removed: XRInputSource[]; + session: XRSession; +} + +interface XRReferenceSpaceEventInit extends EventInit { + referenceSpace: XRReferenceSpace; + transform?: XRRigidTransform | null; +} + +interface XRRenderStateInit { + baseLayer?: XRWebGLLayer | null; + depthFar?: number; + depthNear?: number; + inlineVerticalFieldOfView?: number; +} + +interface XRSessionEventInit extends EventInit { + session: XRSession; +} + +interface XRSessionInit { + optionalFeatures?: any[]; + requiredFeatures?: any[]; +} + +interface XRWebGLLayerInit { + alpha?: boolean; + antialias?: boolean; + depth?: boolean; + framebufferScaleFactor?: number; + ignoreDepthValues?: boolean; + stencil?: boolean; +} + +interface addonInstallOptions { + hash?: string | null; + url: string; +} + +type EventListener = ((event: Event) => void) | { handleEvent(event: Event): void; }; + +type MessageListener = ((argument: ReceiveMessageArgument) => any) | { receiveMessage(argument: ReceiveMessageArgument): any; }; + +type MozDocumentCallback = ((matcher: MozDocumentMatcher, window: WindowProxy) => void) | { onNewDocument(matcher: MozDocumentMatcher, window: WindowProxy): void; }; + +type NodeFilter = ((node: Node) => number) | { acceptNode(node: Node): number; }; + +declare var NodeFilter: { + readonly FILTER_ACCEPT: 1; + readonly FILTER_REJECT: 2; + readonly FILTER_SKIP: 3; + readonly SHOW_ALL: 0xFFFFFFFF; + readonly SHOW_ELEMENT: 0x1; + readonly SHOW_ATTRIBUTE: 0x2; + readonly SHOW_TEXT: 0x4; + readonly SHOW_CDATA_SECTION: 0x8; + readonly SHOW_ENTITY_REFERENCE: 0x10; + readonly SHOW_ENTITY: 0x20; + readonly SHOW_PROCESSING_INSTRUCTION: 0x40; + readonly SHOW_COMMENT: 0x80; + readonly SHOW_DOCUMENT: 0x100; + readonly SHOW_DOCUMENT_TYPE: 0x200; + readonly SHOW_DOCUMENT_FRAGMENT: 0x400; + readonly SHOW_NOTATION: 0x800; +}; + +type ObserverCallback = ((observer: FetchObserver) => void) | { handleEvent(observer: FetchObserver): void; }; + +type UncaughtRejectionObserver = ((p: any) => boolean) | { onLeftUncaught(p: any): boolean; }; + +type XPathNSResolver = ((prefix: string | null) => string | null) | { lookupNamespaceURI(prefix: string | null): string | null; }; + +/** + * 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. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ANGLE_instanced_arrays) + */ +interface ANGLE_instanced_arrays { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ANGLE_instanced_arrays/drawArraysInstancedANGLE) */ + drawArraysInstancedANGLE(mode: GLenum, first: GLint, count: GLsizei, primcount: GLsizei): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ANGLE_instanced_arrays/drawElementsInstancedANGLE) */ + drawElementsInstancedANGLE(mode: GLenum, count: GLsizei, type: GLenum, offset: GLintptr, primcount: GLsizei): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ANGLE_instanced_arrays/vertexAttribDivisorANGLE) */ + vertexAttribDivisorANGLE(index: GLuint, divisor: GLuint): void; + readonly VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE: 0x88FE; +} + +/** + * A controller object that allows you to abort one or more DOM requests as and when desired. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbortController) + */ +interface AbortController { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbortController/signal) */ + readonly signal: AbortSignal; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbortController/abort) */ + abort(reason?: any): void; +} + +declare var AbortController: { + prototype: AbortController; + new(): AbortController; + isInstance(obj): obj is AbortController; +}; + +interface AbortSignalEventMap { + "abort": Event; +} + +/** + * 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. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbortSignal) + */ +interface AbortSignal extends EventTarget { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbortSignal/aborted) */ + readonly aborted: boolean; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbortSignal/abort_event) */ + onabort: ((this: AbortSignal, ev: Event) => any) | null; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbortSignal/reason) */ + readonly reason: any; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbortSignal/throwIfAborted) */ + throwIfAborted(): void; + addEventListener(type: K, listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void; + addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void; + removeEventListener(type: K, listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any, options?: boolean | EventListenerOptions): void; + removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void; +} + +declare var AbortSignal: { + prototype: AbortSignal; + new(): AbortSignal; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbortSignal/abort_static) */ + abort(reason?: any): AbortSignal; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbortSignal/timeout_static) */ + timeout(milliseconds: number): AbortSignal; + isInstance(obj): obj is AbortSignal; +}; + +/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbstractRange) */ +interface AbstractRange { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbstractRange/collapsed) */ + readonly collapsed: boolean; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbstractRange/endContainer) */ + readonly endContainer: Node; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbstractRange/endOffset) */ + readonly endOffset: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbstractRange/startContainer) */ + readonly startContainer: Node; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbstractRange/startOffset) */ + readonly startOffset: number; +} + +declare var AbstractRange: { + prototype: AbstractRange; + new(): AbstractRange; + isInstance(obj): obj is AbstractRange; +}; + +interface AbstractWorkerEventMap { + "error": ErrorEvent; +} + +interface AbstractWorker { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorker/error_event) */ + onerror: OnErrorEventHandler; + addEventListener(type: K, listener: (this: AbstractWorker, ev: AbstractWorkerEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void; + addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void; + removeEventListener(type: K, listener: (this: AbstractWorker, ev: AbstractWorkerEventMap[K]) => any, options?: boolean | EventListenerOptions): void; + removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void; +} + +interface AccessibilityRole { + role: string | null; +} + +interface AccessibleNode { + readonly DOMNode: Node | null; + activeDescendant: AccessibleNode | null; + atomic: boolean | null; + readonly attributes: string[]; + autocomplete: string | null; + busy: boolean | null; + checked: string | null; + colCount: number | null; + colIndex: number | null; + colSpan: number | null; + readonly computedRole: string; + current: string | null; + details: AccessibleNode | null; + disabled: boolean | null; + errorMessage: AccessibleNode | null; + expanded: boolean | null; + hasPopUp: string | null; + hidden: boolean | null; + invalid: string | null; + keyShortcuts: string | null; + label: string | null; + level: number | null; + live: string | null; + modal: boolean | null; + multiline: boolean | null; + multiselectable: boolean | null; + orientation: string | null; + placeholder: string | null; + posInSet: number | null; + pressed: string | null; + readOnly: boolean | null; + relevant: string | null; + required: boolean | null; + role: string | null; + roleDescription: string | null; + rowCount: number | null; + rowIndex: number | null; + rowSpan: number | null; + selected: boolean | null; + setSize: number | null; + sort: string | null; + readonly states: string[]; + valueMax: number | null; + valueMin: number | null; + valueNow: number | null; + valueText: string | null; + get(attribute: string): any; + has(...attributes: string[]): boolean; + is(...states: string[]): boolean; +} + +declare var AccessibleNode: { + prototype: AccessibleNode; + new(): AccessibleNode; + isInstance(obj): obj is AccessibleNode; +}; + +interface Addon { + readonly canUninstall: boolean; + readonly description: string; + readonly id: string; + readonly isActive: boolean; + readonly isEnabled: boolean; + readonly name: string; + readonly type: string; + readonly version: string; + setEnabled(value: boolean): Promise; + uninstall(): Promise; +} + +declare var Addon: { + prototype: Addon; + new(): Addon; + isInstance(obj): obj is Addon; +}; + +interface AddonEvent extends Event { + readonly id: string; +} + +declare var AddonEvent: { + prototype: AddonEvent; + new(type: string, eventInitDict: AddonEventInit): AddonEvent; + isInstance(obj): obj is AddonEvent; +}; + +interface AddonInstall extends EventTarget { + "error": ErrorEvent; + readonly maxProgress: number; + readonly progress: number; + readonly state: string; + cancel(): Promise; + install(): Promise; +} + +declare var AddonInstall: { + prototype: AddonInstall; + new(): AddonInstall; + isInstance(obj): obj is AddonInstall; +}; + +interface AddonManager extends EventTarget { + readonly abuseReportPanelEnabled: boolean; + createInstall(options?: addonInstallOptions): Promise; + getAddonByID(id: string): Promise; + reportAbuse(id: string): Promise; +} + +declare var AddonManager: { + prototype: AddonManager; + new(): AddonManager; + isInstance(obj): obj is AddonManager; +}; + +/** + * 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. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AnalyserNode) + */ +interface AnalyserNode extends AudioNode, AudioNodePassThrough { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AnalyserNode/fftSize) */ + fftSize: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AnalyserNode/frequencyBinCount) */ + readonly frequencyBinCount: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AnalyserNode/maxDecibels) */ + maxDecibels: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AnalyserNode/minDecibels) */ + minDecibels: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AnalyserNode/smoothingTimeConstant) */ + smoothingTimeConstant: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AnalyserNode/getByteFrequencyData) */ + getByteFrequencyData(array: Uint8Array): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AnalyserNode/getByteTimeDomainData) */ + getByteTimeDomainData(array: Uint8Array): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AnalyserNode/getFloatFrequencyData) */ + getFloatFrequencyData(array: Float32Array): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AnalyserNode/getFloatTimeDomainData) */ + getFloatTimeDomainData(array: Float32Array): void; +} + +declare var AnalyserNode: { + prototype: AnalyserNode; + new(context: BaseAudioContext, options?: AnalyserOptions): AnalyserNode; + isInstance(obj): obj is AnalyserNode; +}; + +interface Animatable { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/animate) */ + animate(keyframes: any, options?: UnrestrictedDoubleOrKeyframeAnimationOptions): Animation; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/getAnimations) */ + getAnimations(options?: GetAnimationsOptions): Animation[]; +} + +interface AnimationEventMap { + "cancel": Event; + "finish": Event; + "remove": Event; +} + +/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Animation) */ +interface Animation extends EventTarget { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Animation/currentTime) */ + currentTime: number | null; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Animation/effect) */ + effect: AnimationEffect | null; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Animation/finished) */ + readonly finished: Promise; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Animation/id) */ + id: string; + readonly isRunningOnCompositor: boolean; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Animation/cancel_event) */ + oncancel: ((this: Animation, ev: Event) => any) | null; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Animation/finish_event) */ + onfinish: ((this: Animation, ev: Event) => any) | null; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Animation/remove_event) */ + onremove: ((this: Animation, ev: Event) => any) | null; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Animation/pending) */ + readonly pending: boolean; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Animation/playState) */ + readonly playState: AnimationPlayState; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Animation/playbackRate) */ + playbackRate: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Animation/ready) */ + readonly ready: Promise; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Animation/replaceState) */ + readonly replaceState: AnimationReplaceState; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Animation/startTime) */ + startTime: number | null; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Animation/timeline) */ + timeline: AnimationTimeline | null; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Animation/cancel) */ + cancel(): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Animation/commitStyles) */ + commitStyles(): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Animation/finish) */ + finish(): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Animation/pause) */ + pause(): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Animation/persist) */ + persist(): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Animation/play) */ + play(): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Animation/reverse) */ + reverse(): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Animation/updatePlaybackRate) */ + updatePlaybackRate(playbackRate: number): void; + addEventListener(type: K, listener: (this: Animation, ev: AnimationEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void; + addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void; + removeEventListener(type: K, listener: (this: Animation, ev: AnimationEventMap[K]) => any, options?: boolean | EventListenerOptions): void; + removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void; +} + +declare var Animation: { + prototype: Animation; + new(effect?: AnimationEffect | null, timeline?: AnimationTimeline | null): Animation; + isInstance(obj): obj is Animation; +}; + +/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AnimationEffect) */ +interface AnimationEffect { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AnimationEffect/getComputedTiming) */ + getComputedTiming(): ComputedEffectTiming; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AnimationEffect/getTiming) */ + getTiming(): EffectTiming; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AnimationEffect/updateTiming) */ + updateTiming(timing?: OptionalEffectTiming): void; +} + +declare var AnimationEffect: { + prototype: AnimationEffect; + new(): AnimationEffect; + isInstance(obj): obj is AnimationEffect; +}; + +/** + * Events providing information related to animations. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AnimationEvent) + */ +interface AnimationEvent extends Event { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AnimationEvent/animationName) */ + readonly animationName: string; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AnimationEvent/elapsedTime) */ + readonly elapsedTime: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AnimationEvent/pseudoElement) */ + readonly pseudoElement: string; +} + +declare var AnimationEvent: { + prototype: AnimationEvent; + new(type: string, eventInitDict?: AnimationEventInit): AnimationEvent; + isInstance(obj): obj is AnimationEvent; +}; + +interface AnimationFrameProvider { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DedicatedWorkerGlobalScope/cancelAnimationFrame) */ + cancelAnimationFrame(handle: number): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DedicatedWorkerGlobalScope/requestAnimationFrame) */ + requestAnimationFrame(callback: FrameRequestCallback): number; +} + +/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AnimationPlaybackEvent) */ +interface AnimationPlaybackEvent extends Event { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AnimationPlaybackEvent/currentTime) */ + readonly currentTime: number | null; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AnimationPlaybackEvent/timelineTime) */ + readonly timelineTime: number | null; +} + +declare var AnimationPlaybackEvent: { + prototype: AnimationPlaybackEvent; + new(type: string, eventInitDict?: AnimationPlaybackEventInit): AnimationPlaybackEvent; + isInstance(obj): obj is AnimationPlaybackEvent; +}; + +/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AnimationTimeline) */ +interface AnimationTimeline { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AnimationTimeline/currentTime) */ + readonly currentTime: number | null; +} + +declare var AnimationTimeline: { + prototype: AnimationTimeline; + new(): AnimationTimeline; + isInstance(obj): obj is AnimationTimeline; +}; + +interface AnonymousContent { + readonly root: ShadowRoot; +} + +declare var AnonymousContent: { + prototype: AnonymousContent; + new(): AnonymousContent; + isInstance(obj): obj is AnonymousContent; +}; + +interface AriaAttributes { + ariaAtomic: string | null; + ariaAutoComplete: string | null; + ariaBusy: string | null; + ariaChecked: string | null; + ariaColCount: string | null; + ariaColIndex: string | null; + ariaColIndexText: string | null; + ariaColSpan: string | null; + ariaCurrent: string | null; + ariaDescription: string | null; + ariaDisabled: string | null; + ariaExpanded: string | null; + ariaHasPopup: string | null; + ariaHidden: string | null; + ariaInvalid: string | null; + ariaKeyShortcuts: string | null; + ariaLabel: string | null; + ariaLevel: string | null; + ariaLive: string | null; + ariaModal: string | null; + ariaMultiLine: string | null; + ariaMultiSelectable: string | null; + ariaOrientation: string | null; + ariaPlaceholder: string | null; + ariaPosInSet: string | null; + ariaPressed: string | null; + ariaReadOnly: string | null; + ariaRelevant: string | null; + ariaRequired: string | null; + ariaRoleDescription: string | null; + ariaRowCount: string | null; + ariaRowIndex: string | null; + ariaRowIndexText: string | null; + ariaRowSpan: string | null; + ariaSelected: string | null; + ariaSetSize: string | null; + ariaSort: string | null; + ariaValueMax: string | null; + ariaValueMin: string | null; + ariaValueNow: string | null; + ariaValueText: string | null; +} + +/** + * 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. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Attr) + */ +interface Attr extends Node { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Attr/localName) */ + readonly localName: string; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Attr/name) */ + readonly name: string; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Attr/namespaceURI) */ + readonly namespaceURI: string | null; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Attr/ownerElement) */ + readonly ownerElement: Element | null; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Attr/prefix) */ + readonly prefix: string | null; + /** + * @deprecated + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Attr/specified) + */ + readonly specified: boolean; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Attr/value) */ + value: string; +} + +declare var Attr: { + prototype: Attr; + new(): Attr; + isInstance(obj): obj is Attr; +}; + +/** + * 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. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioBuffer) + */ +interface AudioBuffer { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioBuffer/duration) */ + readonly duration: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioBuffer/length) */ + readonly length: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioBuffer/numberOfChannels) */ + readonly numberOfChannels: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioBuffer/sampleRate) */ + readonly sampleRate: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioBuffer/copyFromChannel) */ + copyFromChannel(destination: Float32Array, channelNumber: number, startInChannel?: number): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioBuffer/copyToChannel) */ + copyToChannel(source: Float32Array, channelNumber: number, startInChannel?: number): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioBuffer/getChannelData) */ + getChannelData(channel: number): Float32Array; +} + +declare var AudioBuffer: { + prototype: AudioBuffer; + new(options: AudioBufferOptions): AudioBuffer; + isInstance(obj): obj is AudioBuffer; +}; + +/** + * 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. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioBufferSourceNode) + */ +interface AudioBufferSourceNode extends AudioScheduledSourceNode, AudioNodePassThrough { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioBufferSourceNode/buffer) */ + buffer: AudioBuffer | null; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioBufferSourceNode/detune) */ + readonly detune: AudioParam; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioBufferSourceNode/loop) */ + loop: boolean; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioBufferSourceNode/loopEnd) */ + loopEnd: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioBufferSourceNode/loopStart) */ + loopStart: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioBufferSourceNode/playbackRate) */ + readonly playbackRate: AudioParam; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioBufferSourceNode/start) */ + start(when?: number, grainOffset?: number, grainDuration?: number): void; + addEventListener(type: K, listener: (this: AudioBufferSourceNode, ev: AudioScheduledSourceNodeEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void; + addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void; + removeEventListener(type: K, listener: (this: AudioBufferSourceNode, ev: AudioScheduledSourceNodeEventMap[K]) => any, options?: boolean | EventListenerOptions): void; + removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void; +} + +declare var AudioBufferSourceNode: { + prototype: AudioBufferSourceNode; + new(context: BaseAudioContext, options?: AudioBufferSourceOptions): AudioBufferSourceNode; + isInstance(obj): obj is AudioBufferSourceNode; +}; + +/** + * An audio-processing graph built from audio modules linked together, each represented by an AudioNode. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioContext) + */ +interface AudioContext extends BaseAudioContext { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioContext/baseLatency) */ + readonly baseLatency: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioContext/outputLatency) */ + readonly outputLatency: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioContext/close) */ + close(): Promise; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioContext/createMediaElementSource) */ + createMediaElementSource(mediaElement: HTMLMediaElement): MediaElementAudioSourceNode; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioContext/createMediaStreamDestination) */ + createMediaStreamDestination(): MediaStreamAudioDestinationNode; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioContext/createMediaStreamSource) */ + createMediaStreamSource(mediaStream: MediaStream): MediaStreamAudioSourceNode; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioContext/createMediaStreamTrackSource) */ + createMediaStreamTrackSource(mediaStreamTrack: MediaStreamTrack): MediaStreamTrackAudioSourceNode; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioContext/getOutputTimestamp) */ + getOutputTimestamp(): AudioTimestamp; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioContext/suspend) */ + suspend(): Promise; + addEventListener(type: K, listener: (this: AudioContext, ev: BaseAudioContextEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void; + addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void; + removeEventListener(type: K, listener: (this: AudioContext, ev: BaseAudioContextEventMap[K]) => any, options?: boolean | EventListenerOptions): void; + removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void; +} + +declare var AudioContext: { + prototype: AudioContext; + new(contextOptions?: AudioContextOptions): AudioContext; + isInstance(obj): obj is AudioContext; +}; + +/** + * 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. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioDestinationNode) + */ +interface AudioDestinationNode extends AudioNode { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioDestinationNode/maxChannelCount) */ + readonly maxChannelCount: number; +} + +declare var AudioDestinationNode: { + prototype: AudioDestinationNode; + new(): AudioDestinationNode; + isInstance(obj): obj is AudioDestinationNode; +}; + +/** + * 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. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioListener) + */ +interface AudioListener { + /** + * @deprecated + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioListener/setOrientation) + */ + setOrientation(x: number, y: number, z: number, xUp: number, yUp: number, zUp: number): void; + /** + * @deprecated + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioListener/setPosition) + */ + setPosition(x: number, y: number, z: number): void; +} + +declare var AudioListener: { + prototype: AudioListener; + new(): AudioListener; + isInstance(obj): obj is AudioListener; +}; + +/** + * A generic interface for representing an audio processing module. Examples include: + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioNode) + */ +interface AudioNode extends EventTarget { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioNode/channelCount) */ + channelCount: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioNode/channelCountMode) */ + channelCountMode: ChannelCountMode; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioNode/channelInterpretation) */ + channelInterpretation: ChannelInterpretation; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioNode/context) */ + readonly context: BaseAudioContext; + readonly id: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioNode/numberOfInputs) */ + readonly numberOfInputs: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioNode/numberOfOutputs) */ + readonly numberOfOutputs: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioNode/connect) */ + connect(destination: AudioNode, output?: number, input?: number): AudioNode; + connect(destination: AudioParam, output?: number): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioNode/disconnect) */ + disconnect(): void; + disconnect(output: number): void; + disconnect(destination: AudioNode): void; + disconnect(destination: AudioNode, output: number): void; + disconnect(destination: AudioNode, output: number, input: number): void; + disconnect(destination: AudioParam): void; + disconnect(destination: AudioParam, output: number): void; +} + +declare var AudioNode: { + prototype: AudioNode; + new(): AudioNode; + isInstance(obj): obj is AudioNode; +}; + +interface AudioNodePassThrough { + passThrough: boolean; +} + +/** + * The Web Audio API's AudioParam interface represents an audio-related parameter, usually a parameter of an AudioNode (such as GainNode.gain). + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioParam) + */ +interface AudioParam { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioParam/defaultValue) */ + readonly defaultValue: number; + readonly isTrackSuspended: boolean; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioParam/maxValue) */ + readonly maxValue: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioParam/minValue) */ + readonly minValue: number; + readonly name: string; + readonly parentNodeId: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioParam/value) */ + value: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioParam/cancelScheduledValues) */ + cancelScheduledValues(startTime: number): AudioParam; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioParam/exponentialRampToValueAtTime) */ + exponentialRampToValueAtTime(value: number, endTime: number): AudioParam; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioParam/linearRampToValueAtTime) */ + linearRampToValueAtTime(value: number, endTime: number): AudioParam; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioParam/setTargetAtTime) */ + setTargetAtTime(target: number, startTime: number, timeConstant: number): AudioParam; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioParam/setValueAtTime) */ + setValueAtTime(value: number, startTime: number): AudioParam; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioParam/setValueCurveAtTime) */ + setValueCurveAtTime(values: number[] | Float32Array, startTime: number, duration: number): AudioParam; +} + +declare var AudioParam: { + prototype: AudioParam; + new(): AudioParam; + isInstance(obj): obj is AudioParam; +}; + +/** + * Available only in secure contexts. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioParamMap) + */ +interface AudioParamMap { + forEach(callbackfn: (value: AudioParam, key: string, parent: AudioParamMap) => void, thisArg?: any): void; +} + +declare var AudioParamMap: { + prototype: AudioParamMap; + new(): AudioParamMap; + isInstance(obj): obj is AudioParamMap; +}; + +/** + * The Web Audio API events that occur when a ScriptProcessorNode input buffer is ready to be processed. + * @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. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioProcessingEvent) + */ +interface AudioProcessingEvent extends Event { + /** + * @deprecated + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioProcessingEvent/inputBuffer) + */ + readonly inputBuffer: AudioBuffer; + /** + * @deprecated + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioProcessingEvent/outputBuffer) + */ + readonly outputBuffer: AudioBuffer; + /** + * @deprecated + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioProcessingEvent/playbackTime) + */ + readonly playbackTime: number; +} + +/** @deprecated */ +declare var AudioProcessingEvent: { + prototype: AudioProcessingEvent; + new(): AudioProcessingEvent; + isInstance(obj): obj is AudioProcessingEvent; +}; + +interface AudioScheduledSourceNodeEventMap { + "ended": Event; +} + +/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioScheduledSourceNode) */ +interface AudioScheduledSourceNode extends AudioNode { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioScheduledSourceNode/ended_event) */ + onended: ((this: AudioScheduledSourceNode, ev: Event) => any) | null; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioScheduledSourceNode/start) */ + start(when?: number): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioScheduledSourceNode/stop) */ + stop(when?: number): void; + addEventListener(type: K, listener: (this: AudioScheduledSourceNode, ev: AudioScheduledSourceNodeEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void; + addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void; + removeEventListener(type: K, listener: (this: AudioScheduledSourceNode, ev: AudioScheduledSourceNodeEventMap[K]) => any, options?: boolean | EventListenerOptions): void; + removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void; +} + +declare var AudioScheduledSourceNode: { + prototype: AudioScheduledSourceNode; + new(): AudioScheduledSourceNode; + isInstance(obj): obj is AudioScheduledSourceNode; +}; + +/** + * A single audio track from one of the HTML media elements,