Skip to content
Permalink
main
Switch branches/tags
Go to file
* Update LKG.

* Remove unnecessary assertions.
12 contributors

Users who have contributed to this file

@mhegazy @DanielRosenwasser @weswigham @rbuckton @andy-ms @billti @vladima @SeaRyanC @RyanCavanaugh @ntrrgc @benbraou @andrewbranch
/*! *****************************************************************************
Copyright (c) Microsoft Corporation. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use
this file except in compliance with the License. You may obtain a copy of the
License at http://www.apache.org/licenses/LICENSE-2.0
THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
MERCHANTABLITY OR NON-INFRINGEMENT.
See the Apache Version 2.0 License for specific language governing permissions
and limitations under the License.
***************************************************************************** */
/// <reference no-default-lib="true"/>
/////////////////////////////
/// Window APIs
/////////////////////////////
interface AddEventListenerOptions extends EventListenerOptions {
once?: boolean;
passive?: boolean;
signal?: AbortSignal;
}
interface AesCbcParams extends Algorithm {
iv: BufferSource;
}
interface AesCtrParams extends Algorithm {
counter: BufferSource;
length: number;
}
interface AesDerivedKeyParams extends Algorithm {
length: number;
}
interface AesGcmParams extends Algorithm {
additionalData?: BufferSource;
iv: BufferSource;
tagLength?: number;
}
interface AesKeyAlgorithm extends KeyAlgorithm {
length: number;
}
interface AesKeyGenParams extends Algorithm {
length: number;
}
interface Algorithm {
name: 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 AssignedNodesOptions {
flatten?: boolean;
}
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;
spatialRendering?: boolean;
}
interface AudioContextOptions {
latencyHint?: AudioContextLatencyCategory | number;
sampleRate?: number;
}
interface AudioNodeOptions {
channelCount?: number;
channelCountMode?: ChannelCountMode;
channelInterpretation?: ChannelInterpretation;
}
interface AudioProcessingEventInit extends EventInit {
inputBuffer: AudioBuffer;
outputBuffer: AudioBuffer;
playbackTime: number;
}
interface AudioTimestamp {
contextTime?: number;
performanceTime?: DOMHighResTimeStamp;
}
interface AudioWorkletNodeOptions extends AudioNodeOptions {
numberOfInputs?: number;
numberOfOutputs?: number;
outputChannelCount?: number[];
parameterData?: Record<string, number>;
processorOptions?: any;
}
interface AuthenticationExtensionsClientInputs {
appid?: string;
appidExclude?: string;
credProps?: boolean;
uvm?: boolean;
}
interface AuthenticationExtensionsClientOutputs {
appid?: boolean;
credProps?: CredentialPropertiesOutput;
uvm?: UvmEntries;
}
interface AuthenticatorSelectionCriteria {
authenticatorAttachment?: AuthenticatorAttachment;
requireResidentKey?: boolean;
residentKey?: ResidentKeyRequirement;
userVerification?: UserVerificationRequirement;
}
interface BiquadFilterOptions extends AudioNodeOptions {
Q?: number;
detune?: number;
frequency?: number;
gain?: number;
type?: BiquadFilterType;
}
interface BlobEventInit {
data: Blob;
timecode?: DOMHighResTimeStamp;
}
interface BlobPropertyBag {
endings?: EndingType;
type?: string;
}
interface CacheQueryOptions {
ignoreMethod?: boolean;
ignoreSearch?: boolean;
ignoreVary?: boolean;
}
interface CanvasRenderingContext2DSettings {
alpha?: boolean;
colorSpace?: PredefinedColorSpace;
desynchronized?: boolean;
}
interface ChannelMergerOptions extends AudioNodeOptions {
numberOfInputs?: number;
}
interface ChannelSplitterOptions extends AudioNodeOptions {
numberOfOutputs?: number;
}
interface ClientQueryOptions {
includeUncontrolled?: boolean;
type?: ClientTypes;
}
interface ClipboardEventInit extends EventInit {
clipboardData?: DataTransfer | null;
}
interface ClipboardItemOptions {
presentationStyle?: PresentationStyle;
}
interface CloseEventInit extends EventInit {
code?: number;
reason?: string;
wasClean?: boolean;
}
interface CompositionEventInit extends UIEventInit {
data?: string;
}
interface ComputedEffectTiming extends EffectTiming {
activeDuration?: number;
currentIteration?: number | null;
endTime?: number;
localTime?: number | null;
progress?: number | null;
startTime?: number;
}
interface ComputedKeyframe {
composite: CompositeOperationOrAuto;
computedOffset: number;
easing: string;
offset: number | null;
[property: string]: string | number | null | undefined;
}
interface ConstantSourceOptions {
offset?: number;
}
interface ConstrainBooleanParameters {
exact?: boolean;
ideal?: boolean;
}
interface ConstrainDOMStringParameters {
exact?: string | string[];
ideal?: string | string[];
}
interface ConstrainDoubleRange extends DoubleRange {
exact?: number;
ideal?: number;
}
interface ConstrainULongRange extends ULongRange {
exact?: number;
ideal?: number;
}
interface ConvolverOptions extends AudioNodeOptions {
buffer?: AudioBuffer | null;
disableNormalization?: boolean;
}
interface CredentialCreationOptions {
publicKey?: PublicKeyCredentialCreationOptions;
signal?: AbortSignal;
}
interface CredentialPropertiesOutput {
rk?: boolean;
}
interface CredentialRequestOptions {
mediation?: CredentialMediationRequirement;
publicKey?: PublicKeyCredentialRequestOptions;
signal?: AbortSignal;
}
interface CryptoKeyPair {
privateKey?: CryptoKey;
publicKey?: CryptoKey;
}
interface CustomEventInit<T = any> extends EventInit {
detail?: T;
}
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 DelayOptions extends AudioNodeOptions {
delayTime?: number;
maxDelayTime?: number;
}
interface DeviceMotionEventAccelerationInit {
x?: number | null;
y?: number | null;
z?: number | null;
}
interface DeviceMotionEventInit extends EventInit {
acceleration?: DeviceMotionEventAccelerationInit;
accelerationIncludingGravity?: DeviceMotionEventAccelerationInit;
interval?: number;
rotationRate?: DeviceMotionEventRotationRateInit;
}
interface DeviceMotionEventRotationRateInit {
alpha?: number | null;
beta?: number | null;
gamma?: number | null;
}
interface DeviceOrientationEventInit extends EventInit {
absolute?: boolean;
alpha?: number | null;
beta?: number | null;
gamma?: number | null;
}
interface DisplayMediaStreamConstraints {
audio?: boolean | MediaTrackConstraints;
video?: boolean | MediaTrackConstraints;
}
interface DocumentTimelineOptions {
originTime?: DOMHighResTimeStamp;
}
interface DoubleRange {
max?: number;
min?: number;
}
interface DragEventInit extends MouseEventInit {
dataTransfer?: DataTransfer | null;
}
interface DynamicsCompressorOptions extends AudioNodeOptions {
attack?: number;
knee?: number;
ratio?: number;
release?: number;
threshold?: number;
}
interface EcKeyAlgorithm extends KeyAlgorithm {
namedCurve: NamedCurve;
}
interface EcKeyGenParams extends Algorithm {
namedCurve: NamedCurve;
}
interface EcKeyImportParams extends Algorithm {
namedCurve: NamedCurve;
}
interface EcdhKeyDeriveParams extends Algorithm {
public: CryptoKey;
}
interface EcdsaParams extends Algorithm {
hash: HashAlgorithmIdentifier;
}
interface EffectTiming {
delay?: number;
direction?: PlaybackDirection;
duration?: number | string;
easing?: string;
endDelay?: number;
fill?: FillMode;
iterationStart?: number;
iterations?: number;
playbackRate?: number;
}
interface ElementCreationOptions {
is?: string;
}
interface ElementDefinitionOptions {
extends?: string;
}
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;
}
interface EventModifierInit extends UIEventInit {
altKey?: boolean;
ctrlKey?: boolean;
metaKey?: boolean;
modifierAltGraph?: boolean;
modifierCapsLock?: boolean;
modifierFn?: boolean;
modifierFnLock?: boolean;
modifierHyper?: boolean;
modifierNumLock?: boolean;
modifierScrollLock?: boolean;
modifierSuper?: boolean;
modifierSymbol?: boolean;
modifierSymbolLock?: boolean;
shiftKey?: boolean;
}
interface EventSourceInit {
withCredentials?: boolean;
}
interface FilePropertyBag extends BlobPropertyBag {
lastModified?: number;
}
interface FileSystemFlags {
create?: boolean;
exclusive?: boolean;
}
interface FocusEventInit extends UIEventInit {
relatedTarget?: EventTarget | null;
}
interface FocusOptions {
preventScroll?: boolean;
}
interface FontFaceDescriptors {
display?: string;
featureSettings?: string;
stretch?: string;
style?: string;
unicodeRange?: string;
variant?: string;
weight?: string;
}
interface FontFaceSetLoadEventInit extends EventInit {
fontfaces?: FontFace[];
}
interface FormDataEventInit extends EventInit {
formData: FormData;
}
interface FullscreenOptions {
navigationUI?: FullscreenNavigationUI;
}
interface GainOptions extends AudioNodeOptions {
gain?: number;
}
interface GamepadEventInit extends EventInit {
gamepad: Gamepad;
}
interface GetAnimationsOptions {
subtree?: boolean;
}
interface GetNotificationOptions {
tag?: string;
}
interface GetRootNodeOptions {
composed?: boolean;
}
interface HashChangeEventInit extends EventInit {
newURL?: string;
oldURL?: string;
}
interface HkdfParams extends Algorithm {
hash: HashAlgorithmIdentifier;
info: BufferSource;
salt: BufferSource;
}
interface HmacImportParams extends Algorithm {
hash: HashAlgorithmIdentifier;
length?: number;
}
interface HmacKeyAlgorithm extends KeyAlgorithm {
hash: KeyAlgorithm;
length: number;
}
interface HmacKeyGenParams extends Algorithm {
hash: HashAlgorithmIdentifier;
length?: number;
}
interface IDBDatabaseInfo {
name?: string;
version?: number;
}
interface IDBIndexParameters {
multiEntry?: boolean;
unique?: boolean;
}
interface IDBObjectStoreParameters {
autoIncrement?: boolean;
keyPath?: string | string[] | null;
}
interface IDBVersionChangeEventInit extends EventInit {
newVersion?: number | null;
oldVersion?: number;
}
interface IIRFilterOptions extends AudioNodeOptions {
feedback: number[];
feedforward: number[];
}
interface IdleRequestOptions {
timeout?: number;
}
interface ImageBitmapOptions {
colorSpaceConversion?: ColorSpaceConversion;
imageOrientation?: ImageOrientation;
premultiplyAlpha?: PremultiplyAlpha;
resizeHeight?: number;
resizeQuality?: ResizeQuality;
resizeWidth?: number;
}
interface ImageBitmapRenderingContextSettings {
alpha?: boolean;
}
interface ImageDataSettings {
colorSpace?: PredefinedColorSpace;
}
interface ImportMeta {
url: string;
}
interface InputEventInit extends UIEventInit {
data?: string | null;
dataTransfer?: DataTransfer | null;
inputType?: string;
isComposing?: boolean;
targetRanges?: StaticRange[];
}
interface IntersectionObserverEntryInit {
boundingClientRect: DOMRectInit;
intersectionRatio: number;
intersectionRect: DOMRectInit;
isIntersecting: boolean;
rootBounds: DOMRectInit | null;
target: Element;
time: DOMHighResTimeStamp;
}
interface IntersectionObserverInit {
root?: Element | Document | null;
rootMargin?: string;
threshold?: number | number[];
}
interface JsonWebKey {
alg?: string;
crv?: string;
d?: string;
dp?: string;
dq?: string;
e?: string;
ext?: boolean;
k?: string;
key_ops?: string[];
kty?: string;
n?: string;
oth?: RsaOtherPrimesInfo[];
p?: string;
q?: string;
qi?: string;
use?: string;
x?: string;
y?: string;
}
interface KeyAlgorithm {
name: string;
}
interface KeyboardEventInit extends EventModifierInit {
/** @deprecated */
charCode?: number;
code?: string;
isComposing?: boolean;
key?: string;
/** @deprecated */
keyCode?: number;
location?: number;
repeat?: boolean;
}
interface Keyframe {
composite?: CompositeOperationOrAuto;
easing?: string;
offset?: number | null;
[property: string]: string | number | null | undefined;
}
interface KeyframeAnimationOptions extends KeyframeEffectOptions {
id?: string;
}
interface KeyframeEffectOptions extends EffectTiming {
composite?: CompositeOperation;
iterationComposite?: IterationCompositeOperation;
pseudoElement?: string | null;
}
interface MediaCapabilitiesDecodingInfo extends MediaCapabilitiesInfo {
configuration?: MediaDecodingConfiguration;
}
interface MediaCapabilitiesEncodingInfo extends MediaCapabilitiesInfo {
configuration?: MediaEncodingConfiguration;
}
interface MediaCapabilitiesInfo {
powerEfficient: boolean;
smooth: boolean;
supported: boolean;
}
interface MediaConfiguration {
audio?: AudioConfiguration;
video?: VideoConfiguration;
}
interface MediaDecodingConfiguration extends MediaConfiguration {
type: MediaDecodingType;
}
interface MediaElementAudioSourceOptions {
mediaElement: HTMLMediaElement;
}
interface MediaEncodingConfiguration extends MediaConfiguration {
type: MediaEncodingType;
}
interface MediaEncryptedEventInit extends EventInit {
initData?: ArrayBuffer | null;
initDataType?: string;
}
interface MediaImage {
sizes?: string;
src: string;
type?: string;
}
interface MediaKeyMessageEventInit extends EventInit {
message: ArrayBuffer;
messageType: MediaKeyMessageType;
}
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 MediaMetadataInit {
album?: string;
artist?: string;
artwork?: MediaImage[];
title?: string;
}
interface MediaPositionState {
duration?: number;
playbackRate?: number;
position?: number;
}
interface MediaQueryListEventInit extends EventInit {
matches?: boolean;
media?: string;
}
interface MediaRecorderErrorEventInit extends EventInit {
error: DOMException;
}
interface MediaRecorderOptions {
audioBitsPerSecond?: number;
bitsPerSecond?: number;
mimeType?: string;
videoBitsPerSecond?: number;
}
interface MediaSessionActionDetails {
action: MediaSessionAction;
fastSeek?: boolean | null;
seekOffset?: number | null;
seekTime?: number | null;
}
interface MediaStreamAudioSourceOptions {
mediaStream: MediaStream;
}
interface MediaStreamConstraints {
audio?: boolean | MediaTrackConstraints;
peerIdentity?: string;
video?: boolean | MediaTrackConstraints;
}
interface MediaStreamTrackEventInit extends EventInit {
track: MediaStreamTrack;
}
interface MediaTrackCapabilities {
aspectRatio?: DoubleRange;
autoGainControl?: boolean[];
channelCount?: ULongRange;
cursor?: string[];
deviceId?: string;
displaySurface?: string;
echoCancellation?: boolean[];
facingMode?: string[];
frameRate?: DoubleRange;
groupId?: string;
height?: ULongRange;
latency?: DoubleRange;
logicalSurface?: boolean;
noiseSuppression?: boolean[];
resizeMode?: string[];
sampleRate?: ULongRange;
sampleSize?: ULongRange;
width?: ULongRange;
}
interface MediaTrackConstraintSet {
aspectRatio?: ConstrainDouble;
channelCount?: ConstrainULong;
deviceId?: ConstrainDOMString;
echoCancellation?: ConstrainBoolean;
facingMode?: ConstrainDOMString;
frameRate?: ConstrainDouble;
groupId?: ConstrainDOMString;
height?: ConstrainULong;
latency?: ConstrainDouble;
sampleRate?: ConstrainULong;
sampleSize?: ConstrainULong;
suppressLocalAudioPlayback?: ConstrainBoolean;
width?: ConstrainULong;
}
interface MediaTrackConstraints extends MediaTrackConstraintSet {
advanced?: MediaTrackConstraintSet[];
}
interface MediaTrackSettings {
aspectRatio?: number;
deviceId?: string;
echoCancellation?: boolean;
facingMode?: string;
frameRate?: number;
groupId?: string;
height?: number;
restrictOwnAudio?: boolean;
sampleRate?: number;
sampleSize?: number;
width?: number;
}
interface MediaTrackSupportedConstraints {
aspectRatio?: boolean;
deviceId?: boolean;
echoCancellation?: boolean;
facingMode?: boolean;
frameRate?: boolean;
groupId?: boolean;
height?: boolean;
sampleRate?: boolean;
sampleSize?: boolean;
suppressLocalAudioPlayback?: boolean;
width?: boolean;
}
interface MessageEventInit<T = any> extends EventInit {
data?: T;
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 MultiCacheQueryOptions extends CacheQueryOptions {
cacheName?: string;
}
interface MutationObserverInit {
/**
* Set to a list of attribute local names (without namespace) if not all attribute mutations need to be observed and attributes is true or omitted.
*/
attributeFilter?: string[];
/**
* Set to true if attributes is true or omitted and target's attribute value before the mutation needs to be recorded.
*/
attributeOldValue?: boolean;
/**
* Set to true if mutations to target's attributes are to be observed. Can be omitted if attributeOldValue or attributeFilter is specified.
*/
attributes?: boolean;
/**
* Set to true if mutations to target's data are to be observed. Can be omitted if characterDataOldValue is specified.
*/
characterData?: boolean;
/**
* Set to true if characterData is set to true or omitted and target's data before the mutation needs to be recorded.
*/
characterDataOldValue?: boolean;
/**
* Set to true if mutations to target's children are to be observed.
*/
childList?: boolean;
/**
* Set to true if mutations to not just target, but also target's descendants are to be observed.
*/
subtree?: boolean;
}
interface NotificationAction {
action: string;
icon?: string;
title: string;
}
interface NotificationOptions {
actions?: NotificationAction[];
badge?: string;
body?: string;
data?: any;
dir?: NotificationDirection;
icon?: string;
image?: string;
lang?: string;
renotify?: boolean;
requireInteraction?: boolean;
silent?: boolean;
tag?: string;
timestamp?: DOMTimeStamp;
vibrate?: VibratePattern;
}
interface OfflineAudioCompletionEventInit extends EventInit {
renderedBuffer: AudioBuffer;
}
interface OfflineAudioContextOptions {
length: number;
numberOfChannels?: number;
sampleRate: number;
}
interface OptionalEffectTiming {
delay?: number;
direction?: PlaybackDirection;
duration?: number | string;
easing?: string;
endDelay?: number;
fill?: FillMode;
iterationStart?: number;
iterations?: number;
playbackRate?: number;
}
interface OscillatorOptions extends AudioNodeOptions {
detune?: number;
frequency?: number;
periodicWave?: PeriodicWave;
type?: OscillatorType;
}
interface PageTransitionEventInit extends EventInit {
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 PaymentCurrencyAmount {
currency: string;
value: string;
}
interface PaymentDetailsBase {
displayItems?: PaymentItem[];
modifiers?: PaymentDetailsModifier[];
}
interface PaymentDetailsInit extends PaymentDetailsBase {
id?: string;
total: PaymentItem;
}
interface PaymentDetailsModifier {
additionalDisplayItems?: PaymentItem[];
data?: any;
supportedMethods: string;
total?: PaymentItem;
}
interface PaymentDetailsUpdate extends PaymentDetailsBase {
paymentMethodErrors?: any;
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 PaymentRequestUpdateEventInit extends EventInit {
}
interface PaymentValidationErrors {
error?: string;
paymentMethod?: any;
}
interface Pbkdf2Params extends Algorithm {
hash: HashAlgorithmIdentifier;
iterations: number;
salt: BufferSource;
}
interface PerformanceMarkOptions {
detail?: any;
startTime?: DOMHighResTimeStamp;
}
interface PerformanceMeasureOptions {
detail?: any;
duration?: DOMHighResTimeStamp;
end?: string | DOMHighResTimeStamp;
start?: string | DOMHighResTimeStamp;
}
interface PerformanceObserverInit {
buffered?: boolean;
entryTypes?: string[];
type?: string;
}
interface PeriodicWaveConstraints {
disableNormalization?: boolean;
}
interface PeriodicWaveOptions extends PeriodicWaveConstraints {
imag?: number[] | Float32Array;
real?: number[] | Float32Array;
}
interface PermissionDescriptor {
name: PermissionName;
}
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 PositionOptions {
enableHighAccuracy?: boolean;
maximumAge?: number;
timeout?: number;
}
interface PostMessageOptions {
transfer?: any[];
}
interface ProgressEventInit extends EventInit {
lengthComputable?: boolean;
loaded?: number;
total?: number;
}
interface PromiseRejectionEventInit extends EventInit {
promise: Promise<any>;
reason?: any;
}
interface PropertyIndexedKeyframes {
composite?: CompositeOperationOrAuto | CompositeOperationOrAuto[];
easing?: string | string[];
offset?: number | (number | null)[];
[property: string]: string | string[] | number | null | (number | null)[] | undefined;
}
interface PublicKeyCredentialCreationOptions {
attestation?: AttestationConveyancePreference;
authenticatorSelection?: AuthenticatorSelectionCriteria;
challenge: BufferSource;
excludeCredentials?: PublicKeyCredentialDescriptor[];
extensions?: AuthenticationExtensionsClientInputs;
pubKeyCredParams: PublicKeyCredentialParameters[];
rp: PublicKeyCredentialRpEntity;
timeout?: number;
user: PublicKeyCredentialUserEntity;
}
interface PublicKeyCredentialDescriptor {
id: BufferSource;
transports?: AuthenticatorTransport[];
type: PublicKeyCredentialType;
}
interface PublicKeyCredentialEntity {
name: string;
}
interface PublicKeyCredentialParameters {
alg: COSEAlgorithmIdentifier;
type: PublicKeyCredentialType;
}
interface PublicKeyCredentialRequestOptions {
allowCredentials?: PublicKeyCredentialDescriptor[];
challenge: BufferSource;
extensions?: AuthenticationExtensionsClientInputs;
rpId?: string;
timeout?: number;
userVerification?: UserVerificationRequirement;
}
interface PublicKeyCredentialRpEntity extends PublicKeyCredentialEntity {
id?: string;
}
interface PublicKeyCredentialUserEntity extends PublicKeyCredentialEntity {
displayName: string;
id: BufferSource;
}
interface PushSubscriptionJSON {
endpoint?: string;
expirationTime?: DOMTimeStamp | null;
keys?: Record<string, string>;
}
interface PushSubscriptionOptionsInit {
applicationServerKey?: BufferSource | string | null;
userVisibleOnly?: boolean;
}
interface QueuingStrategy<T = any> {
highWaterMark?: number;
size?: QueuingStrategySize<T>;
}
interface QueuingStrategyInit {
/**
* Creates a new ByteLengthQueuingStrategy with the provided high water mark.
*
* Note that the provided high water mark will not be validated ahead of time. Instead, if it is negative, NaN, or not a number, the resulting ByteLengthQueuingStrategy will cause the corresponding stream constructor to throw.
*/
highWaterMark: number;
}
interface RTCAnswerOptions extends RTCOfferAnswerOptions {
}
interface RTCCertificateExpiration {
expires?: DOMTimeStamp;
}
interface RTCConfiguration {
bundlePolicy?: RTCBundlePolicy;
certificates?: RTCCertificate[];
iceCandidatePoolSize?: number;
iceServers?: RTCIceServer[];
iceTransportPolicy?: RTCIceTransportPolicy;
rtcpMuxPolicy?: RTCRtcpMuxPolicy;
}
interface RTCDTMFToneChangeEventInit extends EventInit {
tone?: string;
}
interface RTCDataChannelEventInit extends EventInit {
channel: RTCDataChannel;
}
interface RTCDataChannelInit {
id?: number;
maxPacketLifeTime?: number;
maxRetransmits?: number;
negotiated?: boolean;
ordered?: boolean;
protocol?: string;
}
interface RTCDtlsFingerprint {
algorithm?: string;
value?: string;
}
interface RTCIceCandidateInit {
candidate?: string;
sdpMLineIndex?: number | null;
sdpMid?: string | null;
usernameFragment?: string | null;
}
interface RTCIceCandidatePairStats extends RTCStats {
availableIncomingBitrate?: number;
availableOutgoingBitrate?: number;
bytesReceived?: number;
bytesSent?: number;
currentRoundTripTime?: number;
localCandidateId: string;
nominated?: boolean;
remoteCandidateId: string;
requestsReceived?: number;
requestsSent?: number;
responsesReceived?: number;
responsesSent?: number;
state: RTCStatsIceCandidatePairState;
totalRoundTripTime?: number;
transportId: string;
}
interface RTCIceServer {
credential?: string;
credentialType?: RTCIceCredentialType;
urls: string | string[];
username?: string;
}
interface RTCInboundRtpStreamStats extends RTCReceivedRtpStreamStats {
firCount?: number;
framesDecoded?: number;
nackCount?: number;
pliCount?: number;
qpSum?: number;
remoteId?: string;
}
interface RTCLocalSessionDescriptionInit {
sdp?: string;
type?: RTCSdpType;
}
interface RTCOfferAnswerOptions {
}
interface RTCOfferOptions extends RTCOfferAnswerOptions {
iceRestart?: boolean;
offerToReceiveAudio?: boolean;
offerToReceiveVideo?: boolean;
}
interface RTCOutboundRtpStreamStats extends RTCSentRtpStreamStats {
firCount?: number;
framesEncoded?: number;
nackCount?: number;
pliCount?: number;
qpSum?: number;
remoteId?: string;
}
interface RTCPeerConnectionIceErrorEventInit extends EventInit {
address?: string | null;
errorCode: number;
errorText?: string;
port?: number | null;
url?: string;
}
interface RTCPeerConnectionIceEventInit extends EventInit {
candidate?: RTCIceCandidate | null;
url?: string | null;
}
interface RTCReceivedRtpStreamStats extends RTCRtpStreamStats {
jitter?: number;
packetsDiscarded?: number;
packetsLost?: number;
packetsReceived?: number;
}
interface RTCRtcpParameters {
cname?: string;
reducedSize?: boolean;
}
interface RTCRtpCapabilities {
codecs: RTCRtpCodecCapability[];
headerExtensions: RTCRtpHeaderExtensionCapability[];
}
interface RTCRtpCodecCapability {
channels?: number;
clockRate: number;
mimeType: string;
sdpFmtpLine?: string;
}
interface RTCRtpCodecParameters {
channels?: number;
clockRate: number;
mimeType: string;
payloadType: number;
sdpFmtpLine?: string;
}
interface RTCRtpCodingParameters {
rid?: string;
}
interface RTCRtpContributingSource {
audioLevel?: number;
rtpTimestamp: number;
source: number;
timestamp: DOMHighResTimeStamp;
}
interface RTCRtpEncodingParameters extends RTCRtpCodingParameters {
active?: boolean;
maxBitrate?: number;
priority?: RTCPriorityType;
scaleResolutionDownBy?: number;
}
interface RTCRtpHeaderExtensionCapability {
uri?: string;
}
interface RTCRtpHeaderExtensionParameters {
encrypted?: boolean;
id: number;
uri: string;
}
interface RTCRtpParameters {
codecs: RTCRtpCodecParameters[];
headerExtensions: RTCRtpHeaderExtensionParameters[];
rtcp: RTCRtcpParameters;
}
interface RTCRtpReceiveParameters extends RTCRtpParameters {
}
interface RTCRtpSendParameters extends RTCRtpParameters {
degradationPreference?: RTCDegradationPreference;
encodings: RTCRtpEncodingParameters[];
transactionId: string;
}
interface RTCRtpStreamStats extends RTCStats {
codecId?: string;
kind: string;
ssrc: number;
transportId?: string;
}
interface RTCRtpSynchronizationSource extends RTCRtpContributingSource {
}
interface RTCRtpTransceiverInit {
direction?: RTCRtpTransceiverDirection;
sendEncodings?: RTCRtpEncodingParameters[];
streams?: MediaStream[];
}
interface RTCSentRtpStreamStats extends RTCRtpStreamStats {
bytesSent?: number;
packetsSent?: number;
}
interface RTCSessionDescriptionInit {
sdp?: string;
type: RTCSdpType;
}
interface RTCStats {
id: string;
timestamp: DOMHighResTimeStamp;
type: RTCStatsType;
}
interface RTCTrackEventInit extends EventInit {
receiver: RTCRtpReceiver;
streams?: MediaStream[];
track: MediaStreamTrack;
transceiver: RTCRtpTransceiver;
}
interface RTCTransportStats extends RTCStats {
bytesReceived?: number;
bytesSent?: number;
dtlsCipher?: string;
dtlsState: RTCDtlsTransportState;
localCertificateId?: string;
remoteCertificateId?: string;
rtcpTransportStatsId?: string;
selectedCandidatePairId?: string;
srtpCipher?: string;
tlsVersion?: string;
}
interface ReadableStreamDefaultReadDoneResult {
done: true;
value?: undefined;
}
interface ReadableStreamDefaultReadValueResult<T> {
done: false;
value: T;
}
interface ReadableWritablePair<R = any, W = any> {
readable: ReadableStream<R>;
/**
* Provides a convenient, chainable way of piping this readable stream through a transform stream (or any other { writable, readable } pair). It simply pipes the stream into the writable side of the supplied pair, and returns the readable side for further use.
*
* Piping a stream will lock it for the duration of the pipe, preventing any other consumer from acquiring a reader.
*/
writable: WritableStream<W>;
}
interface RegistrationOptions {
scope?: string;
type?: WorkerType;
updateViaCache?: ServiceWorkerUpdateViaCache;
}
interface RequestInit {
/**
* A BodyInit object or null to set request's body.
*/
body?: BodyInit | null;
/**
* A string indicating how the request will interact with the browser's cache to set request's cache.
*/
cache?: RequestCache;
/**
* A string indicating whether credentials will be sent with the request always, never, or only when sent to a same-origin URL. Sets request's credentials.
*/
credentials?: RequestCredentials;
/**
* A Headers object, an object literal, or an array of two-item arrays to set request's headers.
*/
headers?: HeadersInit;
/**
* A cryptographic hash of the resource to be fetched by request. Sets request's integrity.
*/
integrity?: string;
/**
* A boolean to set request's keepalive.
*/
keepalive?: boolean;
/**
* A string to set request's method.
*/
method?: string;
/**
* A string to indicate whether the request will use CORS, or will be restricted to same-origin URLs. Sets request's mode.
*/
mode?: RequestMode;
/**
* A string indicating whether request follows redirects, results in an error upon encountering a redirect, or returns the redirect (in an opaque fashion). Sets request's redirect.
*/
redirect?: RequestRedirect;
/**
* A string whose value is a same-origin URL, "about:client", or the empty string, to set request's referrer.
*/
referrer?: string;
/**
* A referrer policy to set request's referrerPolicy.
*/
referrerPolicy?: ReferrerPolicy;
/**
* An AbortSignal to set request's signal.
*/
signal?: AbortSignal | null;
/**
* Can only be null. Used to disassociate request from any Window.
*/
window?: any;
}
interface ResizeObserverOptions {
box?: ResizeObserverBoxOptions;
}
interface ResponseInit {
headers?: HeadersInit;
status?: number;
statusText?: string;
}
interface RsaHashedImportParams extends Algorithm {
hash: HashAlgorithmIdentifier;
}
interface RsaHashedKeyAlgorithm extends RsaKeyAlgorithm {
hash: KeyAlgorithm;
}
interface RsaHashedKeyGenParams extends RsaKeyGenParams {
hash: HashAlgorithmIdentifier;
}
interface RsaKeyAlgorithm extends KeyAlgorithm {
modulusLength: number;
publicExponent: BigInteger;
}
interface RsaKeyGenParams extends Algorithm {
modulusLength: number;
publicExponent: BigInteger;
}
interface RsaOaepParams extends Algorithm {
label?: BufferSource;
}
interface RsaOtherPrimesInfo {
d?: string;
r?: string;
t?: string;
}
interface RsaPssParams extends Algorithm {
saltLength: number;
}
interface SVGBoundingBoxOptions {
clipped?: boolean;
fill?: boolean;
markers?: boolean;
stroke?: boolean;
}
interface ScrollIntoViewOptions extends ScrollOptions {
block?: ScrollLogicalPosition;
inline?: ScrollLogicalPosition;
}
interface ScrollOptions {
behavior?: ScrollBehavior;
}
interface ScrollToOptions extends ScrollOptions {
left?: number;
top?: number;
}
interface SecurityPolicyViolationEventInit extends EventInit {
blockedURI?: string;
blockedURL?: string;
colno?: number;
columnNumber?: number;
disposition: SecurityPolicyViolationEventDisposition;
documentURI?: string;
documentURL: string;
effectiveDirective: string;
lineNumber?: number;
lineno?: number;
originalPolicy: string;
referrer?: string;
sample?: string;
sourceFile?: string;
statusCode: number;
}
interface ShadowRootInit {
delegatesFocus?: boolean;
mode: ShadowRootMode;
slotAssignment?: SlotAssignmentMode;
}
interface ShareData {
files?: File[];
text?: string;
title?: string;
url?: string;
}
interface SpeechRecognitionErrorEventInit extends EventInit {
error: SpeechRecognitionErrorCode;
message?: string;
}
interface SpeechSynthesisErrorEventInit extends SpeechSynthesisEventInit {
error: SpeechSynthesisErrorCode;
}
interface SpeechSynthesisEventInit extends EventInit {
charIndex?: number;
charLength?: number;
elapsedTime?: number;
name?: string;
utterance: SpeechSynthesisUtterance;
}
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 StreamPipeOptions {
preventAbort?: boolean;
preventCancel?: boolean;
/**
* Pipes this readable stream to a given writable stream destination. The way in which the piping process behaves under various error conditions can be customized with a number of passed options. It returns a promise that fulfills when the piping process completes successfully, or rejects if any errors were encountered.
*
* Piping a stream will lock it for the duration of the pipe, preventing any other consumer from acquiring a reader.
*
* Errors and closures of the source and destination streams propagate as follows:
*
* An error in this source readable stream will abort destination, unless preventAbort is truthy. The returned promise will be rejected with the source's error, or with any error that occurs during aborting the destination.
*
* An error in destination will cancel this source readable stream, unless preventCancel is truthy. The returned promise will be rejected with the destination's error, or with any error that occurs during canceling the source.
*
* When this source readable stream closes, destination will be closed, unless preventClose is truthy. The returned promise will be fulfilled once this process completes, unless an error is encountered while closing the destination, in which case it will be rejected with that error.
*
* If destination starts out closed or closing, this source readable stream will be canceled, unless preventCancel is true. The returned promise will be rejected with an error indicating piping to a closed stream failed, or with any error that occurs during canceling the source.
*
* The signal option can be set to an AbortSignal to allow aborting an ongoing pipe operation via the corresponding AbortController. In this case, this source readable stream will be canceled, and destination aborted, unless the respective options preventCancel or preventAbort are set.
*/
preventClose?: boolean;
signal?: AbortSignal;
}
interface SubmitEventInit extends EventInit {
submitter?: HTMLElement | null;
}
interface TextDecodeOptions {
stream?: boolean;
}
interface TextDecoderOptions {
fatal?: boolean;
ignoreBOM?: boolean;
}
interface TextEncoderEncodeIntoResult {
read?: number;
written?: number;
}
interface TouchEventInit extends EventModifierInit {
changedTouches?: Touch[];
targetTouches?: Touch[];
touches?: Touch[];
}
interface TouchInit {
altitudeAngle?: number;
azimuthAngle?: number;
clientX?: number;
clientY?: number;
force?: number;
identifier: number;
pageX?: number;
pageY?: number;
radiusX?: number;
radiusY?: number;
rotationAngle?: number;
screenX?: number;
screenY?: number;
target: EventTarget;
touchType?: TouchType;
}
interface TrackEventInit extends EventInit {
track?: TextTrack | null;
}
interface Transformer<I = any, O = any> {
flush?: TransformerFlushCallback<O>;
readableType?: undefined;
start?: TransformerStartCallback<O>;
transform?: TransformerTransformCallback<I, O>;
writableType?: undefined;
}
interface TransitionEventInit extends EventInit {
elapsedTime?: number;
propertyName?: string;
pseudoElement?: string;
}
interface UIEventInit extends EventInit {
detail?: number;
view?: Window | null;
/** @deprecated */
which?: number;
}
interface ULongRange {
max?: number;
min?: number;
}
interface UnderlyingSink<W = any> {
abort?: UnderlyingSinkAbortCallback;
close?: UnderlyingSinkCloseCallback;
start?: UnderlyingSinkStartCallback;
type?: undefined;
write?: UnderlyingSinkWriteCallback<W>;
}
interface UnderlyingSource<R = any> {
cancel?: UnderlyingSourceCancelCallback;
pull?: UnderlyingSourcePullCallback<R>;
start?: UnderlyingSourceStartCallback<R>;
type?: undefined;
}
interface VideoConfiguration {
bitrate: number;
colorGamut?: ColorGamut;
contentType: string;
framerate: number;
hdrMetadataType?: HdrMetadataType;
height: number;
scalabilityMode?: string;
transferFunction?: TransferFunction;
width: number;
}
interface WaveShaperOptions extends AudioNodeOptions {
curve?: number[] | Float32Array;
oversample?: OverSampleType;
}
interface WebGLContextAttributes {
alpha?: boolean;
antialias?: boolean;
depth?: boolean;
desynchronized?: boolean;
failIfMajorPerformanceCaveat?: boolean;
powerPreference?: WebGLPowerPreference;
premultipliedAlpha?: boolean;
preserveDrawingBuffer?: boolean;
stencil?: boolean;
}
interface WebGLContextEventInit extends EventInit {
statusMessage?: string;
}
interface WheelEventInit extends MouseEventInit {
deltaMode?: number;
deltaX?: number;
deltaY?: number;
deltaZ?: number;
}
interface WindowPostMessageOptions extends PostMessageOptions {
targetOrigin?: string;
}
interface WorkerOptions {
credentials?: RequestCredentials;
name?: string;
type?: WorkerType;
}
interface WorkletOptions {
credentials?: RequestCredentials;
}
type NodeFilter = ((node: Node) => number) | { acceptNode(node: Node): number; };
declare var NodeFilter: {
readonly FILTER_ACCEPT: number;
readonly FILTER_REJECT: number;
readonly FILTER_SKIP: number;
readonly SHOW_ALL: number;
readonly SHOW_ATTRIBUTE: number;
readonly SHOW_CDATA_SECTION: number;
readonly SHOW_COMMENT: number;
readonly SHOW_DOCUMENT: number;
readonly SHOW_DOCUMENT_FRAGMENT: number;
readonly SHOW_DOCUMENT_TYPE: number;
readonly SHOW_ELEMENT: number;
readonly SHOW_ENTITY: number;
readonly SHOW_ENTITY_REFERENCE: number;
readonly SHOW_NOTATION: number;
readonly SHOW_PROCESSING_INSTRUCTION: number;
readonly SHOW_TEXT: number;
};
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. */
interface ANGLE_instanced_arrays {
drawArraysInstancedANGLE(mode: GLenum, first: GLint, count: GLsizei, primcount: GLsizei): void;
drawElementsInstancedANGLE(mode: GLenum, count: GLsizei, type: GLenum, offset: GLintptr, primcount: GLsizei): void;
vertexAttribDivisorANGLE(index: GLuint, divisor: GLuint): void;
readonly VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE: GLenum;
}
interface ARIAMixin {
ariaAtomic: string;
ariaAutoComplete: string;
ariaBusy: string;
ariaChecked: string;
ariaColCount: string;
ariaColIndex: string;
ariaColSpan: string;
ariaCurrent: string;
ariaDisabled: string;
ariaExpanded: string;
ariaHasPopup: string;
ariaHidden: string;
ariaKeyShortcuts: string;
ariaLabel: string;
ariaLevel: string;
ariaLive: string;
ariaModal: string;
ariaMultiLine: string;
ariaMultiSelectable: string;
ariaOrientation: string;
ariaPlaceholder: string;
ariaPosInSet: string;
ariaPressed: string;
ariaReadOnly: string;
ariaRequired: string;
ariaRoleDescription: string;
ariaRowCount: string;
ariaRowIndex: string;
ariaRowSpan: string;
ariaSelected: string;
ariaSetSize: string;
ariaSort: string;
ariaValueMax: string;
ariaValueMin: string;
ariaValueNow: string;
ariaValueText: string;
}
/** A controller object that allows you to abort one or more DOM requests as and when desired. */
interface AbortController {
/**
* Returns the AbortSignal object associated with this object.
*/
readonly signal: AbortSignal;
/**
* Invoking this method will set this object's AbortSignal's aborted flag and signal to any observers that the associated activity is to be aborted.
*/
abort(): void;
}
declare var AbortController: {
prototype: AbortController;
new(): 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. */
interface AbortSignal extends EventTarget {
/**
* Returns true if this AbortSignal's AbortController has signaled to abort, and false otherwise.
*/
readonly aborted: boolean;
onabort: ((this: AbortSignal, ev: Event) => any) | null;
addEventListener<K extends keyof AbortSignalEventMap>(type: K, listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
removeEventListener<K extends keyof AbortSignalEventMap>(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;
};
interface AbstractRange {
/**
* Returns true if range is collapsed, and false otherwise.
*/
readonly collapsed: boolean;
/**
* Returns range's end node.
*/
readonly endContainer: Node;
/**
* Returns range's end offset.
*/
readonly endOffset: number;
/**
* Returns range's start node.
*/
readonly startContainer: Node;
/**
* Returns range's start offset.
*/
readonly startOffset: number;
}
declare var AbstractRange: {
prototype: AbstractRange;
new(): AbstractRange;
};
interface AbstractWorkerEventMap {
"error": ErrorEvent;
}
interface AbstractWorker {
onerror: ((this: AbstractWorker, ev: ErrorEvent) => any) | null;
addEventListener<K extends keyof AbstractWorkerEventMap>(type: K, listener: (this: AbstractWorker, ev: AbstractWorkerEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
removeEventListener<K extends keyof AbstractWorkerEventMap>(type: K, listener: (this: AbstractWorker, ev: AbstractWorkerEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
}
/** 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. */
interface AnalyserNode extends AudioNode {
fftSize: number;
readonly frequencyBinCount: number;
maxDecibels: number;
minDecibels: number;
smoothingTimeConstant: number;
getByteFrequencyData(array: Uint8Array): void;
getByteTimeDomainData(array: Uint8Array): void;
getFloatFrequencyData(array: Float32Array): void;
getFloatTimeDomainData(array: Float32Array): void;
}
declare var AnalyserNode: {
prototype: AnalyserNode;
new(context: BaseAudioContext, options?: AnalyserOptions): AnalyserNode;
};
interface Animatable {
animate(keyframes: Keyframe[] | PropertyIndexedKeyframes | null, options?: number | KeyframeAnimationOptions): Animation;
getAnimations(options?: GetAnimationsOptions): Animation[];
}
interface AnimationEventMap {
"cancel": AnimationPlaybackEvent;
"finish": AnimationPlaybackEvent;
"remove": Event;
}
interface Animation extends EventTarget {
currentTime: number | null;
effect: AnimationEffect | null;
readonly finished: Promise<Animation>;
id: string;
oncancel: ((this: Animation, ev: AnimationPlaybackEvent) => any) | null;
onfinish: ((this: Animation, ev: AnimationPlaybackEvent) => any) | null;
onremove: ((this: Animation, ev: Event) => any) | null;
readonly pending: boolean;
readonly playState: AnimationPlayState;
playbackRate: number;
readonly ready: Promise<Animation>;
readonly replaceState: AnimationReplaceState;
startTime: number | null;
timeline: AnimationTimeline | null;
cancel(): void;
commitStyles(): void;
finish(): void;
pause(): void;
persist(): void;
play(): void;
reverse(): void;
updatePlaybackRate(playbackRate: number): void;
addEventListener<K extends keyof AnimationEventMap>(type: K, listener: (this: Animation, ev: AnimationEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
removeEventListener<K extends keyof AnimationEventMap>(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;
};
interface AnimationEffect {
getComputedTiming(): ComputedEffectTiming;
getTiming(): EffectTiming;
updateTiming(timing?: OptionalEffectTiming): void;
}
declare var AnimationEffect: {
prototype: AnimationEffect;
new(): AnimationEffect;
};
/** Events providing information related to animations. */
interface AnimationEvent extends Event {
readonly animationName: string;
readonly elapsedTime: number;
readonly pseudoElement: string;
}
declare var AnimationEvent: {
prototype: AnimationEvent;
new(type: string, animationEventInitDict?: AnimationEventInit): AnimationEvent;
};
interface AnimationFrameProvider {
cancelAnimationFrame(handle: number): void;
requestAnimationFrame(callback: FrameRequestCallback): number;
}
interface AnimationPlaybackEvent extends Event {
readonly currentTime: number | null;
readonly timelineTime: number | null;
}
declare var AnimationPlaybackEvent: {
prototype: AnimationPlaybackEvent;
new(type: string, eventInitDict?: AnimationPlaybackEventInit): AnimationPlaybackEvent;
};
interface AnimationTimeline {
readonly currentTime: number | null;
}
declare var AnimationTimeline: {
prototype: AnimationTimeline;
new(): AnimationTimeline;
};
/** 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. */
interface Attr extends Node {
readonly localName: string;
readonly name: string;
readonly namespaceURI: string | null;
readonly ownerDocument: Document;
readonly ownerElement: Element | null;
readonly prefix: string | null;
readonly specified: boolean;
value: string;
}
declare var Attr: {
prototype: Attr;
new(): 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. */
interface AudioBuffer {
readonly duration: number;
readonly length: number;
readonly numberOfChannels: number;
readonly sampleRate: number;
copyFromChannel(destination: Float32Array, channelNumber: number, bufferOffset?: number): void;
copyToChannel(source: Float32Array, channelNumber: number, bufferOffset?: number): void;
getChannelData(channel: number): Float32Array;
}
declare var AudioBuffer: {
prototype: AudioBuffer;
new(options: AudioBufferOptions): 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. */
interface AudioBufferSourceNode extends AudioScheduledSourceNode {
buffer: AudioBuffer | null;
readonly detune: AudioParam;
loop: boolean;
loopEnd: number;
loopStart: number;
readonly playbackRate: AudioParam;
start(when?: number, offset?: number, duration?: number): void;
addEventListener<K extends keyof AudioScheduledSourceNodeEventMap>(type: K, listener: (this: AudioBufferSourceNode, ev: AudioScheduledSourceNodeEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
removeEventListener<K extends keyof AudioScheduledSourceNodeEventMap>(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;
};
/** An audio-processing graph built from audio modules linked together, each represented by an AudioNode. */
interface AudioContext extends BaseAudioContext {
readonly baseLatency: number;
close(): Promise<void>;
createMediaElementSource(mediaElement: HTMLMediaElement): MediaElementAudioSourceNode;
createMediaStreamDestination(): MediaStreamAudioDestinationNode;
createMediaStreamSource(mediaStream: MediaStream): MediaStreamAudioSourceNode;
getOutputTimestamp(): AudioTimestamp;
resume(): Promise<void>;
suspend(): Promise<void>;
addEventListener<K extends keyof BaseAudioContextEventMap>(type: K, listener: (this: AudioContext, ev: BaseAudioContextEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
removeEventListener<K extends keyof BaseAudioContextEventMap>(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;
};
/** 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. */
interface AudioDestinationNode extends AudioNode {
readonly maxChannelCount: number;
}
declare var AudioDestinationNode: {
prototype: AudioDestinationNode;
new(): 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. */
interface AudioListener {
readonly forwardX: AudioParam;
readonly forwardY: AudioParam;
readonly forwardZ: AudioParam;
readonly positionX: AudioParam;
readonly positionY: AudioParam;
readonly positionZ: AudioParam;
readonly upX: AudioParam;
readonly upY: AudioParam;
readonly upZ: AudioParam;
/** @deprecated */
setOrientation(x: number, y: number, z: number, xUp: number, yUp: number, zUp: number): void;
/** @deprecated */
setPosition(x: number, y: number, z: number): void;
}
declare var AudioListener: {
prototype: AudioListener;
new(): AudioListener;
};
/** A generic interface for representing an audio processing module. Examples include: */
interface AudioNode extends EventTarget {
channelCount: number;
channelCountMode: ChannelCountMode;
channelInterpretation: ChannelInterpretation;
readonly context: BaseAudioContext;
readonly numberOfInputs: number;
readonly numberOfOutputs: number;
connect(destinationNode: AudioNode, output?: number, input?: number): AudioNode;
connect(destinationParam: AudioParam, output?: number): void;
disconnect(): void;
disconnect(output: number): void;
disconnect(destinationNode: AudioNode): void;
disconnect(destinationNode: AudioNode, output: number): void;
disconnect(destinationNode: AudioNode, output: number, input: number): void;
disconnect(destinationParam: AudioParam): void;
disconnect(destinationParam: AudioParam, output: number): void;
}
declare var AudioNode: {
prototype: AudioNode;
new(): AudioNode;
};
/** The Web Audio API's AudioParam interface represents an audio-related parameter, usually a parameter of an AudioNode (such as GainNode.gain). */
interface AudioParam {
automationRate: AutomationRate;
readonly defaultValue: number;
readonly maxValue: number;
readonly minValue: number;
value: number;
cancelAndHoldAtTime(cancelTime: number): AudioParam;
cancelScheduledValues(cancelTime: number): AudioParam;
exponentialRampToValueAtTime(value: number, endTime: number): AudioParam;
linearRampToValueAtTime(value: number, endTime: number): AudioParam;
setTargetAtTime(target: number, startTime: number, timeConstant: number): AudioParam;
setValueAtTime(value: number, startTime: number): AudioParam;
setValueCurveAtTime(values: number[] | Float32Array, startTime: number, duration: number): AudioParam;
}
declare var AudioParam: {
prototype: AudioParam;
new(): AudioParam;
};
interface AudioParamMap {
forEach(callbackfn: (value: AudioParam, key: string, parent: AudioParamMap) => void, thisArg?: any): void;
}
declare var AudioParamMap: {
prototype: AudioParamMap;
new(): 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. */
interface AudioProcessingEvent extends Event {
/** @deprecated */
readonly inputBuffer: AudioBuffer;
/** @deprecated */
readonly outputBuffer: AudioBuffer;
/** @deprecated */
readonly playbackTime: number;
}
/** @deprecated */
declare var AudioProcessingEvent: {
prototype: AudioProcessingEvent;
new(type: string, eventInitDict: AudioProcessingEventInit): AudioProcessingEvent;
};
interface AudioScheduledSourceNodeEventMap {
"ended": Event;
}
interface AudioScheduledSourceNode extends AudioNode {
onended: ((this: AudioScheduledSourceNode, ev: Event) => any) | null;
start(when?: number): void;
stop(when?: number): void;
addEventListener<K extends keyof AudioScheduledSourceNodeEventMap>(type: K, listener: (this: AudioScheduledSourceNode, ev: AudioScheduledSourceNodeEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
removeEventListener<K extends keyof AudioScheduledSourceNodeEventMap>(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;
};
interface AudioWorklet extends Worklet {
}
declare var AudioWorklet: {
prototype: AudioWorklet;
new(): AudioWorklet;
};
interface AudioWorkletNodeEventMap {
"processorerror": Event;
}
interface AudioWorkletNode extends AudioNode {
onprocessorerror: ((this: AudioWorkletNode, ev: Event) => any) | null;
readonly parameters: AudioParamMap;
readonly port: MessagePort;
addEventListener<K extends keyof AudioWorkletNodeEventMap>(type: K, listener: (this: AudioWorkletNode, ev: AudioWorkletNodeEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
removeEventListener<K extends keyof AudioWorkletNodeEventMap>(type: K, listener: (this: AudioWorkletNode, ev: AudioWorkletNodeEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
}
declare var AudioWorkletNode: {
prototype: AudioWorkletNode;
new(context: BaseAudioContext, name: string, options?: AudioWorkletNodeOptions): AudioWorkletNode;
};
interface AuthenticatorAssertionResponse extends AuthenticatorResponse {
readonly authenticatorData: ArrayBuffer;
readonly signature: ArrayBuffer;
readonly userHandle: ArrayBuffer | null;
}
declare var AuthenticatorAssertionResponse: {
prototype: AuthenticatorAssertionResponse;
new(): AuthenticatorAssertionResponse;
};
interface AuthenticatorAttestationResponse extends AuthenticatorResponse {
readonly attestationObject: ArrayBuffer;
}
declare var AuthenticatorAttestationResponse: {
prototype: AuthenticatorAttestationResponse;
new(): AuthenticatorAttestationResponse;
};
interface AuthenticatorResponse {
readonly clientDataJSON: ArrayBuffer;
}
declare var AuthenticatorResponse: {
prototype: AuthenticatorResponse;
new(): AuthenticatorResponse;
};
interface BarProp {
readonly visible: boolean;
}
declare var BarProp: {
prototype: BarProp;
new(): BarProp;
};
interface BaseAudioContextEventMap {
"statechange": Event;
}
interface BaseAudioContext extends EventTarget {
readonly audioWorklet: AudioWorklet;
readonly currentTime: number;
readonly destination: AudioDestinationNode;
readonly listener: AudioListener;
onstatechange: ((this: BaseAudioContext, ev: Event) => any) | null;
readonly sampleRate: number;
readonly state: AudioContextState;
createAnalyser(): AnalyserNode;
createBiquadFilter(): BiquadFilterNode;
createBuffer(numberOfChannels: number, length: number, sampleRate: number): AudioBuffer;
createBufferSource(): AudioBufferSourceNode;
createChannelMerger(numberOfInputs?: number): ChannelMergerNode;
createChannelSplitter(numberOfOutputs?: number): ChannelSplitterNode;
createConstantSource(): ConstantSourceNode;
createConvolver(): ConvolverNode;
createDelay(maxDelayTime?: number): DelayNode;
createDynamicsCompressor(): DynamicsCompressorNode;
createGain(): GainNode;
createIIRFilter(feedforward: number[], feedback: number[]): IIRFilterNode;
createOscillator(): OscillatorNode;
createPanner(): PannerNode;
createPeriodicWave(real: number[] | Float32Array, imag: number[] | Float32Array, constraints?: PeriodicWaveConstraints): PeriodicWave;
/** @deprecated */
createScriptProcessor(bufferSize?: number, numberOfInputChannels?: number, numberOfOutputChannels?: number): ScriptProcessorNode;
createStereoPanner(): StereoPannerNode;
createWaveShaper(): WaveShaperNode;
decodeAudioData(audioData: ArrayBuffer, successCallback?: DecodeSuccessCallback | null, errorCallback?: DecodeErrorCallback | null): Promise<AudioBuffer>;
addEventListener<K extends keyof BaseAudioContextEventMap>(type: K, listener: (this: BaseAudioContext, ev: BaseAudioContextEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
removeEventListener<K extends keyof BaseAudioContextEventMap>(type: K, listener: (this: BaseAudioContext, ev: BaseAudioContextEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
}
declare var BaseAudioContext: {
prototype: BaseAudioContext;
new(): BaseAudioContext;
};
/** The beforeunload event is fired when the window, the document and its resources are about to be unloaded. */
interface BeforeUnloadEvent extends Event {
returnValue: any;
}
declare var BeforeUnloadEvent: {
prototype: BeforeUnloadEvent;
new(): BeforeUnloadEvent;
};
/** A simple low-order filter, and is created using the AudioContext.createBiquadFilter() method. It is an AudioNode that can represent different kinds of filters, tone control devices, and graphic equalizers. */
interface BiquadFilterNode extends AudioNode {
readonly Q: AudioParam;
readonly detune: AudioParam;
readonly frequency: AudioParam;
readonly gain: AudioParam;
type: BiquadFilterType;
getFrequencyResponse(frequencyHz: Float32Array, magResponse: Float32Array, phaseResponse: Float32Array): void;
}
declare var BiquadFilterNode: {
prototype: BiquadFilterNode;
new(context: BaseAudioContext, options?: BiquadFilterOptions): BiquadFilterNode;
};
/** A file-like object of immutable, raw data. Blobs represent data that isn't necessarily in a JavaScript-native format. The File interface is based on Blob, inheriting blob functionality and expanding it to support files on the user's system. */
interface Blob {
readonly size: number;
readonly type: string;
arrayBuffer(): Promise<ArrayBuffer>;
slice(start?: number, end?: number, contentType?: string): Blob;
stream(): ReadableStream;
text(): Promise<string>;
}
declare var Blob: {
prototype: Blob;
new(blobParts?: BlobPart[], options?: BlobPropertyBag): Blob;
};
interface BlobEvent extends Event {
readonly data: Blob;
readonly timecode: DOMHighResTimeStamp;
}
declare var BlobEvent: {
prototype: BlobEvent;
new(type: string, eventInitDict: BlobEventInit): BlobEvent;
};
interface Body {
readonly body: ReadableStream<Uint8Array> | null;
readonly bodyUsed: boolean;
arrayBuffer(): Promise<ArrayBuffer>;
blob(): Promise<Blob>;
formData(): Promise<FormData>;
json(): Promise<any>;
text(): Promise<string>;
}
interface BroadcastChannelEventMap {
"message": MessageEvent;
"messageerror": MessageEvent;
}
interface BroadcastChannel extends EventTarget {
/**
* Returns the channel name (as passed to the constructor).
*/
readonly name: string;
onmessage: ((this: BroadcastChannel, ev: MessageEvent) => any) | null;
onmessageerror: ((this: BroadcastChannel, ev: MessageEvent) => any) | null;
/**
* Closes the BroadcastChannel object, opening it up to garbage collection.
*/
close(): void;
/**
* Sends the given message to other BroadcastChannel objects set up for this channel. Messages can be structured objects, e.g. nested objects and arrays.
*/
postMessage(message: any): void;
addEventListener<K extends keyof BroadcastChannelEventMap>(type: K, listener: (this: BroadcastChannel, ev: BroadcastChannelEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
removeEventListener<K extends keyof BroadcastChannelEventMap>(type: K, listener: (this: BroadcastChannel, ev: BroadcastChannelEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
}
declare var BroadcastChannel: {
prototype: BroadcastChannel;
new(name: string): BroadcastChannel;
};
/** This Streams API interface provides a built-in byte length queuing strategy that can be used when constructing streams. */
interface ByteLengthQueuingStrategy extends QueuingStrategy<ArrayBufferView> {
readonly highWaterMark: number;
readonly size: QueuingStrategySize<ArrayBufferView>;
}
declare var ByteLengthQueuingStrategy: {
prototype: ByteLengthQueuingStrategy;
new(init: QueuingStrategyInit): ByteLengthQueuingStrategy;
};
/** A CDATA section that can be used within XML to include extended portions of unescaped text. The symbols < and & don’t need escaping as they normally do when inside a CDATA section. */
interface CDATASection extends Text {
}
declare var CDATASection: {
prototype: CDATASection;
new(): CDATASection;
};
interface CSSAnimation extends Animation {
readonly animationName: string;
addEventListener<K extends keyof AnimationEventMap>(type: K, listener: (this: CSSAnimation, ev: AnimationEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
removeEventListener<K extends keyof AnimationEventMap>(type: K, listener: (this: CSSAnimation, ev: AnimationEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
}
declare var CSSAnimation: {
prototype: CSSAnimation;
new(): CSSAnimation;
};
/** A single condition CSS at-rule, which consists of a condition and a statement block. It is a child of CSSGroupingRule. */
interface CSSConditionRule extends CSSGroupingRule {
conditionText: string;
}
declare var CSSConditionRule: {
prototype: CSSConditionRule;
new(): CSSConditionRule;
};
interface CSSCounterStyleRule extends CSSRule {
additiveSymbols: string;
fallback: string;
name: string;
negative: string;
pad: string;
prefix: string;
range: string;
speakAs: string;
suffix: string;
symbols: string;
system: string;
}
declare var CSSCounterStyleRule: {
prototype: CSSCounterStyleRule;
new(): CSSCounterStyleRule;
};
interface CSSFontFaceRule extends CSSRule {
readonly style: CSSStyleDeclaration;
}
declare var CSSFontFaceRule: {
prototype: CSSFontFaceRule;
new(): CSSFontFaceRule;
};
/** Any CSS at-rule that contains other rules nested within it. */
interface CSSGroupingRule extends CSSRule {
readonly cssRules: CSSRuleList;
deleteRule(index: number): void;
insertRule(rule: string, index?: number): number;
}
declare var CSSGroupingRule: {
prototype: CSSGroupingRule;
new(): CSSGroupingRule;
};
interface CSSImportRule extends CSSRule {
readonly href: string;
readonly media: MediaList;
readonly styleSheet: CSSStyleSheet;
}
declare var CSSImportRule: {
prototype: CSSImportRule;
new(): CSSImportRule;
};
/** An object representing a set of style for a given keyframe. It corresponds to the contains of a single keyframe of a @keyframes at-rule. It implements the CSSRule interface with a type value of 8 (CSSRule.KEYFRAME_RULE). */
interface CSSKeyframeRule extends CSSRule {
keyText: string;
readonly style: CSSStyleDeclaration;
}
declare var CSSKeyframeRule: {
prototype: CSSKeyframeRule;
new(): CSSKeyframeRule;
};
/** An object representing a complete set of keyframes for a CSS animation. It corresponds to the contains of a whole @keyframes at-rule. It implements the CSSRule interface with a type value of 7 (CSSRule.KEYFRAMES_RULE). */
interface CSSKeyframesRule extends CSSRule {
readonly cssRules: CSSRuleList;
name: string;
appendRule(rule: string): void;
deleteRule(select: string): void;
findRule(select: string): CSSKeyframeRule | null;
}
declare var CSSKeyframesRule: {
prototype: CSSKeyframesRule;
new(): CSSKeyframesRule;
};
/** A single CSS @media rule. It implements the CSSConditionRule interface, and therefore the CSSGroupingRule and the CSSRule interface with a type value of 4 (CSSRule.MEDIA_RULE). */
interface CSSMediaRule extends CSSConditionRule {
readonly media: MediaList;
}
declare var CSSMediaRule: {
prototype: CSSMediaRule;
new(): CSSMediaRule;
};
/** An object representing a single CSS @namespace at-rule. It implements the CSSRule interface, with a type value of 10 (CSSRule.NAMESPACE_RULE). */
interface CSSNamespaceRule extends CSSRule {
readonly namespaceURI: string;
readonly prefix: string;
}
declare var CSSNamespaceRule: {
prototype: CSSNamespaceRule;
new(): CSSNamespaceRule;
};
/** CSSPageRule is an interface representing a single CSS @page rule. It implements the CSSRule interface with a type value of 6 (CSSRule.PAGE_RULE). */
interface CSSPageRule extends CSSGroupingRule {
selectorText: string;
readonly style: CSSStyleDeclaration;
}
declare var CSSPageRule: {
prototype: CSSPageRule;
new(): CSSPageRule;
};
/** A single CSS rule. There are several types of rules, listed in the Type constants section below. */
interface CSSRule {
cssText: string;
readonly parentRule: CSSRule | null;
readonly parentStyleSheet: CSSStyleSheet | null;
/** @deprecated */
readonly type: number;
readonly CHARSET_RULE: number;
readonly FONT_FACE_RULE: number;
readonly IMPORT_RULE: number;
readonly KEYFRAMES_RULE: number;
readonly KEYFRAME_RULE: number;
readonly MEDIA_RULE: number;
readonly NAMESPACE_RULE: number;
readonly PAGE_RULE: number;
readonly STYLE_RULE: number;
readonly SUPPORTS_RULE: number;
}
declare var CSSRule: {
prototype: CSSRule;
new(): CSSRule;
readonly CHARSET_RULE: number;
readonly FONT_FACE_RULE: number;
readonly IMPORT_RULE: number;
readonly KEYFRAMES_RULE: number;
readonly KEYFRAME_RULE: number;
readonly MEDIA_RULE: number;
readonly NAMESPACE_RULE: number;
readonly PAGE_RULE: number;
readonly STYLE_RULE: number;
readonly SUPPORTS_RULE: number;
};
/** A CSSRuleList is an (indirect-modify only) array-like object containing an ordered collection of CSSRule objects. */
interface CSSRuleList {
readonly length: number;
item(index: number): CSSRule | null;
[index: number]: CSSRule;
}
declare var CSSRuleList: {
prototype: CSSRuleList;
new(): CSSRuleList;
};
/** An object that is a CSS declaration block, and exposes style information and various style-related methods and properties. */
interface CSSStyleDeclaration {
alignContent: string;
alignItems: string;
alignSelf: string;