Interface GlobalObject

interface GlobalObject {
    __reactRouterVersion: string;
    __staticRouterHydrationData:
        | Partial<Pick<RouterState, "loaderData" | "actionData" | "errors">>
        | undefined;
    __TSR_CACHE__:
        | {
            processRouteTreeResult: ProcessRouteTreeResult<AnyRoute>;
            resolvePathCache: LRUCache<string, string>;
            routeTree: AnyRoute;
        }
        | undefined;
    AbortController: { prototype: AbortController; new (): AbortController };
    AbortSignal: {
        prototype: AbortSignal;
        abort(reason?: any): AbortSignal;
        any(signals: AbortSignal[]): AbortSignal;
        timeout(milliseconds: number): AbortSignal;
        new (): AbortSignal;
    };
    AbstractRange: { prototype: AbstractRange; new (): AbstractRange };
    addEventListener: {
        <K extends keyof WindowEventMap>(
            type: K,
            listener: (this: Window, ev: WindowEventMap[K]) => any,
            options?: boolean | AddEventListenerOptions,
        ): void;
        (
            type: string,
            listener: EventListenerOrEventListenerObject,
            options?: boolean | AddEventListenerOptions,
        ): void;
        <K extends keyof DedicatedWorkerGlobalScopeEventMap>(
            type: K,
            listener: (
                this: DedicatedWorkerGlobalScope,
                ev: DedicatedWorkerGlobalScopeEventMap[K],
            ) => any,
            options?: boolean | AddEventListenerOptions,
        ): void;
        (
            type: string,
            listener: EventListenerOrEventListenerObject,
            options?: boolean | AddEventListenerOptions,
        ): void;
    };
    afterAll: (action: ImplementationCallback, timeout?: number) => void;
    afterEach: (action: ImplementationCallback, timeout?: number) => void;
    alert: (message?: any) => void;
    AnalyserNode: {
        prototype: AnalyserNode;
        new (context: BaseAudioContext, options?: AnalyserOptions): AnalyserNode;
    };
    Animation: {
        prototype: Animation;
        new (
            effect?: AnimationEffect | null,
            timeline?: AnimationTimeline | null,
        ): Animation;
    };
    AnimationEffect: { prototype: AnimationEffect; new (): AnimationEffect };
    AnimationEvent: {
        prototype: AnimationEvent;
        new (
            type: string,
            animationEventInitDict?: AnimationEventInit,
        ): AnimationEvent;
    };
    AnimationPlaybackEvent: {
        prototype: AnimationPlaybackEvent;
        new (
            type: string,
            eventInitDict?: AnimationPlaybackEventInit,
        ): AnimationPlaybackEvent;
    };
    AnimationTimeline: {
        prototype: AnimationTimeline;
        new (): AnimationTimeline;
    };
    Array: ArrayConstructor;
    ArrayBuffer: ArrayBufferConstructor;
    atob: { (data: string): string; (data: string): string };
    Atomics: Atomics;
    Attr: { prototype: Attr; new (): Attr };
    Audio: new (src?: string) => HTMLAudioElement;
    AudioBuffer: {
        prototype: AudioBuffer;
        new (options: AudioBufferOptions): AudioBuffer;
    };
    AudioBufferSourceNode: {
        prototype: AudioBufferSourceNode;
        new (
            context: BaseAudioContext,
            options?: AudioBufferSourceOptions,
        ): AudioBufferSourceNode;
    };
    AudioContext: {
        prototype: AudioContext;
        new (contextOptions?: AudioContextOptions): AudioContext;
    };
    AudioData: { prototype: AudioData; new (init: AudioDataInit): AudioData };
    AudioDecoder: {
        prototype: AudioDecoder;
        isConfigSupported(
            config: AudioDecoderConfig,
        ): Promise<AudioDecoderSupport>;
        new (init: AudioDecoderInit): AudioDecoder;
    };
    AudioDestinationNode: {
        prototype: AudioDestinationNode;
        new (): AudioDestinationNode;
    };
    AudioEncoder: {
        prototype: AudioEncoder;
        isConfigSupported(
            config: AudioEncoderConfig,
        ): Promise<AudioEncoderSupport>;
        new (init: AudioEncoderInit): AudioEncoder;
    };
    AudioListener: { prototype: AudioListener; new (): AudioListener };
    AudioNode: { prototype: AudioNode; new (): AudioNode };
    AudioParam: { prototype: AudioParam; new (): AudioParam };
    AudioParamMap: { prototype: AudioParamMap; new (): AudioParamMap };
    AudioProcessingEvent: {
        prototype: AudioProcessingEvent;
        new (
            type: string,
            eventInitDict: AudioProcessingEventInit,
        ): AudioProcessingEvent;
    };
    AudioScheduledSourceNode: {
        prototype: AudioScheduledSourceNode;
        new (): AudioScheduledSourceNode;
    };
    AudioWorklet: { prototype: AudioWorklet; new (): AudioWorklet };
    AudioWorkletNode: {
        prototype: AudioWorkletNode;
        new (
            context: BaseAudioContext,
            name: string,
            options?: AudioWorkletNodeOptions,
        ): AudioWorkletNode;
    };
    AuthenticatorAssertionResponse: {
        prototype: AuthenticatorAssertionResponse;
        new (): AuthenticatorAssertionResponse;
    };
    AuthenticatorAttestationResponse: {
        prototype: AuthenticatorAttestationResponse;
        new (): AuthenticatorAttestationResponse;
    };
    AuthenticatorResponse: {
        prototype: AuthenticatorResponse;
        new (): AuthenticatorResponse;
    };
    BarProp: { prototype: BarProp; new (): BarProp };
    BaseAudioContext: { prototype: BaseAudioContext; new (): BaseAudioContext };
    beforeAll: (action: ImplementationCallback, timeout?: number) => void;
    beforeEach: (action: ImplementationCallback, timeout?: number) => void;
    BeforeUnloadEvent: {
        prototype: BeforeUnloadEvent;
        new (): BeforeUnloadEvent;
    };
    BigInt: BigIntConstructor;
    BigInt64Array: BigInt64ArrayConstructor;
    BigUint64Array: BigUint64ArrayConstructor;
    BiquadFilterNode: {
        prototype: BiquadFilterNode;
        new (
            context: BaseAudioContext,
            options?: BiquadFilterOptions,
        ): BiquadFilterNode;
    };
    Blob: {
        prototype: Blob;
        new (blobParts?: BlobPart[], options?: BlobPropertyBag): Blob;
    };
    BlobEvent: {
        prototype: BlobEvent;
        new (type: string, eventInitDict: BlobEventInit): BlobEvent;
    };
    blur: () => void;
    Boolean: BooleanConstructor;
    BroadcastChannel: {
        prototype: BroadcastChannel;
        new (name: string): BroadcastChannel;
    };
    btoa: { (data: string): string; (data: string): string };
    ByteLengthQueuingStrategy: {
        prototype: ByteLengthQueuingStrategy;
        new (init: QueuingStrategyInit): ByteLengthQueuingStrategy;
    };
    Cache: { prototype: Cache; new (): Cache };
    caches: CacheStorage;
    CacheStorage: { prototype: CacheStorage; new (): CacheStorage };
    cancelAnimationFrame: { (handle: number): void; (handle: number): void };
    cancelIdleCallback: (handle: number) => void;
    CanvasCaptureMediaStreamTrack: {
        prototype: CanvasCaptureMediaStreamTrack;
        new (): CanvasCaptureMediaStreamTrack;
    };
    CanvasGradient: { prototype: CanvasGradient; new (): CanvasGradient };
    CanvasPattern: { prototype: CanvasPattern; new (): CanvasPattern };
    CanvasRenderingContext2D: {
        prototype: CanvasRenderingContext2D;
        new (): CanvasRenderingContext2D;
    };
    captureEvents: () => void;
    CaretPosition: { prototype: CaretPosition; new (): CaretPosition };
    CDATASection: { prototype: CDATASection; new (): CDATASection };
    ChannelMergerNode: {
        prototype: ChannelMergerNode;
        new (
            context: BaseAudioContext,
            options?: ChannelMergerOptions,
        ): ChannelMergerNode;
    };
    ChannelSplitterNode: {
        prototype: ChannelSplitterNode;
        new (
            context: BaseAudioContext,
            options?: ChannelSplitterOptions,
        ): ChannelSplitterNode;
    };
    CharacterData: { prototype: CharacterData; new (): CharacterData };
    clearInterval: {
        (id: number | undefined): void;
        (id: number | undefined): void;
    };
    clearTimeout: {
        (id: number | undefined): void;
        (id: number | undefined): void;
    };
    Client: { prototype: Client; new (): Client };
    clientInformation: Navigator;
    Clients: { prototype: Clients; new (): Clients };
    Clipboard: { prototype: Clipboard; new (): Clipboard };
    ClipboardEvent: {
        prototype: ClipboardEvent;
        new (type: string, eventInitDict?: ClipboardEventInit): ClipboardEvent;
    };
    ClipboardItem: {
        prototype: ClipboardItem;
        supports(type: string): boolean;
        new (
            items: Record<string, string | Blob | PromiseLike<string | Blob>>,
            options?: ClipboardItemOptions,
        ): ClipboardItem;
    };
    close: { (): void; (): void };
    closed: boolean;
    CloseEvent: {
        prototype: CloseEvent;
        new (type: string, eventInitDict?: CloseEventInit): CloseEvent;
    };
    CommandEvent: {
        prototype: CommandEvent;
        new (type: string, eventInitDict?: CommandEventInit): CommandEvent;
    };
    Comment: { prototype: Comment; new (data?: string): Comment };
    CompositionEvent: {
        prototype: CompositionEvent;
        new (type: string, eventInitDict?: CompositionEventInit): CompositionEvent;
    };
    CompressionStream: {
        prototype: CompressionStream;
        new (format: CompressionFormat): CompressionStream;
    };
    confirm: (message?: string) => boolean;
    console: Console;
    ConstantSourceNode: {
        prototype: ConstantSourceNode;
        new (
            context: BaseAudioContext,
            options?: ConstantSourceOptions,
        ): ConstantSourceNode;
    };
    ContentVisibilityAutoStateChangeEvent: {
        prototype: ContentVisibilityAutoStateChangeEvent;
        new (
            type: string,
            eventInitDict?: ContentVisibilityAutoStateChangeEventInit,
        ): ContentVisibilityAutoStateChangeEvent;
    };
    ConvolverNode: {
        prototype: ConvolverNode;
        new (context: BaseAudioContext, options?: ConvolverOptions): ConvolverNode;
    };
    CookieChangeEvent: {
        prototype: CookieChangeEvent;
        new (
            type: string,
            eventInitDict?: CookieChangeEventInit,
        ): CookieChangeEvent;
    };
    cookieStore?: CookieStore;
    CookieStore: { prototype: CookieStore; new (): CookieStore };
    CookieStoreManager: {
        prototype: CookieStoreManager;
        new (): CookieStoreManager;
    };
    CountQueuingStrategy: {
        prototype: CountQueuingStrategy;
        new (init: QueuingStrategyInit): CountQueuingStrategy;
    };
    createImageBitmap: {
        (
            image: ImageBitmapSource,
            options?: ImageBitmapOptions,
        ): Promise<ImageBitmap>;
        (
            image: ImageBitmapSource,
            sx: number,
            sy: number,
            sw: number,
            sh: number,
            options?: ImageBitmapOptions,
        ): Promise<ImageBitmap>;
        (
            image: ImageBitmapSource,
            options?: ImageBitmapOptions,
        ): Promise<ImageBitmap>;
        (
            image: ImageBitmapSource,
            sx: number,
            sy: number,
            sw: number,
            sh: number,
            options?: ImageBitmapOptions,
        ): Promise<ImageBitmap>;
    };
    Credential: { prototype: Credential; new (): Credential };
    CredentialsContainer: {
        prototype: CredentialsContainer;
        new (): CredentialsContainer;
    };
    crossOriginIsolated: boolean;
    crypto: Crypto;
    Crypto: { prototype: Crypto; new (): Crypto };
    CryptoKey: { prototype: CryptoKey; new (): CryptoKey };
    CSS: typeof CSS;
    CSSAnimation: { prototype: CSSAnimation; new (): CSSAnimation };
    CSSConditionRule: { prototype: CSSConditionRule; new (): CSSConditionRule };
    CSSContainerRule: { prototype: CSSContainerRule; new (): CSSContainerRule };
    CSSCounterStyleRule: {
        prototype: CSSCounterStyleRule;
        new (): CSSCounterStyleRule;
    };
    CSSFontFaceRule: { prototype: CSSFontFaceRule; new (): CSSFontFaceRule };
    CSSFontFeatureValuesRule: {
        prototype: CSSFontFeatureValuesRule;
        new (): CSSFontFeatureValuesRule;
    };
    CSSFontPaletteValuesRule: {
        prototype: CSSFontPaletteValuesRule;
        new (): CSSFontPaletteValuesRule;
    };
    CSSGroupingRule: { prototype: CSSGroupingRule; new (): CSSGroupingRule };
    CSSImageValue: { prototype: CSSImageValue; new (): CSSImageValue };
    CSSImportRule: { prototype: CSSImportRule; new (): CSSImportRule };
    CSSKeyframeRule: { prototype: CSSKeyframeRule; new (): CSSKeyframeRule };
    CSSKeyframesRule: { prototype: CSSKeyframesRule; new (): CSSKeyframesRule };
    CSSKeywordValue: {
        prototype: CSSKeywordValue;
        new (value: string): CSSKeywordValue;
    };
    CSSLayerBlockRule: {
        prototype: CSSLayerBlockRule;
        new (): CSSLayerBlockRule;
    };
    CSSLayerStatementRule: {
        prototype: CSSLayerStatementRule;
        new (): CSSLayerStatementRule;
    };
    CSSMathClamp: {
        prototype: CSSMathClamp;
        new (
            lower: CSSNumberish,
            value: CSSNumberish,
            upper: CSSNumberish,
        ): CSSMathClamp;
    };
    CSSMathInvert: {
        prototype: CSSMathInvert;
        new (arg: CSSNumberish): CSSMathInvert;
    };
    CSSMathMax: {
        prototype: CSSMathMax;
        new (...args: CSSNumberish[]): CSSMathMax;
    };
    CSSMathMin: {
        prototype: CSSMathMin;
        new (...args: CSSNumberish[]): CSSMathMin;
    };
    CSSMathNegate: {
        prototype: CSSMathNegate;
        new (arg: CSSNumberish): CSSMathNegate;
    };
    CSSMathProduct: {
        prototype: CSSMathProduct;
        new (...args: CSSNumberish[]): CSSMathProduct;
    };
    CSSMathSum: {
        prototype: CSSMathSum;
        new (...args: CSSNumberish[]): CSSMathSum;
    };
    CSSMathValue: { prototype: CSSMathValue; new (): CSSMathValue };
    CSSMatrixComponent: {
        prototype: CSSMatrixComponent;
        new (
            matrix: DOMMatrixReadOnly,
            options?: CSSMatrixComponentOptions,
        ): CSSMatrixComponent;
    };
    CSSMediaRule: { prototype: CSSMediaRule; new (): CSSMediaRule };
    CSSNamespaceRule: { prototype: CSSNamespaceRule; new (): CSSNamespaceRule };
    CSSNestedDeclarations: {
        prototype: CSSNestedDeclarations;
        new (): CSSNestedDeclarations;
    };
    CSSNumericArray: { prototype: CSSNumericArray; new (): CSSNumericArray };
    CSSNumericValue: {
        prototype: CSSNumericValue;
        parse(cssText: string): CSSNumericValue;
        new (): CSSNumericValue;
    };
    CSSPageDescriptors: {
        prototype: CSSPageDescriptors;
        new (): CSSPageDescriptors;
    };
    CSSPageRule: { prototype: CSSPageRule; new (): CSSPageRule };
    CSSPerspective: {
        prototype: CSSPerspective;
        new (length: CSSPerspectiveValue): CSSPerspective;
    };
    CSSPositionTryDescriptors: {
        prototype: CSSPositionTryDescriptors;
        new (): CSSPositionTryDescriptors;
    };
    CSSPositionTryRule: {
        prototype: CSSPositionTryRule;
        new (): CSSPositionTryRule;
    };
    CSSPropertyRule: { prototype: CSSPropertyRule; new (): CSSPropertyRule };
    CSSRotate: {
        prototype: CSSRotate;
        new (angle: CSSNumericValue): CSSRotate;
        new (
            x: CSSNumberish,
            y: CSSNumberish,
            z: CSSNumberish,
            angle: CSSNumericValue,
        ): CSSRotate;
    };
    CSSRule: {
        CHARSET_RULE: 2;
        COUNTER_STYLE_RULE: 11;
        FONT_FACE_RULE: 5;
        FONT_FEATURE_VALUES_RULE: 14;
        IMPORT_RULE: 3;
        KEYFRAME_RULE: 8;
        KEYFRAMES_RULE: 7;
        MARGIN_RULE: 9;
        MEDIA_RULE: 4;
        NAMESPACE_RULE: 10;
        PAGE_RULE: 6;
        prototype: CSSRule;
        STYLE_RULE: 1;
        SUPPORTS_RULE: 12;
        new (): CSSRule;
    };
    CSSRuleList: { prototype: CSSRuleList; new (): CSSRuleList };
    CSSScale: {
        prototype: CSSScale;
        new (x: CSSNumberish, y: CSSNumberish, z?: CSSNumberish): CSSScale;
    };
    CSSScopeRule: { prototype: CSSScopeRule; new (): CSSScopeRule };
    CSSSkew: {
        prototype: CSSSkew;
        new (ax: CSSNumericValue, ay: CSSNumericValue): CSSSkew;
    };
    CSSSkewX: { prototype: CSSSkewX; new (ax: CSSNumericValue): CSSSkewX };
    CSSSkewY: { prototype: CSSSkewY; new (ay: CSSNumericValue): CSSSkewY };
    CSSStartingStyleRule: {
        prototype: CSSStartingStyleRule;
        new (): CSSStartingStyleRule;
    };
    CSSStyleDeclaration: {
        prototype: CSSStyleDeclaration;
        new (): CSSStyleDeclaration;
    };
    CSSStyleProperties: {
        prototype: CSSStyleProperties;
        new (): CSSStyleProperties;
    };
    CSSStyleRule: { prototype: CSSStyleRule; new (): CSSStyleRule };
    CSSStyleSheet: {
        prototype: CSSStyleSheet;
        new (options?: CSSStyleSheetInit): CSSStyleSheet;
    };
    CSSStyleValue: {
        prototype: CSSStyleValue;
        parse(property: string, cssText: string): CSSStyleValue;
        parseAll(property: string, cssText: string): CSSStyleValue[];
        new (): CSSStyleValue;
    };
    CSSSupportsRule: { prototype: CSSSupportsRule; new (): CSSSupportsRule };
    CSSTransformComponent: {
        prototype: CSSTransformComponent;
        new (): CSSTransformComponent;
    };
    CSSTransformValue: {
        prototype: CSSTransformValue;
        new (transforms: CSSTransformComponent[]): CSSTransformValue;
    };
    CSSTransition: { prototype: CSSTransition; new (): CSSTransition };
    CSSTranslate: {
        prototype: CSSTranslate;
        new (
            x: CSSNumericValue,
            y: CSSNumericValue,
            z?: CSSNumericValue,
        ): CSSTranslate;
    };
    CSSUnitValue: {
        prototype: CSSUnitValue;
        new (value: number, unit: string): CSSUnitValue;
    };
    CSSUnparsedValue: {
        prototype: CSSUnparsedValue;
        new (members: CSSUnparsedSegment[]): CSSUnparsedValue;
    };
    CSSVariableReferenceValue: {
        prototype: CSSVariableReferenceValue;
        new (
            variable: string,
            fallback?: CSSUnparsedValue | null,
        ): CSSVariableReferenceValue;
    };
    CSSViewTransitionRule: {
        prototype: CSSViewTransitionRule;
        new (): CSSViewTransitionRule;
    };
    CustomElementRegistry: {
        prototype: CustomElementRegistry;
        new (): CustomElementRegistry;
    };
    customElements: CustomElementRegistry;
    CustomEvent: {
        prototype: CustomEvent;
        new <T>(type: string, eventInitDict?: CustomEventInit<T>): CustomEvent<T>;
    };
    CustomStateSet: { prototype: CustomStateSet; new (): CustomStateSet };
    DataTransfer: { prototype: DataTransfer; new (): DataTransfer };
    DataTransferItem: { prototype: DataTransferItem; new (): DataTransferItem };
    DataTransferItemList: {
        prototype: DataTransferItemList;
        new (): DataTransferItemList;
    };
    DataView: DataViewConstructor;
    Date: DateConstructor;
    decodeURI: (encodedURI: string) => string;
    decodeURIComponent: (encodedURIComponent: string) => string;
    DecompressionStream: {
        prototype: DecompressionStream;
        new (format: CompressionFormat): DecompressionStream;
    };
    DedicatedWorkerGlobalScope: {
        prototype: DedicatedWorkerGlobalScope;
        new (): DedicatedWorkerGlobalScope;
    };
    DelayNode: {
        prototype: DelayNode;
        new (context: BaseAudioContext, options?: DelayOptions): DelayNode;
    };
    describe: (description: string, specDefinitions: () => void) => void;
    DeviceMotionEvent: {
        prototype: DeviceMotionEvent;
        new (
            type: string,
            eventInitDict?: DeviceMotionEventInit,
        ): DeviceMotionEvent;
    };
    DeviceOrientationEvent: {
        prototype: DeviceOrientationEvent;
        new (
            type: string,
            eventInitDict?: DeviceOrientationEventInit,
        ): DeviceOrientationEvent;
    };
    devicePixelRatio: number;
    devtoolsFormatters: any[];
    DigitalCredential: {
        prototype: DigitalCredential;
        userAgentAllowsProtocol(protocol: string): boolean;
        new (): DigitalCredential;
    };
    dispatchEvent: {
        (event: Event): boolean;
        (event: Event): boolean;
        (event: Event): boolean;
    };
    document: Document;
    Document: {
        prototype: Document;
        parseHTMLUnsafe(html: string): Document;
        new (): Document;
    };
    DocumentFragment: { prototype: DocumentFragment; new (): DocumentFragment };
    DocumentTimeline: {
        prototype: DocumentTimeline;
        new (options?: DocumentTimelineOptions): DocumentTimeline;
    };
    DocumentType: { prototype: DocumentType; new (): DocumentType };
    DOMException: {
        ABORT_ERR: 20;
        DATA_CLONE_ERR: 25;
        DOMSTRING_SIZE_ERR: 2;
        HIERARCHY_REQUEST_ERR: 3;
        INDEX_SIZE_ERR: 1;
        INUSE_ATTRIBUTE_ERR: 10;
        INVALID_ACCESS_ERR: 15;
        INVALID_CHARACTER_ERR: 5;
        INVALID_MODIFICATION_ERR: 13;
        INVALID_NODE_TYPE_ERR: 24;
        INVALID_STATE_ERR: 11;
        NAMESPACE_ERR: 14;
        NETWORK_ERR: 19;
        NO_DATA_ALLOWED_ERR: 6;
        NO_MODIFICATION_ALLOWED_ERR: 7;
        NOT_FOUND_ERR: 8;
        NOT_SUPPORTED_ERR: 9;
        prototype: DOMException;
        QUOTA_EXCEEDED_ERR: 22;
        SECURITY_ERR: 18;
        SYNTAX_ERR: 12;
        TIMEOUT_ERR: 23;
        TYPE_MISMATCH_ERR: 17;
        URL_MISMATCH_ERR: 21;
        VALIDATION_ERR: 16;
        WRONG_DOCUMENT_ERR: 4;
        new (message?: string, name?: string): DOMException;
    };
    DOMImplementation: {
        prototype: DOMImplementation;
        new (): DOMImplementation;
    };
    DOMMatrix: {
        prototype: DOMMatrix;
        fromFloat32Array(array32: Float32Array<ArrayBuffer>): DOMMatrix;
        fromFloat64Array(array64: Float64Array<ArrayBuffer>): DOMMatrix;
        fromMatrix(other?: DOMMatrixInit): DOMMatrix;
        new (init?: string | number[]): DOMMatrix;
    };
    DOMMatrixReadOnly: {
        prototype: DOMMatrixReadOnly;
        fromFloat32Array(array32: Float32Array<ArrayBuffer>): DOMMatrixReadOnly;
        fromFloat64Array(array64: Float64Array<ArrayBuffer>): DOMMatrixReadOnly;
        fromMatrix(other?: DOMMatrixInit): DOMMatrixReadOnly;
        new (init?: string | number[]): DOMMatrixReadOnly;
    };
    DOMParser: { prototype: DOMParser; new (): DOMParser };
    DOMPoint: {
        prototype: DOMPoint;
        fromPoint(other?: DOMPointInit): DOMPoint;
        new (x?: number, y?: number, z?: number, w?: number): DOMPoint;
    };
    DOMPointReadOnly: {
        prototype: DOMPointReadOnly;
        fromPoint(other?: DOMPointInit): DOMPointReadOnly;
        new (x?: number, y?: number, z?: number, w?: number): DOMPointReadOnly;
    };
    DOMQuad: {
        prototype: DOMQuad;
        fromQuad(other?: DOMQuadInit): DOMQuad;
        fromRect(other?: DOMRectInit): DOMQuad;
        new (
            p1?: DOMPointInit,
            p2?: DOMPointInit,
            p3?: DOMPointInit,
            p4?: DOMPointInit,
        ): DOMQuad;
    };
    DOMRect: {
        prototype: DOMRect;
        fromRect(other?: DOMRectInit): DOMRect;
        new (x?: number, y?: number, width?: number, height?: number): DOMRect;
    };
    DOMRectList: { prototype: DOMRectList; new (): DOMRectList };
    DOMRectReadOnly: {
        prototype: DOMRectReadOnly;
        fromRect(other?: DOMRectInit): DOMRectReadOnly;
        new (
            x?: number,
            y?: number,
            width?: number,
            height?: number,
        ): DOMRectReadOnly;
    };
    DOMStringList: { prototype: DOMStringList; new (): DOMStringList };
    DOMStringMap: { prototype: DOMStringMap; new (): DOMStringMap };
    DOMTokenList: { prototype: DOMTokenList; new (): DOMTokenList };
    DragEvent: {
        prototype: DragEvent;
        new (type: string, eventInitDict?: DragEventInit): DragEvent;
    };
    DynamicsCompressorNode: {
        prototype: DynamicsCompressorNode;
        new (
            context: BaseAudioContext,
            options?: DynamicsCompressorOptions,
        ): DynamicsCompressorNode;
    };
    Element: { prototype: Element; new (): Element };
    ElementInternals: { prototype: ElementInternals; new (): ElementInternals };
    EncodedAudioChunk: {
        prototype: EncodedAudioChunk;
        new (init: EncodedAudioChunkInit): EncodedAudioChunk;
    };
    EncodedVideoChunk: {
        prototype: EncodedVideoChunk;
        new (init: EncodedVideoChunkInit): EncodedVideoChunk;
    };
    encodeURI: (uri: string) => string;
    encodeURIComponent: (uriComponent: string | number | boolean) => string;
    Error: ErrorConstructor;
    ErrorEvent: {
        prototype: ErrorEvent;
        new (type: string, eventInitDict?: ErrorEventInit): ErrorEvent;
    };
    escape: (string: string) => string;
    eval: (x: string) => any;
    EvalError: EvalErrorConstructor;
    event: Event | undefined;
    Event: {
        AT_TARGET: 2;
        BUBBLING_PHASE: 3;
        CAPTURING_PHASE: 1;
        NONE: 0;
        prototype: Event;
        new (type: string, eventInitDict?: EventInit): Event;
    };
    EventCounts: { prototype: EventCounts; new (): EventCounts };
    EventSource: {
        CLOSED: 2;
        CONNECTING: 0;
        OPEN: 1;
        prototype: EventSource;
        new (
            url: string | URL,
            eventSourceInitDict?: EventSourceInit,
        ): EventSource;
    };
    EventTarget: { prototype: EventTarget; new (): EventTarget };
    expect: {
        <T extends Func>(spy: T | Spy<T>): FunctionMatchers<T>;
        <T>(actual: ArrayLike<T>): ArrayLikeMatchers<T>;
        <T>(actual: T): Matchers<T>;
        (): NothingMatcher;
    };
    expectAsync: <T, U>(actual: T | PromiseLike<T>) => AsyncMatchers<T, U>;
    ExtendableCookieChangeEvent: {
        prototype: ExtendableCookieChangeEvent;
        new (
            type: string,
            eventInitDict?: ExtendableCookieChangeEventInit,
        ): ExtendableCookieChangeEvent;
    };
    ExtendableEvent: {
        prototype: ExtendableEvent;
        new (type: string, eventInitDict?: ExtendableEventInit): ExtendableEvent;
    };
    ExtendableMessageEvent: {
        prototype: ExtendableMessageEvent;
        new (
            type: string,
            eventInitDict?: ExtendableMessageEventInit,
        ): ExtendableMessageEvent;
    };
    external: External;
    External: { prototype: External; new (): External };
    fail: (e?: any) => void;
    fdescribe: (description: string, specDefinitions: () => void) => void;
    fetch: {
        (input: URL | RequestInfo, init?: RequestInit): Promise<Response>;
        (input: URL | RequestInfo, init?: RequestInit): Promise<Response>;
    };
    FetchEvent: {
        prototype: FetchEvent;
        new (type: string, eventInitDict: FetchEventInit): FetchEvent;
    };
    File: {
        prototype: File;
        new (
            fileBits: BlobPart[],
            fileName: string,
            options?: FilePropertyBag,
        ): File;
    };
    FileList: { prototype: FileList; new (): FileList };
    FileReader: {
        DONE: 2;
        EMPTY: 0;
        LOADING: 1;
        prototype: FileReader;
        new (): FileReader;
    };
    FileReaderSync: { prototype: FileReaderSync; new (): FileReaderSync };
    FileSystem: { prototype: FileSystem; new (): FileSystem };
    FileSystemDirectoryEntry: {
        prototype: FileSystemDirectoryEntry;
        new (): FileSystemDirectoryEntry;
    };
    FileSystemDirectoryHandle: {
        prototype: FileSystemDirectoryHandle;
        new (): FileSystemDirectoryHandle;
    };
    FileSystemDirectoryReader: {
        prototype: FileSystemDirectoryReader;
        new (): FileSystemDirectoryReader;
    };
    FileSystemEntry: { prototype: FileSystemEntry; new (): FileSystemEntry };
    FileSystemFileEntry: {
        prototype: FileSystemFileEntry;
        new (): FileSystemFileEntry;
    };
    FileSystemFileHandle: {
        prototype: FileSystemFileHandle;
        new (): FileSystemFileHandle;
    };
    FileSystemHandle: { prototype: FileSystemHandle; new (): FileSystemHandle };
    FileSystemSyncAccessHandle: {
        prototype: FileSystemSyncAccessHandle;
        new (): FileSystemSyncAccessHandle;
    };
    FileSystemWritableFileStream: {
        prototype: FileSystemWritableFileStream;
        new (): FileSystemWritableFileStream;
    };
    fit: (
        expectation: string,
        assertion?: ImplementationCallback,
        timeout?: number,
    ) => void;
    Float32Array: Float32ArrayConstructor;
    Float64Array: Float64ArrayConstructor;
    focus: () => void;
    FocusEvent: {
        prototype: FocusEvent;
        new (type: string, eventInitDict?: FocusEventInit): FocusEvent;
    };
    FontFace: {
        prototype: FontFace;
        new (
            family: string,
            source: string | BufferSource,
            descriptors?: FontFaceDescriptors,
        ): FontFace;
    };
    FontFaceSet: { prototype: FontFaceSet; new (): FontFaceSet };
    FontFaceSetLoadEvent: {
        prototype: FontFaceSetLoadEvent;
        new (
            type: string,
            eventInitDict?: FontFaceSetLoadEventInit,
        ): FontFaceSetLoadEvent;
    };
    fonts: FontFaceSet;
    FormData: {
        prototype: FormData;
        new (form?: HTMLFormElement, submitter?: HTMLElement | null): FormData;
    };
    FormDataEvent: {
        prototype: FormDataEvent;
        new (type: string, eventInitDict: FormDataEventInit): FormDataEvent;
    };
    FragmentDirective: {
        prototype: FragmentDirective;
        new (): FragmentDirective;
    };
    frameElement: Element
    | null;
    frames: Window;
    Function: FunctionConstructor;
    GainNode: {
        prototype: GainNode;
        new (context: BaseAudioContext, options?: GainOptions): GainNode;
    };
    Gamepad: { prototype: Gamepad; new (): Gamepad };
    GamepadButton: { prototype: GamepadButton; new (): GamepadButton };
    GamepadEvent: {
        prototype: GamepadEvent;
        new (type: string, eventInitDict?: GamepadEventInit): GamepadEvent;
    };
    GamepadHapticActuator: {
        prototype: GamepadHapticActuator;
        new (): GamepadHapticActuator;
    };
    Geolocation: { prototype: Geolocation; new (): Geolocation };
    GeolocationCoordinates: {
        prototype: GeolocationCoordinates;
        new (): GeolocationCoordinates;
    };
    GeolocationPosition: {
        prototype: GeolocationPosition;
        new (): GeolocationPosition;
    };
    GeolocationPositionError: {
        PERMISSION_DENIED: 1;
        POSITION_UNAVAILABLE: 2;
        prototype: GeolocationPositionError;
        TIMEOUT: 3;
        new (): GeolocationPositionError;
    };
    getComputedStyle: (
        elt: Element,
        pseudoElt?: string | null,
    ) => CSSStyleDeclaration;
    getSelection: () => Selection | null;
    globalThis: typeof globalThis;
    GPU: { prototype: GPU; new (): GPU };
    GPUAdapter: { prototype: GPUAdapter; new (): GPUAdapter };
    GPUAdapterInfo: { prototype: GPUAdapterInfo; new (): GPUAdapterInfo };
    GPUBindGroup: { prototype: GPUBindGroup; new (): GPUBindGroup };
    GPUBindGroupLayout: {
        prototype: GPUBindGroupLayout;
        new (): GPUBindGroupLayout;
    };
    GPUBuffer: { prototype: GPUBuffer; new (): GPUBuffer };
    GPUCanvasContext: { prototype: GPUCanvasContext; new (): GPUCanvasContext };
    GPUCommandBuffer: { prototype: GPUCommandBuffer; new (): GPUCommandBuffer };
    GPUCommandEncoder: {
        prototype: GPUCommandEncoder;
        new (): GPUCommandEncoder;
    };
    GPUCompilationInfo: {
        prototype: GPUCompilationInfo;
        new (): GPUCompilationInfo;
    };
    GPUCompilationMessage: {
        prototype: GPUCompilationMessage;
        new (): GPUCompilationMessage;
    };
    GPUComputePassEncoder: {
        prototype: GPUComputePassEncoder;
        new (): GPUComputePassEncoder;
    };
    GPUComputePipeline: {
        prototype: GPUComputePipeline;
        new (): GPUComputePipeline;
    };
    GPUDevice: { prototype: GPUDevice; new (): GPUDevice };
    GPUDeviceLostInfo: {
        prototype: GPUDeviceLostInfo;
        new (): GPUDeviceLostInfo;
    };
    GPUError: { prototype: GPUError; new (): GPUError };
    GPUExternalTexture: {
        prototype: GPUExternalTexture;
        new (): GPUExternalTexture;
    };
    GPUInternalError: {
        prototype: GPUInternalError;
        new (message: string): GPUInternalError;
    };
    GPUOutOfMemoryError: {
        prototype: GPUOutOfMemoryError;
        new (message: string): GPUOutOfMemoryError;
    };
    GPUPipelineError: {
        prototype: GPUPipelineError;
        new (message: string, options: GPUPipelineErrorInit): GPUPipelineError;
    };
    GPUPipelineLayout: {
        prototype: GPUPipelineLayout;
        new (): GPUPipelineLayout;
    };
    GPUQuerySet: { prototype: GPUQuerySet; new (): GPUQuerySet };
    GPUQueue: { prototype: GPUQueue; new (): GPUQueue };
    GPURenderBundle: { prototype: GPURenderBundle; new (): GPURenderBundle };
    GPURenderBundleEncoder: {
        prototype: GPURenderBundleEncoder;
        new (): GPURenderBundleEncoder;
    };
    GPURenderPassEncoder: {
        prototype: GPURenderPassEncoder;
        new (): GPURenderPassEncoder;
    };
    GPURenderPipeline: {
        prototype: GPURenderPipeline;
        new (): GPURenderPipeline;
    };
    GPUSampler: { prototype: GPUSampler; new (): GPUSampler };
    GPUShaderModule: { prototype: GPUShaderModule; new (): GPUShaderModule };
    GPUSupportedFeatures: {
        prototype: GPUSupportedFeatures;
        new (): GPUSupportedFeatures;
    };
    GPUSupportedLimits: {
        prototype: GPUSupportedLimits;
        new (): GPUSupportedLimits;
    };
    GPUTexture: { prototype: GPUTexture; new (): GPUTexture };
    GPUTextureView: { prototype: GPUTextureView; new (): GPUTextureView };
    GPUUncapturedErrorEvent: {
        prototype: GPUUncapturedErrorEvent;
        new (
            type: string,
            gpuUncapturedErrorEventInitDict: GPUUncapturedErrorEventInit,
        ): GPUUncapturedErrorEvent;
    };
    GPUValidationError: {
        prototype: GPUValidationError;
        new (message: string): GPUValidationError;
    };
    HashChangeEvent: {
        prototype: HashChangeEvent;
        new (type: string, eventInitDict?: HashChangeEventInit): HashChangeEvent;
    };
    Headers: { prototype: Headers; new (init?: HeadersInit): Headers };
    Highlight: {
        prototype: Highlight;
        new (...initialRanges: AbstractRange[]): Highlight;
    };
    HighlightRegistry: {
        prototype: HighlightRegistry;
        new (): HighlightRegistry;
    };
    history: History;
    History: { prototype: History; new (): History };
    HTMLAllCollection: {
        prototype: HTMLAllCollection;
        new (): HTMLAllCollection;
    };
    HTMLAnchorElement: {
        prototype: HTMLAnchorElement;
        new (): HTMLAnchorElement;
    };
    HTMLAreaElement: { prototype: HTMLAreaElement; new (): HTMLAreaElement };
    HTMLAudioElement: { prototype: HTMLAudioElement; new (): HTMLAudioElement };
    HTMLBaseElement: { prototype: HTMLBaseElement; new (): HTMLBaseElement };
    HTMLBodyElement: { prototype: HTMLBodyElement; new (): HTMLBodyElement };
    HTMLBRElement: { prototype: HTMLBRElement; new (): HTMLBRElement };
    HTMLButtonElement: {
        prototype: HTMLButtonElement;
        new (): HTMLButtonElement;
    };
    HTMLCanvasElement: {
        prototype: HTMLCanvasElement;
        new (): HTMLCanvasElement;
    };
    HTMLCollection: { prototype: HTMLCollection; new (): HTMLCollection };
    HTMLDataElement: { prototype: HTMLDataElement; new (): HTMLDataElement };
    HTMLDataListElement: {
        prototype: HTMLDataListElement;
        new (): HTMLDataListElement;
    };
    HTMLDetailsElement: {
        prototype: HTMLDetailsElement;
        new (): HTMLDetailsElement;
    };
    HTMLDialogElement: {
        prototype: HTMLDialogElement;
        new (): HTMLDialogElement;
    };
    HTMLDirectoryElement: {
        prototype: HTMLDirectoryElement;
        new (): HTMLDirectoryElement;
    };
    HTMLDivElement: { prototype: HTMLDivElement; new (): HTMLDivElement };
    HTMLDListElement: { prototype: HTMLDListElement; new (): HTMLDListElement };
    HTMLDocument: { prototype: HTMLDocument; new (): HTMLDocument };
    HTMLElement: { prototype: HTMLElement; new (): HTMLElement };
    HTMLEmbedElement: { prototype: HTMLEmbedElement; new (): HTMLEmbedElement };
    HTMLFieldSetElement: {
        prototype: HTMLFieldSetElement;
        new (): HTMLFieldSetElement;
    };
    HTMLFontElement: { prototype: HTMLFontElement; new (): HTMLFontElement };
    HTMLFormControlsCollection: {
        prototype: HTMLFormControlsCollection;
        new (): HTMLFormControlsCollection;
    };
    HTMLFormElement: { prototype: HTMLFormElement; new (): HTMLFormElement };
    HTMLFrameElement: { prototype: HTMLFrameElement; new (): HTMLFrameElement };
    HTMLFrameSetElement: {
        prototype: HTMLFrameSetElement;
        new (): HTMLFrameSetElement;
    };
    HTMLHeadElement: { prototype: HTMLHeadElement; new (): HTMLHeadElement };
    HTMLHeadingElement: {
        prototype: HTMLHeadingElement;
        new (): HTMLHeadingElement;
    };
    HTMLHRElement: { prototype: HTMLHRElement; new (): HTMLHRElement };
    HTMLHtmlElement: { prototype: HTMLHtmlElement; new (): HTMLHtmlElement };
    HTMLIFrameElement: {
        prototype: HTMLIFrameElement;
        new (): HTMLIFrameElement;
    };
    HTMLImageElement: { prototype: HTMLImageElement; new (): HTMLImageElement };
    HTMLInputElement: { prototype: HTMLInputElement; new (): HTMLInputElement };
    HTMLLabelElement: { prototype: HTMLLabelElement; new (): HTMLLabelElement };
    HTMLLegendElement: {
        prototype: HTMLLegendElement;
        new (): HTMLLegendElement;
    };
    HTMLLIElement: { prototype: HTMLLIElement; new (): HTMLLIElement };
    HTMLLinkElement: { prototype: HTMLLinkElement; new (): HTMLLinkElement };
    HTMLMapElement: { prototype: HTMLMapElement; new (): HTMLMapElement };
    HTMLMarqueeElement: {
        prototype: HTMLMarqueeElement;
        new (): HTMLMarqueeElement;
    };
    HTMLMediaElement: {
        HAVE_CURRENT_DATA: 2;
        HAVE_ENOUGH_DATA: 4;
        HAVE_FUTURE_DATA: 3;
        HAVE_METADATA: 1;
        HAVE_NOTHING: 0;
        NETWORK_EMPTY: 0;
        NETWORK_IDLE: 1;
        NETWORK_LOADING: 2;
        NETWORK_NO_SOURCE: 3;
        prototype: HTMLMediaElement;
        new (): HTMLMediaElement;
    };
    HTMLMenuElement: { prototype: HTMLMenuElement; new (): HTMLMenuElement };
    HTMLMetaElement: { prototype: HTMLMetaElement; new (): HTMLMetaElement };
    HTMLMeterElement: { prototype: HTMLMeterElement; new (): HTMLMeterElement };
    HTMLModElement: { prototype: HTMLModElement; new (): HTMLModElement };
    HTMLObjectElement: {
        prototype: HTMLObjectElement;
        new (): HTMLObjectElement;
    };
    HTMLOListElement: { prototype: HTMLOListElement; new (): HTMLOListElement };
    HTMLOptGroupElement: {
        prototype: HTMLOptGroupElement;
        new (): HTMLOptGroupElement;
    };
    HTMLOptionElement: {
        prototype: HTMLOptionElement;
        new (): HTMLOptionElement;
    };
    HTMLOptionsCollection: {
        prototype: HTMLOptionsCollection;
        new (): HTMLOptionsCollection;
    };
    HTMLOutputElement: {
        prototype: HTMLOutputElement;
        new (): HTMLOutputElement;
    };
    HTMLParagraphElement: {
        prototype: HTMLParagraphElement;
        new (): HTMLParagraphElement;
    };
    HTMLParamElement: { prototype: HTMLParamElement; new (): HTMLParamElement };
    HTMLPictureElement: {
        prototype: HTMLPictureElement;
        new (): HTMLPictureElement;
    };
    HTMLPreElement: { prototype: HTMLPreElement; new (): HTMLPreElement };
    HTMLProgressElement: {
        prototype: HTMLProgressElement;
        new (): HTMLProgressElement;
    };
    HTMLQuoteElement: { prototype: HTMLQuoteElement; new (): HTMLQuoteElement };
    HTMLScriptElement: {
        prototype: HTMLScriptElement;
        supports(type: string): boolean;
        new (): HTMLScriptElement;
    };
    HTMLSelectElement: {
        prototype: HTMLSelectElement;
        new (): HTMLSelectElement;
    };
    HTMLSlotElement: { prototype: HTMLSlotElement; new (): HTMLSlotElement };
    HTMLSourceElement: {
        prototype: HTMLSourceElement;
        new (): HTMLSourceElement;
    };
    HTMLSpanElement: { prototype: HTMLSpanElement; new (): HTMLSpanElement };
    HTMLStyleElement: { prototype: HTMLStyleElement; new (): HTMLStyleElement };
    HTMLTableCaptionElement: {
        prototype: HTMLTableCaptionElement;
        new (): HTMLTableCaptionElement;
    };
    HTMLTableCellElement: {
        prototype: HTMLTableCellElement;
        new (): HTMLTableCellElement;
    };
    HTMLTableColElement: {
        prototype: HTMLTableColElement;
        new (): HTMLTableColElement;
    };
    HTMLTableElement: { prototype: HTMLTableElement; new (): HTMLTableElement };
    HTMLTableRowElement: {
        prototype: HTMLTableRowElement;
        new (): HTMLTableRowElement;
    };
    HTMLTableSectionElement: {
        prototype: HTMLTableSectionElement;
        new (): HTMLTableSectionElement;
    };
    HTMLTemplateElement: {
        prototype: HTMLTemplateElement;
        new (): HTMLTemplateElement;
    };
    HTMLTextAreaElement: {
        prototype: HTMLTextAreaElement;
        new (): HTMLTextAreaElement;
    };
    HTMLTimeElement: { prototype: HTMLTimeElement; new (): HTMLTimeElement };
    HTMLTitleElement: { prototype: HTMLTitleElement; new (): HTMLTitleElement };
    HTMLTrackElement: {
        ERROR: 3;
        LOADED: 2;
        LOADING: 1;
        NONE: 0;
        prototype: HTMLTrackElement;
        new (): HTMLTrackElement;
    };
    HTMLUListElement: { prototype: HTMLUListElement; new (): HTMLUListElement };
    HTMLUnknownElement: {
        prototype: HTMLUnknownElement;
        new (): HTMLUnknownElement;
    };
    HTMLVideoElement: { prototype: HTMLVideoElement; new (): HTMLVideoElement };
    IDBCursor: { prototype: IDBCursor; new (): IDBCursor };
    IDBCursorWithValue: {
        prototype: IDBCursorWithValue;
        new (): IDBCursorWithValue;
    };
    IDBDatabase: { prototype: IDBDatabase; new (): IDBDatabase };
    IDBFactory: { prototype: IDBFactory; new (): IDBFactory };
    IDBIndex: { prototype: IDBIndex; new (): IDBIndex };
    IDBKeyRange: {
        prototype: IDBKeyRange;
        bound(
            lower: any,
            upper: any,
            lowerOpen?: boolean,
            upperOpen?: boolean,
        ): IDBKeyRange;
        lowerBound(lower: any, open?: boolean): IDBKeyRange;
        only(value: any): IDBKeyRange;
        upperBound(upper: any, open?: boolean): IDBKeyRange;
        new (): IDBKeyRange;
    };
    IDBObjectStore: { prototype: IDBObjectStore; new (): IDBObjectStore };
    IDBOpenDBRequest: { prototype: IDBOpenDBRequest; new (): IDBOpenDBRequest };
    IDBRequest: { prototype: IDBRequest; new (): IDBRequest };
    IDBTransaction: { prototype: IDBTransaction; new (): IDBTransaction };
    IDBVersionChangeEvent: {
        prototype: IDBVersionChangeEvent;
        new (
            type: string,
            eventInitDict?: IDBVersionChangeEventInit,
        ): IDBVersionChangeEvent;
    };
    IdleDeadline: { prototype: IdleDeadline; new (): IdleDeadline };
    IIRFilterNode: {
        prototype: IIRFilterNode;
        new (context: BaseAudioContext, options: IIRFilterOptions): IIRFilterNode;
    };
    Image: new (width?: number, height?: number) => HTMLImageElement;
    ImageBitmap: { prototype: ImageBitmap; new (): ImageBitmap };
    ImageBitmapRenderingContext: {
        prototype: ImageBitmapRenderingContext;
        new (): ImageBitmapRenderingContext;
    };
    ImageCapture: {
        prototype: ImageCapture;
        new (videoTrack: MediaStreamTrack): ImageCapture;
    };
    ImageData: {
        prototype: ImageData;
        new (sw: number, sh: number, settings?: ImageDataSettings): ImageData;
        new (
            data: ImageDataArray,
            sw: number,
            sh?: number,
            settings?: ImageDataSettings,
        ): ImageData;
    };
    ImageDecoder: {
        prototype: ImageDecoder;
        isTypeSupported(type: string): Promise<boolean>;
        new (init: ImageDecoderInit): ImageDecoder;
    };
    ImageTrack: { prototype: ImageTrack; new (): ImageTrack };
    ImageTrackList: { prototype: ImageTrackList; new (): ImageTrackList };
    importScripts: (...urls: (string | URL)[]) => void;
    indexedDB: IDBFactory;
    Infinity: number;
    innerHeight: number;
    innerWidth: number;
    InputDeviceInfo: { prototype: InputDeviceInfo; new (): InputDeviceInfo };
    InputEvent: {
        prototype: InputEvent;
        new (type: string, eventInitDict?: InputEventInit): InputEvent;
    };
    Int16Array: Int16ArrayConstructor;
    Int32Array: Int32ArrayConstructor;
    Int8Array: Int8ArrayConstructor;
    IntersectionObserver: {
        prototype: IntersectionObserver;
        new (
            callback: IntersectionObserverCallback,
            options?: IntersectionObserverInit,
        ): IntersectionObserver;
    };
    IntersectionObserverEntry: {
        prototype: IntersectionObserverEntry;
        new (): IntersectionObserverEntry;
    };
    Intl: typeof Intl;
    isFinite: (number: number) => boolean;
    isNaN: (number: number) => boolean;
    isSecureContext: boolean;
    it: (
        expectation: string,
        assertion?: ImplementationCallback,
        timeout?: number,
    ) => void;
    jasmine: typeof jasmine;
    JSON: JSON;
    KeyboardEvent: {
        DOM_KEY_LOCATION_LEFT: 1;
        DOM_KEY_LOCATION_NUMPAD: 3;
        DOM_KEY_LOCATION_RIGHT: 2;
        DOM_KEY_LOCATION_STANDARD: 0;
        prototype: KeyboardEvent;
        new (type: string, eventInitDict?: KeyboardEventInit): KeyboardEvent;
    };
    KeyframeEffect: {
        prototype: KeyframeEffect;
        new (
            target: Element | null,
            keyframes: Keyframe[] | PropertyIndexedKeyframes | null,
            options?: number | KeyframeEffectOptions,
        ): KeyframeEffect;
        new (source: KeyframeEffect): KeyframeEffect;
    };
    LargestContentfulPaint: {
        prototype: LargestContentfulPaint;
        new (): LargestContentfulPaint;
    };
    length: number;
    localStorage: Storage;
    location: Location;
    Location: { prototype: Location; new (): Location };
    locationbar: BarProp;
    Lock: { prototype: Lock; new (): Lock };
    LockManager: { prototype: LockManager; new (): LockManager };
    Map: MapConstructor;
    matchMedia: (query: string) => MediaQueryList;
    Math: Math;
    MathMLElement: { prototype: MathMLElement; new (): MathMLElement };
    MediaCapabilities: {
        prototype: MediaCapabilities;
        new (): MediaCapabilities;
    };
    MediaDeviceInfo: { prototype: MediaDeviceInfo; new (): MediaDeviceInfo };
    MediaDevices: { prototype: MediaDevices; new (): MediaDevices };
    MediaElementAudioSourceNode: {
        prototype: MediaElementAudioSourceNode;
        new (
            context: AudioContext,
            options: MediaElementAudioSourceOptions,
        ): MediaElementAudioSourceNode;
    };
    MediaEncryptedEvent: {
        prototype: MediaEncryptedEvent;
        new (
            type: string,
            eventInitDict?: MediaEncryptedEventInit,
        ): MediaEncryptedEvent;
    };
    MediaError: {
        MEDIA_ERR_ABORTED: 1;
        MEDIA_ERR_DECODE: 3;
        MEDIA_ERR_NETWORK: 2;
        MEDIA_ERR_SRC_NOT_SUPPORTED: 4;
        prototype: MediaError;
        new (): MediaError;
    };
    MediaKeyMessageEvent: {
        prototype: MediaKeyMessageEvent;
        new (
            type: string,
            eventInitDict: MediaKeyMessageEventInit,
        ): MediaKeyMessageEvent;
    };
    MediaKeys: { prototype: MediaKeys; new (): MediaKeys };
    MediaKeySession: { prototype: MediaKeySession; new (): MediaKeySession };
    MediaKeyStatusMap: {
        prototype: MediaKeyStatusMap;
        new (): MediaKeyStatusMap;
    };
    MediaKeySystemAccess: {
        prototype: MediaKeySystemAccess;
        new (): MediaKeySystemAccess;
    };
    MediaList: { prototype: MediaList; new (): MediaList };
    MediaMetadata: {
        prototype: MediaMetadata;
        new (init?: MediaMetadataInit): MediaMetadata;
    };
    MediaQueryList: { prototype: MediaQueryList; new (): MediaQueryList };
    MediaQueryListEvent: {
        prototype: MediaQueryListEvent;
        new (
            type: string,
            eventInitDict?: MediaQueryListEventInit,
        ): MediaQueryListEvent;
    };
    MediaRecorder: {
        prototype: MediaRecorder;
        isTypeSupported(type: string): boolean;
        new (stream: MediaStream, options?: MediaRecorderOptions): MediaRecorder;
    };
    MediaSession: { prototype: MediaSession; new (): MediaSession };
    MediaSource: {
        canConstructInDedicatedWorker: boolean;
        prototype: MediaSource;
        isTypeSupported(type: string): boolean;
        new (): MediaSource;
    };
    MediaSourceHandle: {
        prototype: MediaSourceHandle;
        new (): MediaSourceHandle;
    };
    MediaStream: {
        prototype: MediaStream;
        new (): MediaStream;
        new (stream: MediaStream): MediaStream;
        new (tracks: MediaStreamTrack[]): MediaStream;
    };
    MediaStreamAudioDestinationNode: {
        prototype: MediaStreamAudioDestinationNode;
        new (
            context: AudioContext,
            options?: AudioNodeOptions,
        ): MediaStreamAudioDestinationNode;
    };
    MediaStreamAudioSourceNode: {
        prototype: MediaStreamAudioSourceNode;
        new (
            context: AudioContext,
            options: MediaStreamAudioSourceOptions,
        ): MediaStreamAudioSourceNode;
    };
    MediaStreamTrack: { prototype: MediaStreamTrack; new (): MediaStreamTrack };
    MediaStreamTrackEvent: {
        prototype: MediaStreamTrackEvent;
        new (
            type: string,
            eventInitDict: MediaStreamTrackEventInit,
        ): MediaStreamTrackEvent;
    };
    MediaStreamTrackProcessor: {
        prototype: MediaStreamTrackProcessor;
        new (init: MediaStreamTrackProcessorInit): MediaStreamTrackProcessor;
    };
    menubar: BarProp;
    MessageChannel: { prototype: MessageChannel; new (): MessageChannel };
    MessageEvent: {
        prototype: MessageEvent;
        new <T>(
            type: string,
            eventInitDict?: MessageEventInit<T>,
        ): MessageEvent<T>;
    };
    MessagePort: { prototype: MessagePort; new (): MessagePort };
    MIDIAccess: { prototype: MIDIAccess; new (): MIDIAccess };
    MIDIConnectionEvent: {
        prototype: MIDIConnectionEvent;
        new (
            type: string,
            eventInitDict?: MIDIConnectionEventInit,
        ): MIDIConnectionEvent;
    };
    MIDIInput: { prototype: MIDIInput; new (): MIDIInput };
    MIDIInputMap: { prototype: MIDIInputMap; new (): MIDIInputMap };
    MIDIMessageEvent: {
        prototype: MIDIMessageEvent;
        new (type: string, eventInitDict?: MIDIMessageEventInit): MIDIMessageEvent;
    };
    MIDIOutput: { prototype: MIDIOutput; new (): MIDIOutput };
    MIDIOutputMap: { prototype: MIDIOutputMap; new (): MIDIOutputMap };
    MIDIPort: { prototype: MIDIPort; new (): MIDIPort };
    MimeType: { prototype: MimeType; new (): MimeType };
    MimeTypeArray: { prototype: MimeTypeArray; new (): MimeTypeArray };
    MouseEvent: {
        prototype: MouseEvent;
        new (type: string, eventInitDict?: MouseEventInit): MouseEvent;
    };
    moveBy: (x: number, y: number) => void;
    moveTo: (x: number, y: number) => void;
    MutationObserver: {
        prototype: MutationObserver;
        new (callback: MutationCallback): MutationObserver;
    };
    MutationRecord: { prototype: MutationRecord; new (): MutationRecord };
    NamedNodeMap: { prototype: NamedNodeMap; new (): NamedNodeMap };
    NaN: number;
    NavigateEvent: {
        prototype: NavigateEvent;
        new (type: string, eventInitDict: NavigateEventInit): NavigateEvent;
    };
    navigation: Navigation;
    Navigation: { prototype: Navigation; new (): Navigation };
    NavigationActivation: {
        prototype: NavigationActivation;
        new (): NavigationActivation;
    };
    NavigationCurrentEntryChangeEvent: {
        prototype: NavigationCurrentEntryChangeEvent;
        new (
            type: string,
            eventInitDict: NavigationCurrentEntryChangeEventInit,
        ): NavigationCurrentEntryChangeEvent;
    };
    NavigationDestination: {
        prototype: NavigationDestination;
        new (): NavigationDestination;
    };
    NavigationHistoryEntry: {
        prototype: NavigationHistoryEntry;
        new (): NavigationHistoryEntry;
    };
    NavigationPrecommitController: {
        prototype: NavigationPrecommitController;
        new (): NavigationPrecommitController;
    };
    NavigationPreloadManager: {
        prototype: NavigationPreloadManager;
        new (): NavigationPreloadManager;
    };
    NavigationTransition: {
        prototype: NavigationTransition;
        new (): NavigationTransition;
    };
    navigator?: Navigator;
    Navigator: { prototype: Navigator; new (): Navigator };
    NavigatorLogin: { prototype: NavigatorLogin; new (): NavigatorLogin };
    ngHmrMode: boolean | undefined;
    ngServerMode: boolean | undefined;
    Node: {
        ATTRIBUTE_NODE: 2;
        CDATA_SECTION_NODE: 4;
        COMMENT_NODE: 8;
        DOCUMENT_FRAGMENT_NODE: 11;
        DOCUMENT_NODE: 9;
        DOCUMENT_POSITION_CONTAINED_BY: 16;
        DOCUMENT_POSITION_CONTAINS: 8;
        DOCUMENT_POSITION_DISCONNECTED: 1;
        DOCUMENT_POSITION_FOLLOWING: 4;
        DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC: 32;
        DOCUMENT_POSITION_PRECEDING: 2;
        DOCUMENT_TYPE_NODE: 10;
        ELEMENT_NODE: 1;
        ENTITY_NODE: 6;
        ENTITY_REFERENCE_NODE: 5;
        NOTATION_NODE: 12;
        PROCESSING_INSTRUCTION_NODE: 7;
        prototype: Node;
        TEXT_NODE: 3;
        new (): Node;
    };
    NodeFilter: {
        FILTER_ACCEPT: 1;
        FILTER_REJECT: 2;
        FILTER_SKIP: 3;
        SHOW_ALL: 4294967295;
        SHOW_ATTRIBUTE: 2;
        SHOW_CDATA_SECTION: 8;
        SHOW_COMMENT: 128;
        SHOW_DOCUMENT: 256;
        SHOW_DOCUMENT_FRAGMENT: 1024;
        SHOW_DOCUMENT_TYPE: 512;
        SHOW_ELEMENT: 1;
        SHOW_ENTITY: 32;
        SHOW_ENTITY_REFERENCE: 16;
        SHOW_NOTATION: 2048;
        SHOW_PROCESSING_INSTRUCTION: 64;
        SHOW_TEXT: 4;
    };
    NodeIterator: { prototype: NodeIterator; new (): NodeIterator };
    NodeList: { prototype: NodeList; new (): NodeList };
    Notification: {
        permission: NotificationPermission;
        prototype: Notification;
        requestPermission(
            deprecatedCallback?: NotificationPermissionCallback,
        ): Promise<NotificationPermission>;
        new (title: string, options?: NotificationOptions): Notification;
    };
    NotificationEvent: {
        prototype: NotificationEvent;
        new (
            type: string,
            eventInitDict: NotificationEventInit,
        ): NotificationEvent;
    };
    Number: NumberConstructor;
    Object: ObjectConstructor;
    OfflineAudioCompletionEvent: {
        prototype: OfflineAudioCompletionEvent;
        new (
            type: string,
            eventInitDict: OfflineAudioCompletionEventInit,
        ): OfflineAudioCompletionEvent;
    };
    OfflineAudioContext: {
        prototype: OfflineAudioContext;
        new (contextOptions: OfflineAudioContextOptions): OfflineAudioContext;
        new (
            numberOfChannels: number,
            length: number,
            sampleRate: number,
        ): OfflineAudioContext;
    };
    OffscreenCanvas: {
        prototype: OffscreenCanvas;
        new (width: number, height: number): OffscreenCanvas;
    };
    OffscreenCanvasRenderingContext2D: {
        prototype: OffscreenCanvasRenderingContext2D;
        new (): OffscreenCanvasRenderingContext2D;
    };
    onabort: ((this: Window, ev: UIEvent) => any)
    | null;
    onafterprint: ((this: Window, ev: Event) => any) | null;
    onanimationcancel: ((this: Window, ev: AnimationEvent) => any) | null;
    onanimationend: ((this: Window, ev: AnimationEvent) => any) | null;
    onanimationiteration: ((this: Window, ev: AnimationEvent) => any) | null;
    onanimationstart: ((this: Window, ev: AnimationEvent) => any) | null;
    onauxclick: ((this: Window, ev: PointerEvent) => any) | null;
    onbeforeinput: ((this: Window, ev: InputEvent) => any) | null;
    onbeforematch: ((this: Window, ev: Event) => any) | null;
    onbeforeprint: ((this: Window, ev: Event) => any) | null;
    onbeforetoggle: ((this: Window, ev: ToggleEvent) => any) | null;
    onbeforeunload: ((this: Window, ev: BeforeUnloadEvent) => any) | null;
    onblur: ((this: Window, ev: FocusEvent) => any) | null;
    oncancel: ((this: Window, ev: Event) => any) | null;
    oncanplay: ((this: Window, ev: Event) => any) | null;
    oncanplaythrough: ((this: Window, ev: Event) => any) | null;
    onchange: ((this: Window, ev: Event) => any) | null;
    onclick: ((this: Window, ev: PointerEvent) => any) | null;
    onclose: ((this: Window, ev: Event) => any) | null;
    oncommand: ((this: Window, ev: Event) => any) | null;
    oncontextlost: ((this: Window, ev: Event) => any) | null;
    oncontextmenu: ((this: Window, ev: PointerEvent) => any) | null;
    oncontextrestored: ((this: Window, ev: Event) => any) | null;
    oncopy: ((this: Window, ev: ClipboardEvent) => any) | null;
    oncuechange: ((this: Window, ev: Event) => any) | null;
    oncut: ((this: Window, ev: ClipboardEvent) => any) | null;
    ondblclick: ((this: Window, ev: MouseEvent) => any) | null;
    ondevicemotion: ((this: Window, ev: DeviceMotionEvent) => any) | null;
    ondeviceorientation:
        | ((this: Window, ev: DeviceOrientationEvent) => any)
        | null;
    ondeviceorientationabsolute:
        | ((this: Window, ev: DeviceOrientationEvent) => any)
        | null;
    ondrag: ((this: Window, ev: DragEvent) => any) | null;
    ondragend: ((this: Window, ev: DragEvent) => any) | null;
    ondragenter: ((this: Window, ev: DragEvent) => any) | null;
    ondragleave: ((this: Window, ev: DragEvent) => any) | null;
    ondragover: ((this: Window, ev: DragEvent) => any) | null;
    ondragstart: ((this: Window, ev: DragEvent) => any) | null;
    ondrop: ((this: Window, ev: DragEvent) => any) | null;
    ondurationchange: ((this: Window, ev: Event) => any) | null;
    onemptied: ((this: Window, ev: Event) => any) | null;
    onended: ((this: Window, ev: Event) => any) | null;
    onerror: OnErrorEventHandler;
    onfocus: ((this: Window, ev: FocusEvent) => any) | null;
    onformdata: ((this: Window, ev: FormDataEvent) => any) | null;
    ongamepadconnected: ((this: Window, ev: GamepadEvent) => any) | null;
    ongamepaddisconnected: ((this: Window, ev: GamepadEvent) => any) | null;
    ongotpointercapture: ((this: Window, ev: PointerEvent) => any) | null;
    onhashchange: ((this: Window, ev: HashChangeEvent) => any) | null;
    oninput: ((this: Window, ev: InputEvent) => any) | null;
    oninvalid: ((this: Window, ev: Event) => any) | null;
    onkeydown: ((this: Window, ev: KeyboardEvent) => any) | null;
    onkeypress: ((this: Window, ev: KeyboardEvent) => any) | null;
    onkeyup: ((this: Window, ev: KeyboardEvent) => any) | null;
    onlanguagechange: ((this: Window, ev: Event) => any) | null;
    onload: ((this: Window, ev: Event) => any) | null;
    onloadeddata: ((this: Window, ev: Event) => any) | null;
    onloadedmetadata: ((this: Window, ev: Event) => any) | null;
    onloadstart: ((this: Window, ev: Event) => any) | null;
    onlostpointercapture: ((this: Window, ev: PointerEvent) => any) | null;
    onmessage: ((this: Window, ev: MessageEvent) => any) | null;
    onmessageerror: ((this: Window, ev: MessageEvent) => any) | null;
    onmousedown: ((this: Window, ev: MouseEvent) => any) | null;
    onmouseenter: ((this: Window, ev: MouseEvent) => any) | null;
    onmouseleave: ((this: Window, ev: MouseEvent) => any) | null;
    onmousemove: ((this: Window, ev: MouseEvent) => any) | null;
    onmouseout: ((this: Window, ev: MouseEvent) => any) | null;
    onmouseover: ((this: Window, ev: MouseEvent) => any) | null;
    onmouseup: ((this: Window, ev: MouseEvent) => any) | null;
    onoffline: ((this: Window, ev: Event) => any) | null;
    ononline: ((this: Window, ev: Event) => any) | null;
    onorientationchange: ((this: Window, ev: Event) => any) | null;
    onpagehide: ((this: Window, ev: PageTransitionEvent) => any) | null;
    onpagereveal: ((this: Window, ev: PageRevealEvent) => any) | null;
    onpageshow: ((this: Window, ev: PageTransitionEvent) => any) | null;
    onpageswap: ((this: Window, ev: PageSwapEvent) => any) | null;
    onpaste: ((this: Window, ev: ClipboardEvent) => any) | null;
    onpause: ((this: Window, ev: Event) => any) | null;
    onplay: ((this: Window, ev: Event) => any) | null;
    onplaying: ((this: Window, ev: Event) => any) | null;
    onpointercancel: ((this: Window, ev: PointerEvent) => any) | null;
    onpointerdown: ((this: Window, ev: PointerEvent) => any) | null;
    onpointerenter: ((this: Window, ev: PointerEvent) => any) | null;
    onpointerleave: ((this: Window, ev: PointerEvent) => any) | null;
    onpointermove: ((this: Window, ev: PointerEvent) => any) | null;
    onpointerout: ((this: Window, ev: PointerEvent) => any) | null;
    onpointerover: ((this: Window, ev: PointerEvent) => any) | null;
    onpointerrawupdate: ((this: Window, ev: Event) => any) | null;
    onpointerup: ((this: Window, ev: PointerEvent) => any) | null;
    onpopstate: ((this: Window, ev: PopStateEvent) => any) | null;
    onprogress: ((this: Window, ev: ProgressEvent) => any) | null;
    onratechange: ((this: Window, ev: Event) => any) | null;
    onrejectionhandled:
        | ((this: Window, ev: PromiseRejectionEvent) => any)
        | null;
    onreset: ((this: Window, ev: Event) => any) | null;
    onresize: ((this: Window, ev: UIEvent) => any) | null;
    onrtctransform:
        | ((this: DedicatedWorkerGlobalScope, ev: RTCTransformEvent) => any)
        | null;
    onscroll: ((this: Window, ev: Event) => any) | null;
    onscrollend: ((this: Window, ev: Event) => any) | null;
    onsecuritypolicyviolation:
        | ((this: Window, ev: SecurityPolicyViolationEvent) => any)
        | null;
    onseeked: ((this: Window, ev: Event) => any) | null;
    onseeking: ((this: Window, ev: Event) => any) | null;
    onselect: ((this: Window, ev: Event) => any) | null;
    onselectionchange: ((this: Window, ev: Event) => any) | null;
    onselectstart: ((this: Window, ev: Event) => any) | null;
    onslotchange: ((this: Window, ev: Event) => any) | null;
    onstalled: ((this: Window, ev: Event) => any) | null;
    onstorage: ((this: Window, ev: StorageEvent) => any) | null;
    onsubmit: ((this: Window, ev: SubmitEvent) => any) | null;
    onsuspend: ((this: Window, ev: Event) => any) | null;
    ontimeupdate: ((this: Window, ev: Event) => any) | null;
    ontoggle: ((this: Window, ev: ToggleEvent) => any) | null;
    ontouchcancel: ((this: Window, ev: TouchEvent) => any) | null | undefined;
    ontouchend: ((this: Window, ev: TouchEvent) => any) | null | undefined;
    ontouchmove: ((this: Window, ev: TouchEvent) => any) | null | undefined;
    ontouchstart: ((this: Window, ev: TouchEvent) => any) | null | undefined;
    ontransitioncancel: ((this: Window, ev: TransitionEvent) => any) | null;
    ontransitionend: ((this: Window, ev: TransitionEvent) => any) | null;
    ontransitionrun: ((this: Window, ev: TransitionEvent) => any) | null;
    ontransitionstart: ((this: Window, ev: TransitionEvent) => any) | null;
    onunhandledrejection:
        | ((this: Window, ev: PromiseRejectionEvent) => any)
        | null;
    onunload: ((this: Window, ev: Event) => any) | null;
    onvolumechange: ((this: Window, ev: Event) => any) | null;
    onwaiting: ((this: Window, ev: Event) => any) | null;
    onwebkitanimationend: ((this: Window, ev: Event) => any) | null;
    onwebkitanimationiteration: ((this: Window, ev: Event) => any) | null;
    onwebkitanimationstart: ((this: Window, ev: Event) => any) | null;
    onwebkittransitionend: ((this: Window, ev: Event) => any) | null;
    onwheel: ((this: Window, ev: WheelEvent) => any) | null;
    open: (
        url?: string | URL,
        target?: string,
        features?: string,
    ) => Window | null;
    opener: any;
    Option: new (
        text?: string,
        value?: string,
        defaultSelected?: boolean,
        selected?: boolean,
    ) => HTMLOptionElement;
    orientation: number;
    origin: string;
    originAgentCluster: boolean;
    OscillatorNode: {
        prototype: OscillatorNode;
        new (
            context: BaseAudioContext,
            options?: OscillatorOptions,
        ): OscillatorNode;
    };
    outerHeight: number;
    outerWidth: number;
    OverconstrainedError: {
        prototype: OverconstrainedError;
        new (constraint: string, message?: string): OverconstrainedError;
    };
    PageRevealEvent: {
        prototype: PageRevealEvent;
        new (type: string, eventInitDict?: PageRevealEventInit): PageRevealEvent;
    };
    PageSwapEvent: {
        prototype: PageSwapEvent;
        new (type: string, eventInitDict?: PageSwapEventInit): PageSwapEvent;
    };
    PageTransitionEvent: {
        prototype: PageTransitionEvent;
        new (
            type: string,
            eventInitDict?: PageTransitionEventInit,
        ): PageTransitionEvent;
    };
    pageXOffset: number;
    pageYOffset: number;
    PannerNode: {
        prototype: PannerNode;
        new (context: BaseAudioContext, options?: PannerOptions): PannerNode;
    };
    parent: Window;
    parseFloat: (string: string) => number;
    parseInt: (string: string, radix?: number) => number;
    Path2D: { prototype: Path2D; new (path?: string | Path2D): Path2D };
    PaymentAddress: { prototype: PaymentAddress; new (): PaymentAddress };
    PaymentMethodChangeEvent: {
        prototype: PaymentMethodChangeEvent;
        new (
            type: string,
            eventInitDict?: PaymentMethodChangeEventInit,
        ): PaymentMethodChangeEvent;
    };
    PaymentRequest: {
        prototype: PaymentRequest;
        new (
            methodData: PaymentMethodData[],
            details: PaymentDetailsInit,
            options?: PaymentOptions,
        ): PaymentRequest;
    };
    PaymentRequestUpdateEvent: {
        prototype: PaymentRequestUpdateEvent;
        new (
            type: string,
            eventInitDict?: PaymentRequestUpdateEventInit,
        ): PaymentRequestUpdateEvent;
    };
    PaymentResponse: { prototype: PaymentResponse; new (): PaymentResponse };
    pending: (reason?: string) => void;
    performance: Performance;
    Performance: { prototype: Performance; new (): Performance };
    PerformanceEntry: { prototype: PerformanceEntry; new (): PerformanceEntry };
    PerformanceEventTiming: {
        prototype: PerformanceEventTiming;
        new (): PerformanceEventTiming;
    };
    PerformanceMark: {
        prototype: PerformanceMark;
        new (
            markName: string,
            markOptions?: PerformanceMarkOptions,
        ): PerformanceMark;
    };
    PerformanceMeasure: {
        prototype: PerformanceMeasure;
        new (): PerformanceMeasure;
    };
    PerformanceNavigation: {
        prototype: PerformanceNavigation;
        TYPE_BACK_FORWARD: 2;
        TYPE_NAVIGATE: 0;
        TYPE_RELOAD: 1;
        TYPE_RESERVED: 255;
        new (): PerformanceNavigation;
    };
    PerformanceNavigationTiming: {
        prototype: PerformanceNavigationTiming;
        new (): PerformanceNavigationTiming;
    };
    PerformanceObserver: {
        prototype: PerformanceObserver;
        supportedEntryTypes: readonly string[];
        new (callback: PerformanceObserverCallback): PerformanceObserver;
    };
    PerformanceObserverEntryList: {
        prototype: PerformanceObserverEntryList;
        new (): PerformanceObserverEntryList;
    };
    PerformancePaintTiming: {
        prototype: PerformancePaintTiming;
        new (): PerformancePaintTiming;
    };
    PerformanceResourceTiming: {
        prototype: PerformanceResourceTiming;
        new (): PerformanceResourceTiming;
    };
    PerformanceServerTiming: {
        prototype: PerformanceServerTiming;
        new (): PerformanceServerTiming;
    };
    PerformanceTiming: {
        prototype: PerformanceTiming;
        new (): PerformanceTiming;
    };
    PeriodicWave: {
        prototype: PeriodicWave;
        new (
            context: BaseAudioContext,
            options?: PeriodicWaveOptions,
        ): PeriodicWave;
    };
    Permissions: { prototype: Permissions; new (): Permissions };
    PermissionStatus: { prototype: PermissionStatus; new (): PermissionStatus };
    personalbar: BarProp;
    PictureInPictureEvent: {
        prototype: PictureInPictureEvent;
        new (
            type: string,
            eventInitDict: PictureInPictureEventInit,
        ): PictureInPictureEvent;
    };
    PictureInPictureWindow: {
        prototype: PictureInPictureWindow;
        new (): PictureInPictureWindow;
    };
    Plugin: { prototype: Plugin; new (): Plugin };
    PluginArray: { prototype: PluginArray; new (): PluginArray };
    PointerEvent: {
        prototype: PointerEvent;
        new (type: string, eventInitDict?: PointerEventInit): PointerEvent;
    };
    PopStateEvent: {
        prototype: PopStateEvent;
        new (type: string, eventInitDict?: PopStateEventInit): PopStateEvent;
    };
    postMessage: {
        (message: any, targetOrigin: string, transfer?: Transferable[]): void;
        (message: any, options?: WindowPostMessageOptions): void;
        (message: any, transfer: Transferable[]): void;
        (message: any, options?: StructuredSerializeOptions): void;
    };
    print: () => void;
    ProcessingInstruction: {
        prototype: ProcessingInstruction;
        new (): ProcessingInstruction;
    };
    Profiler?: ProfilerConstructor;
    ProgressEvent: {
        prototype: ProgressEvent;
        new (type: string, eventInitDict?: ProgressEventInit): ProgressEvent;
    };
    Promise: PromiseConstructor;
    PromiseRejectionEvent: {
        prototype: PromiseRejectionEvent;
        new (
            type: string,
            eventInitDict: PromiseRejectionEventInit,
        ): PromiseRejectionEvent;
    };
    prompt: (message?: string, _default?: string) => string | null;
    Proxy: ProxyConstructor;
    PublicKeyCredential: {
        prototype: PublicKeyCredential;
        getClientCapabilities(): Promise<PublicKeyCredentialClientCapabilities>;
        isConditionalMediationAvailable(): Promise<boolean>;
        isUserVerifyingPlatformAuthenticatorAvailable(): Promise<boolean>;
        parseCreationOptionsFromJSON(
            options: PublicKeyCredentialCreationOptionsJSON,
        ): PublicKeyCredentialCreationOptions;
        parseRequestOptionsFromJSON(
            options: PublicKeyCredentialRequestOptionsJSON,
        ): PublicKeyCredentialRequestOptions;
        signalAllAcceptedCredentials(
            options: AllAcceptedCredentialsOptions,
        ): Promise<void>;
        signalCurrentUserDetails(
            options: CurrentUserDetailsOptions,
        ): Promise<void>;
        signalUnknownCredential(options: UnknownCredentialOptions): Promise<void>;
        new (): PublicKeyCredential;
    };
    PushEvent: {
        prototype: PushEvent;
        new (type: string, eventInitDict?: PushEventInit): PushEvent;
    };
    PushManager: {
        prototype: PushManager;
        supportedContentEncodings: readonly string[];
        new (): PushManager;
    };
    PushMessageData: { prototype: PushMessageData; new (): PushMessageData };
    PushSubscription: { prototype: PushSubscription; new (): PushSubscription };
    PushSubscriptionChangeEvent: {
        prototype: PushSubscriptionChangeEvent;
        new (
            type: string,
            eventInitDict?: PushSubscriptionChangeEventInit,
        ): PushSubscriptionChangeEvent;
    };
    PushSubscriptionOptions: {
        prototype: PushSubscriptionOptions;
        new (): PushSubscriptionOptions;
    };
    queueMicrotask?: {
        (callback: VoidFunction): void;
        (callback: VoidFunction): void;
    };
    RadioNodeList: { prototype: RadioNodeList; new (): RadioNodeList };
    Range: {
        END_TO_END: 2;
        END_TO_START: 3;
        prototype: Range;
        START_TO_END: 1;
        START_TO_START: 0;
        new (): Range;
    };
    RangeError: RangeErrorConstructor;
    React: typeof React;
    ReadableByteStreamController: {
        prototype: ReadableByteStreamController;
        new (): ReadableByteStreamController;
    };
    ReadableStream: {
        prototype: ReadableStream;
        new (
            underlyingSource: UnderlyingByteSource,
            strategy?: { highWaterMark?: number },
        ): ReadableStream<Uint8Array<ArrayBuffer>>;
        new <R = any>(
            underlyingSource: UnderlyingDefaultSource<R>,
            strategy?: QueuingStrategy<R>,
        ): ReadableStream<R>;
        new <R = any>(
            underlyingSource?: UnderlyingSource<R>,
            strategy?: QueuingStrategy<R>,
        ): ReadableStream<R>;
    };
    ReadableStreamBYOBReader: {
        prototype: ReadableStreamBYOBReader;
        new (
            stream: ReadableStream<Uint8Array<ArrayBuffer>>,
        ): ReadableStreamBYOBReader;
    };
    ReadableStreamBYOBRequest: {
        prototype: ReadableStreamBYOBRequest;
        new (): ReadableStreamBYOBRequest;
    };
    ReadableStreamDefaultController: {
        prototype: ReadableStreamDefaultController;
        new (): ReadableStreamDefaultController;
    };
    ReadableStreamDefaultReader: {
        prototype: ReadableStreamDefaultReader;
        new <R = any>(stream: ReadableStream<R>): ReadableStreamDefaultReader<R>;
    };
    ReferenceError: ReferenceErrorConstructor;
    Reflect: typeof Reflect;
    RegExp: RegExpConstructor;
    releaseEvents: () => void;
    RemotePlayback: { prototype: RemotePlayback; new (): RemotePlayback };
    removeEventListener: {
        <K extends keyof WindowEventMap>(
            type: K,
            listener: (this: Window, ev: WindowEventMap[K]) => any,
            options?: boolean | EventListenerOptions,
        ): void;
        (
            type: string,
            listener: EventListenerOrEventListenerObject,
            options?: boolean | EventListenerOptions,
        ): void;
        <K extends keyof DedicatedWorkerGlobalScopeEventMap>(
            type: K,
            listener: (
                this: DedicatedWorkerGlobalScope,
                ev: DedicatedWorkerGlobalScopeEventMap[K],
            ) => any,
            options?: boolean | EventListenerOptions,
        ): void;
        (
            type: string,
            listener: EventListenerOrEventListenerObject,
            options?: boolean | EventListenerOptions,
        ): void;
    };
    reportError: { (e: any): void; (e: any): void };
    ReportingObserver: {
        prototype: ReportingObserver;
        new (
            callback: ReportingObserverCallback,
            options?: ReportingObserverOptions,
        ): ReportingObserver;
    };
    Request: {
        prototype: Request;
        new (input: URL | RequestInfo, init?: RequestInit): Request;
    };
    requestAnimationFrame: {
        (callback: FrameRequestCallback): number;
        (callback: FrameRequestCallback): number;
    };
    requestIdleCallback: (
        callback: IdleRequestCallback,
        options?: IdleRequestOptions,
    ) => number;
    resizeBy: (x: number, y: number) => void;
    ResizeObserver: {
        prototype: ResizeObserver;
        new (callback: ResizeObserverCallback): ResizeObserver;
    };
    ResizeObserverEntry: {
        prototype: ResizeObserverEntry;
        new (): ResizeObserverEntry;
    };
    ResizeObserverSize: {
        prototype: ResizeObserverSize;
        new (): ResizeObserverSize;
    };
    resizeTo: (width: number, height: number) => void;
    Response: {
        prototype: Response;
        error(): Response;
        json(data: any, init?: ResponseInit): Response;
        redirect(url: string | URL, status?: number): Response;
        new (body?: BodyInit | null, init?: ResponseInit): Response;
    };
    RTCCertificate: { prototype: RTCCertificate; new (): RTCCertificate };
    RTCDataChannel: { prototype: RTCDataChannel; new (): RTCDataChannel };
    RTCDataChannelEvent: {
        prototype: RTCDataChannelEvent;
        new (
            type: string,
            eventInitDict: RTCDataChannelEventInit,
        ): RTCDataChannelEvent;
    };
    RTCDtlsTransport: { prototype: RTCDtlsTransport; new (): RTCDtlsTransport };
    RTCDTMFSender: { prototype: RTCDTMFSender; new (): RTCDTMFSender };
    RTCDTMFToneChangeEvent: {
        prototype: RTCDTMFToneChangeEvent;
        new (
            type: string,
            eventInitDict?: RTCDTMFToneChangeEventInit,
        ): RTCDTMFToneChangeEvent;
    };
    RTCEncodedAudioFrame: {
        prototype: RTCEncodedAudioFrame;
        new (): RTCEncodedAudioFrame;
    };
    RTCEncodedVideoFrame: {
        prototype: RTCEncodedVideoFrame;
        new (): RTCEncodedVideoFrame;
    };
    RTCError: {
        prototype: RTCError;
        new (init: RTCErrorInit, message?: string): RTCError;
    };
    RTCErrorEvent: {
        prototype: RTCErrorEvent;
        new (type: string, eventInitDict: RTCErrorEventInit): RTCErrorEvent;
    };
    RTCIceCandidate: {
        prototype: RTCIceCandidate;
        new (candidateInitDict?: RTCLocalIceCandidateInit): RTCIceCandidate;
    };
    RTCIceTransport: { prototype: RTCIceTransport; new (): RTCIceTransport };
    RTCPeerConnection: {
        prototype: RTCPeerConnection;
        generateCertificate(
            keygenAlgorithm: AlgorithmIdentifier,
        ): Promise<RTCCertificate>;
        new (configuration?: RTCConfiguration): RTCPeerConnection;
    };
    RTCPeerConnectionIceErrorEvent: {
        prototype: RTCPeerConnectionIceErrorEvent;
        new (
            type: string,
            eventInitDict: RTCPeerConnectionIceErrorEventInit,
        ): RTCPeerConnectionIceErrorEvent;
    };
    RTCPeerConnectionIceEvent: {
        prototype: RTCPeerConnectionIceEvent;
        new (
            type: string,
            eventInitDict?: RTCPeerConnectionIceEventInit,
        ): RTCPeerConnectionIceEvent;
    };
    RTCRtpReceiver: {
        prototype: RTCRtpReceiver;
        getCapabilities(kind: string): RTCRtpCapabilities | null;
        new (): RTCRtpReceiver;
    };
    RTCRtpScriptTransform: {
        prototype: RTCRtpScriptTransform;
        new (
            worker: Worker,
            options?: any,
            transfer?: any[],
        ): RTCRtpScriptTransform;
    };
    RTCRtpScriptTransformer: {
        prototype: RTCRtpScriptTransformer;
        new (): RTCRtpScriptTransformer;
    };
    RTCRtpSender: {
        prototype: RTCRtpSender;
        getCapabilities(kind: string): RTCRtpCapabilities | null;
        new (): RTCRtpSender;
    };
    RTCRtpTransceiver: {
        prototype: RTCRtpTransceiver;
        new (): RTCRtpTransceiver;
    };
    RTCSctpTransport: { prototype: RTCSctpTransport; new (): RTCSctpTransport };
    RTCSessionDescription: {
        prototype: RTCSessionDescription;
        new (
            descriptionInitDict: RTCSessionDescriptionInit,
        ): RTCSessionDescription;
    };
    RTCStatsReport: { prototype: RTCStatsReport; new (): RTCStatsReport };
    RTCTrackEvent: {
        prototype: RTCTrackEvent;
        new (type: string, eventInitDict: RTCTrackEventInit): RTCTrackEvent;
    };
    RTCTransformEvent: {
        prototype: RTCTransformEvent;
        new (): RTCTransformEvent;
    };
    Sanitizer: {
        prototype: Sanitizer;
        new (configuration?: "default" | SanitizerConfig): Sanitizer;
    };
    scheduler: Scheduler;
    Scheduler: { prototype: Scheduler; new (): Scheduler };
    screen: Screen;
    Screen: { prototype: Screen; new (): Screen };
    screenLeft: number;
    ScreenOrientation: {
        prototype: ScreenOrientation;
        new (): ScreenOrientation;
    };
    screenTop: number;
    screenX: number;
    screenY: number;
    ScriptProcessorNode: {
        prototype: ScriptProcessorNode;
        new (): ScriptProcessorNode;
    };
    scroll: { (options?: ScrollToOptions): void; (x: number, y: number): void };
    scrollbars: BarProp;
    scrollBy: {
        (options?: ScrollToOptions): void;
        (x: number, y: number): void;
    };
    ScrollTimeline: {
        prototype: ScrollTimeline;
        new (options?: ScrollTimelineOptions): ScrollTimeline;
    };
    scrollTo: {
        (options?: ScrollToOptions): void;
        (x: number, y: number): void;
    };
    scrollX: number;
    scrollY: number;
    SecurityPolicyViolationEvent: {
        prototype: SecurityPolicyViolationEvent;
        new (
            type: string,
            eventInitDict?: SecurityPolicyViolationEventInit,
        ): SecurityPolicyViolationEvent;
    };
    Selection: { prototype: Selection; new (): Selection };
    self: Window & typeof globalThis;
    ServiceWorker: { prototype: ServiceWorker; new (): ServiceWorker };
    ServiceWorkerContainer: {
        prototype: ServiceWorkerContainer;
        new (): ServiceWorkerContainer;
    };
    ServiceWorkerGlobalScope: {
        prototype: ServiceWorkerGlobalScope;
        new (): ServiceWorkerGlobalScope;
    };
    ServiceWorkerRegistration: {
        prototype: ServiceWorkerRegistration;
        new (): ServiceWorkerRegistration;
    };
    sessionStorage: Storage;
    Set: SetConstructor;
    setInterval: {
        (handler: TimerHandler, timeout?: number, ...arguments: any[]): number;
        (handler: TimerHandler, timeout?: number, ...arguments: any[]): number;
    };
    setSpecProperty: (key: string, value: unknown) => void;
    setSuiteProperty: (key: string, value: unknown) => void;
    setTimeout: {
        (handler: TimerHandler, timeout?: number, ...arguments: any[]): number;
        (handler: TimerHandler, timeout?: number, ...arguments: any[]): number;
    };
    ShadowRoot: { prototype: ShadowRoot; new (): ShadowRoot };
    SharedArrayBuffer: SharedArrayBufferConstructor;
    SharedWorker: {
        prototype: SharedWorker;
        new (
            scriptURL: string | URL,
            options?: string | WorkerOptions,
        ): SharedWorker;
    };
    SharedWorkerGlobalScope: {
        prototype: SharedWorkerGlobalScope;
        new (): SharedWorkerGlobalScope;
    };
    SourceBuffer: { prototype: SourceBuffer; new (): SourceBuffer };
    SourceBufferList: { prototype: SourceBufferList; new (): SourceBufferList };
    SpeechRecognitionAlternative: {
        prototype: SpeechRecognitionAlternative;
        new (): SpeechRecognitionAlternative;
    };
    SpeechRecognitionErrorEvent: {
        prototype: SpeechRecognitionErrorEvent;
        new (
            type: string,
            eventInitDict: SpeechRecognitionErrorEventInit,
        ): SpeechRecognitionErrorEvent;
    };
    SpeechRecognitionEvent: {
        prototype: SpeechRecognitionEvent;
        new (
            type: string,
            eventInitDict: SpeechRecognitionEventInit,
        ): SpeechRecognitionEvent;
    };
    SpeechRecognitionResult: {
        prototype: SpeechRecognitionResult;
        new (): SpeechRecognitionResult;
    };
    SpeechRecognitionResultList: {
        prototype: SpeechRecognitionResultList;
        new (): SpeechRecognitionResultList;
    };
    speechSynthesis: SpeechSynthesis;
    SpeechSynthesis: { prototype: SpeechSynthesis; new (): SpeechSynthesis };
    SpeechSynthesisErrorEvent: {
        prototype: SpeechSynthesisErrorEvent;
        new (
            type: string,
            eventInitDict: SpeechSynthesisErrorEventInit,
        ): SpeechSynthesisErrorEvent;
    };
    SpeechSynthesisEvent: {
        prototype: SpeechSynthesisEvent;
        new (
            type: string,
            eventInitDict: SpeechSynthesisEventInit,
        ): SpeechSynthesisEvent;
    };
    SpeechSynthesisUtterance: {
        prototype: SpeechSynthesisUtterance;
        new (text?: string): SpeechSynthesisUtterance;
    };
    SpeechSynthesisVoice: {
        prototype: SpeechSynthesisVoice;
        new (): SpeechSynthesisVoice;
    };
    spyOn: <T, K extends string | number | symbol = keyof T>(
        object: T,
        method: T[K] extends Function ? K : never,
    ) => Spy<
        T[K] extends Func
            ? any[any]
            : T[K] extends new (...args: A) => V ? (...args: A) => V : never,
    >;
    spyOnAllFunctions: <T>(
        object: T,
        includeNonEnumerable?: boolean,
    ) => SpyObj<T>;
    spyOnProperty: {
        <T, K extends string | number | symbol = keyof T>(
            object: T,
            property: K,
            accessType?: "get",
        ): Spy<(this: T) => T[K]>;
        <T, K extends string | number | symbol = keyof T>(
            object: T,
            property: K,
            accessType: "set",
        ): Spy<(this: T, value: T[K]) => void>;
    };
    StaticRange: {
        prototype: StaticRange;
        new (init: StaticRangeInit): StaticRange;
    };
    status: string;
    statusbar: BarProp;
    StereoPannerNode: {
        prototype: StereoPannerNode;
        new (
            context: BaseAudioContext,
            options?: StereoPannerOptions,
        ): StereoPannerNode;
    };
    stop: () => void;
    Storage: { prototype: Storage; new (): Storage };
    StorageEvent: {
        prototype: StorageEvent;
        new (type: string, eventInitDict?: StorageEventInit): StorageEvent;
    };
    StorageManager: { prototype: StorageManager; new (): StorageManager };
    String: StringConstructor;
    structuredClone: {
        <T = any>(value: T, options?: StructuredSerializeOptions): T;
        <T = any>(value: T, options?: StructuredSerializeOptions): T;
    };
    StylePropertyMap: { prototype: StylePropertyMap; new (): StylePropertyMap };
    StylePropertyMapReadOnly: {
        prototype: StylePropertyMapReadOnly;
        new (): StylePropertyMapReadOnly;
    };
    StyleSheet: { prototype: StyleSheet; new (): StyleSheet };
    StyleSheetList: { prototype: StyleSheetList; new (): StyleSheetList };
    SubmitEvent: {
        prototype: SubmitEvent;
        new (type: string, eventInitDict?: SubmitEventInit): SubmitEvent;
    };
    SubtleCrypto: { prototype: SubtleCrypto; new (): SubtleCrypto };
    SVGAElement: { prototype: SVGAElement; new (): SVGAElement };
    SVGAngle: {
        prototype: SVGAngle;
        SVG_ANGLETYPE_DEG: 2;
        SVG_ANGLETYPE_GRAD: 4;
        SVG_ANGLETYPE_RAD: 3;
        SVG_ANGLETYPE_UNKNOWN: 0;
        SVG_ANGLETYPE_UNSPECIFIED: 1;
        new (): SVGAngle;
    };
    SVGAnimatedAngle: { prototype: SVGAnimatedAngle; new (): SVGAnimatedAngle };
    SVGAnimatedBoolean: {
        prototype: SVGAnimatedBoolean;
        new (): SVGAnimatedBoolean;
    };
    SVGAnimatedEnumeration: {
        prototype: SVGAnimatedEnumeration;
        new (): SVGAnimatedEnumeration;
    };
    SVGAnimatedInteger: {
        prototype: SVGAnimatedInteger;
        new (): SVGAnimatedInteger;
    };
    SVGAnimatedLength: {
        prototype: SVGAnimatedLength;
        new (): SVGAnimatedLength;
    };
    SVGAnimatedLengthList: {
        prototype: SVGAnimatedLengthList;
        new (): SVGAnimatedLengthList;
    };
    SVGAnimatedNumber: {
        prototype: SVGAnimatedNumber;
        new (): SVGAnimatedNumber;
    };
    SVGAnimatedNumberList: {
        prototype: SVGAnimatedNumberList;
        new (): SVGAnimatedNumberList;
    };
    SVGAnimatedPreserveAspectRatio: {
        prototype: SVGAnimatedPreserveAspectRatio;
        new (): SVGAnimatedPreserveAspectRatio;
    };
    SVGAnimatedRect: { prototype: SVGAnimatedRect; new (): SVGAnimatedRect };
    SVGAnimatedString: {
        prototype: SVGAnimatedString;
        new (): SVGAnimatedString;
    };
    SVGAnimatedTransformList: {
        prototype: SVGAnimatedTransformList;
        new (): SVGAnimatedTransformList;
    };
    SVGAnimateElement: {
        prototype: SVGAnimateElement;
        new (): SVGAnimateElement;
    };
    SVGAnimateMotionElement: {
        prototype: SVGAnimateMotionElement;
        new (): SVGAnimateMotionElement;
    };
    SVGAnimateTransformElement: {
        prototype: SVGAnimateTransformElement;
        new (): SVGAnimateTransformElement;
    };
    SVGAnimationElement: {
        prototype: SVGAnimationElement;
        new (): SVGAnimationElement;
    };
    SVGCircleElement: { prototype: SVGCircleElement; new (): SVGCircleElement };
    SVGClipPathElement: {
        prototype: SVGClipPathElement;
        new (): SVGClipPathElement;
    };
    SVGComponentTransferFunctionElement: {
        prototype: SVGComponentTransferFunctionElement;
        SVG_FECOMPONENTTRANSFER_TYPE_DISCRETE: 3;
        SVG_FECOMPONENTTRANSFER_TYPE_GAMMA: 5;
        SVG_FECOMPONENTTRANSFER_TYPE_IDENTITY: 1;
        SVG_FECOMPONENTTRANSFER_TYPE_LINEAR: 4;
        SVG_FECOMPONENTTRANSFER_TYPE_TABLE: 2;
        SVG_FECOMPONENTTRANSFER_TYPE_UNKNOWN: 0;
        new (): SVGComponentTransferFunctionElement;
    };
    SVGDefsElement: { prototype: SVGDefsElement; new (): SVGDefsElement };
    SVGDescElement: { prototype: SVGDescElement; new (): SVGDescElement };
    SVGElement: { prototype: SVGElement; new (): SVGElement };
    SVGEllipseElement: {
        prototype: SVGEllipseElement;
        new (): SVGEllipseElement;
    };
    SVGFEBlendElement: {
        prototype: SVGFEBlendElement;
        SVG_FEBLEND_MODE_COLOR: 15;
        SVG_FEBLEND_MODE_COLOR_BURN: 8;
        SVG_FEBLEND_MODE_COLOR_DODGE: 7;
        SVG_FEBLEND_MODE_DARKEN: 4;
        SVG_FEBLEND_MODE_DIFFERENCE: 11;
        SVG_FEBLEND_MODE_EXCLUSION: 12;
        SVG_FEBLEND_MODE_HARD_LIGHT: 9;
        SVG_FEBLEND_MODE_HUE: 13;
        SVG_FEBLEND_MODE_LIGHTEN: 5;
        SVG_FEBLEND_MODE_LUMINOSITY: 16;
        SVG_FEBLEND_MODE_MULTIPLY: 2;
        SVG_FEBLEND_MODE_NORMAL: 1;
        SVG_FEBLEND_MODE_OVERLAY: 6;
        SVG_FEBLEND_MODE_SATURATION: 14;
        SVG_FEBLEND_MODE_SCREEN: 3;
        SVG_FEBLEND_MODE_SOFT_LIGHT: 10;
        SVG_FEBLEND_MODE_UNKNOWN: 0;
        new (): SVGFEBlendElement;
    };
    SVGFEColorMatrixElement: {
        prototype: SVGFEColorMatrixElement;
        SVG_FECOLORMATRIX_TYPE_HUEROTATE: 3;
        SVG_FECOLORMATRIX_TYPE_LUMINANCETOALPHA: 4;
        SVG_FECOLORMATRIX_TYPE_MATRIX: 1;
        SVG_FECOLORMATRIX_TYPE_SATURATE: 2;
        SVG_FECOLORMATRIX_TYPE_UNKNOWN: 0;
        new (): SVGFEColorMatrixElement;
    };
    SVGFEComponentTransferElement: {
        prototype: SVGFEComponentTransferElement;
        new (): SVGFEComponentTransferElement;
    };
    SVGFECompositeElement: {
        prototype: SVGFECompositeElement;
        SVG_FECOMPOSITE_OPERATOR_ARITHMETIC: 6;
        SVG_FECOMPOSITE_OPERATOR_ATOP: 4;
        SVG_FECOMPOSITE_OPERATOR_IN: 2;
        SVG_FECOMPOSITE_OPERATOR_OUT: 3;
        SVG_FECOMPOSITE_OPERATOR_OVER: 1;
        SVG_FECOMPOSITE_OPERATOR_UNKNOWN: 0;
        SVG_FECOMPOSITE_OPERATOR_XOR: 5;
        new (): SVGFECompositeElement;
    };
    SVGFEConvolveMatrixElement: {
        prototype: SVGFEConvolveMatrixElement;
        SVG_EDGEMODE_DUPLICATE: 1;
        SVG_EDGEMODE_NONE: 3;
        SVG_EDGEMODE_UNKNOWN: 0;
        SVG_EDGEMODE_WRAP: 2;
        new (): SVGFEConvolveMatrixElement;
    };
    SVGFEDiffuseLightingElement: {
        prototype: SVGFEDiffuseLightingElement;
        new (): SVGFEDiffuseLightingElement;
    };
    SVGFEDisplacementMapElement: {
        prototype: SVGFEDisplacementMapElement;
        SVG_CHANNEL_A: 4;
        SVG_CHANNEL_B: 3;
        SVG_CHANNEL_G: 2;
        SVG_CHANNEL_R: 1;
        SVG_CHANNEL_UNKNOWN: 0;
        new (): SVGFEDisplacementMapElement;
    };
    SVGFEDistantLightElement: {
        prototype: SVGFEDistantLightElement;
        new (): SVGFEDistantLightElement;
    };
    SVGFEDropShadowElement: {
        prototype: SVGFEDropShadowElement;
        new (): SVGFEDropShadowElement;
    };
    SVGFEFloodElement: {
        prototype: SVGFEFloodElement;
        new (): SVGFEFloodElement;
    };
    SVGFEFuncAElement: {
        prototype: SVGFEFuncAElement;
        new (): SVGFEFuncAElement;
    };
    SVGFEFuncBElement: {
        prototype: SVGFEFuncBElement;
        new (): SVGFEFuncBElement;
    };
    SVGFEFuncGElement: {
        prototype: SVGFEFuncGElement;
        new (): SVGFEFuncGElement;
    };
    SVGFEFuncRElement: {
        prototype: SVGFEFuncRElement;
        new (): SVGFEFuncRElement;
    };
    SVGFEGaussianBlurElement: {
        prototype: SVGFEGaussianBlurElement;
        new (): SVGFEGaussianBlurElement;
    };
    SVGFEImageElement: {
        prototype: SVGFEImageElement;
        new (): SVGFEImageElement;
    };
    SVGFEMergeElement: {
        prototype: SVGFEMergeElement;
        new (): SVGFEMergeElement;
    };
    SVGFEMergeNodeElement: {
        prototype: SVGFEMergeNodeElement;
        new (): SVGFEMergeNodeElement;
    };
    SVGFEMorphologyElement: {
        prototype: SVGFEMorphologyElement;
        SVG_MORPHOLOGY_OPERATOR_DILATE: 2;
        SVG_MORPHOLOGY_OPERATOR_ERODE: 1;
        SVG_MORPHOLOGY_OPERATOR_UNKNOWN: 0;
        new (): SVGFEMorphologyElement;
    };
    SVGFEOffsetElement: {
        prototype: SVGFEOffsetElement;
        new (): SVGFEOffsetElement;
    };
    SVGFEPointLightElement: {
        prototype: SVGFEPointLightElement;
        new (): SVGFEPointLightElement;
    };
    SVGFESpecularLightingElement: {
        prototype: SVGFESpecularLightingElement;
        new (): SVGFESpecularLightingElement;
    };
    SVGFESpotLightElement: {
        prototype: SVGFESpotLightElement;
        new (): SVGFESpotLightElement;
    };
    SVGFETileElement: { prototype: SVGFETileElement; new (): SVGFETileElement };
    SVGFETurbulenceElement: {
        prototype: SVGFETurbulenceElement;
        SVG_STITCHTYPE_NOSTITCH: 2;
        SVG_STITCHTYPE_STITCH: 1;
        SVG_STITCHTYPE_UNKNOWN: 0;
        SVG_TURBULENCE_TYPE_FRACTALNOISE: 1;
        SVG_TURBULENCE_TYPE_TURBULENCE: 2;
        SVG_TURBULENCE_TYPE_UNKNOWN: 0;
        new (): SVGFETurbulenceElement;
    };
    SVGFilterElement: { prototype: SVGFilterElement; new (): SVGFilterElement };
    SVGForeignObjectElement: {
        prototype: SVGForeignObjectElement;
        new (): SVGForeignObjectElement;
    };
    SVGGElement: { prototype: SVGGElement; new (): SVGGElement };
    SVGGeometryElement: {
        prototype: SVGGeometryElement;
        new (): SVGGeometryElement;
    };
    SVGGradientElement: {
        prototype: SVGGradientElement;
        SVG_SPREADMETHOD_PAD: 1;
        SVG_SPREADMETHOD_REFLECT: 2;
        SVG_SPREADMETHOD_REPEAT: 3;
        SVG_SPREADMETHOD_UNKNOWN: 0;
        new (): SVGGradientElement;
    };
    SVGGraphicsElement: {
        prototype: SVGGraphicsElement;
        new (): SVGGraphicsElement;
    };
    SVGImageElement: { prototype: SVGImageElement; new (): SVGImageElement };
    SVGLength: {
        prototype: SVGLength;
        SVG_LENGTHTYPE_CM: 6;
        SVG_LENGTHTYPE_EMS: 3;
        SVG_LENGTHTYPE_EXS: 4;
        SVG_LENGTHTYPE_IN: 8;
        SVG_LENGTHTYPE_MM: 7;
        SVG_LENGTHTYPE_NUMBER: 1;
        SVG_LENGTHTYPE_PC: 10;
        SVG_LENGTHTYPE_PERCENTAGE: 2;
        SVG_LENGTHTYPE_PT: 9;
        SVG_LENGTHTYPE_PX: 5;
        SVG_LENGTHTYPE_UNKNOWN: 0;
        new (): SVGLength;
    };
    SVGLengthList: { prototype: SVGLengthList; new (): SVGLengthList };
    SVGLinearGradientElement: {
        prototype: SVGLinearGradientElement;
        new (): SVGLinearGradientElement;
    };
    SVGLineElement: { prototype: SVGLineElement; new (): SVGLineElement };
    SVGMarkerElement: {
        prototype: SVGMarkerElement;
        SVG_MARKER_ORIENT_ANGLE: 2;
        SVG_MARKER_ORIENT_AUTO: 1;
        SVG_MARKER_ORIENT_AUTO_START_REVERSE: 3;
        SVG_MARKER_ORIENT_UNKNOWN: 0;
        SVG_MARKERUNITS_STROKEWIDTH: 2;
        SVG_MARKERUNITS_UNKNOWN: 0;
        SVG_MARKERUNITS_USERSPACEONUSE: 1;
        new (): SVGMarkerElement;
    };
    SVGMaskElement: { prototype: SVGMaskElement; new (): SVGMaskElement };
    SVGMatrix: {
        prototype: DOMMatrix;
        fromFloat32Array(array32: Float32Array<ArrayBuffer>): DOMMatrix;
        fromFloat64Array(array64: Float64Array<ArrayBuffer>): DOMMatrix;
        fromMatrix(other?: DOMMatrixInit): DOMMatrix;
        new (init?: string | number[]): DOMMatrix;
    };
    SVGMetadataElement: {
        prototype: SVGMetadataElement;
        new (): SVGMetadataElement;
    };
    SVGMPathElement: { prototype: SVGMPathElement; new (): SVGMPathElement };
    SVGNumber: { prototype: SVGNumber; new (): SVGNumber };
    SVGNumberList: { prototype: SVGNumberList; new (): SVGNumberList };
    SVGPathElement: { prototype: SVGPathElement; new (): SVGPathElement };
    SVGPatternElement: {
        prototype: SVGPatternElement;
        new (): SVGPatternElement;
    };
    SVGPoint: {
        prototype: DOMPoint;
        fromPoint(other?: DOMPointInit): DOMPoint;
        new (x?: number, y?: number, z?: number, w?: number): DOMPoint;
    };
    SVGPointList: { prototype: SVGPointList; new (): SVGPointList };
    SVGPolygonElement: {
        prototype: SVGPolygonElement;
        new (): SVGPolygonElement;
    };
    SVGPolylineElement: {
        prototype: SVGPolylineElement;
        new (): SVGPolylineElement;
    };
    SVGPreserveAspectRatio: {
        prototype: SVGPreserveAspectRatio;
        SVG_MEETORSLICE_MEET: 1;
        SVG_MEETORSLICE_SLICE: 2;
        SVG_MEETORSLICE_UNKNOWN: 0;
        SVG_PRESERVEASPECTRATIO_NONE: 1;
        SVG_PRESERVEASPECTRATIO_UNKNOWN: 0;
        SVG_PRESERVEASPECTRATIO_XMAXYMAX: 10;
        SVG_PRESERVEASPECTRATIO_XMAXYMID: 7;
        SVG_PRESERVEASPECTRATIO_XMAXYMIN: 4;
        SVG_PRESERVEASPECTRATIO_XMIDYMAX: 9;
        SVG_PRESERVEASPECTRATIO_XMIDYMID: 6;
        SVG_PRESERVEASPECTRATIO_XMIDYMIN: 3;
        SVG_PRESERVEASPECTRATIO_XMINYMAX: 8;
        SVG_PRESERVEASPECTRATIO_XMINYMID: 5;
        SVG_PRESERVEASPECTRATIO_XMINYMIN: 2;
        new (): SVGPreserveAspectRatio;
    };
    SVGRadialGradientElement: {
        prototype: SVGRadialGradientElement;
        new (): SVGRadialGradientElement;
    };
    SVGRect: {
        prototype: DOMRect;
        fromRect(other?: DOMRectInit): DOMRect;
        new (x?: number, y?: number, width?: number, height?: number): DOMRect;
    };
    SVGRectElement: { prototype: SVGRectElement; new (): SVGRectElement };
    SVGScriptElement: { prototype: SVGScriptElement; new (): SVGScriptElement };
    SVGSetElement: { prototype: SVGSetElement; new (): SVGSetElement };
    SVGStopElement: { prototype: SVGStopElement; new (): SVGStopElement };
    SVGStringList: { prototype: SVGStringList; new (): SVGStringList };
    SVGStyleElement: { prototype: SVGStyleElement; new (): SVGStyleElement };
    SVGSVGElement: { prototype: SVGSVGElement; new (): SVGSVGElement };
    SVGSwitchElement: { prototype: SVGSwitchElement; new (): SVGSwitchElement };
    SVGSymbolElement: { prototype: SVGSymbolElement; new (): SVGSymbolElement };
    SVGTextContentElement: {
        LENGTHADJUST_SPACING: 1;
        LENGTHADJUST_SPACINGANDGLYPHS: 2;
        LENGTHADJUST_UNKNOWN: 0;
        prototype: SVGTextContentElement;
        new (): SVGTextContentElement;
    };
    SVGTextElement: { prototype: SVGTextElement; new (): SVGTextElement };
    SVGTextPathElement: {
        prototype: SVGTextPathElement;
        TEXTPATH_METHODTYPE_ALIGN: 1;
        TEXTPATH_METHODTYPE_STRETCH: 2;
        TEXTPATH_METHODTYPE_UNKNOWN: 0;
        TEXTPATH_SPACINGTYPE_AUTO: 1;
        TEXTPATH_SPACINGTYPE_EXACT: 2;
        TEXTPATH_SPACINGTYPE_UNKNOWN: 0;
        new (): SVGTextPathElement;
    };
    SVGTextPositioningElement: {
        prototype: SVGTextPositioningElement;
        new (): SVGTextPositioningElement;
    };
    SVGTitleElement: { prototype: SVGTitleElement; new (): SVGTitleElement };
    SVGTransform: {
        prototype: SVGTransform;
        SVG_TRANSFORM_MATRIX: 1;
        SVG_TRANSFORM_ROTATE: 4;
        SVG_TRANSFORM_SCALE: 3;
        SVG_TRANSFORM_SKEWX: 5;
        SVG_TRANSFORM_SKEWY: 6;
        SVG_TRANSFORM_TRANSLATE: 2;
        SVG_TRANSFORM_UNKNOWN: 0;
        new (): SVGTransform;
    };
    SVGTransformList: { prototype: SVGTransformList; new (): SVGTransformList };
    SVGTSpanElement: { prototype: SVGTSpanElement; new (): SVGTSpanElement };
    SVGUnitTypes: {
        prototype: SVGUnitTypes;
        SVG_UNIT_TYPE_OBJECTBOUNDINGBOX: 2;
        SVG_UNIT_TYPE_UNKNOWN: 0;
        SVG_UNIT_TYPE_USERSPACEONUSE: 1;
        new (): SVGUnitTypes;
    };
    SVGUseElement: { prototype: SVGUseElement; new (): SVGUseElement };
    SVGViewElement: { prototype: SVGViewElement; new (): SVGViewElement };
    Symbol: SymbolConstructor;
    SyntaxError: SyntaxErrorConstructor;
    TaskController: {
        prototype: TaskController;
        new (init?: TaskControllerInit): TaskController;
    };
    TaskPriorityChangeEvent: {
        prototype: TaskPriorityChangeEvent;
        new (
            type: string,
            priorityChangeEventInitDict: TaskPriorityChangeEventInit,
        ): TaskPriorityChangeEvent;
    };
    TaskSignal: {
        prototype: TaskSignal;
        any(signals: AbortSignal[], init?: TaskSignalAnyInit): TaskSignal;
        new (): TaskSignal;
    };
    Text: { prototype: Text; new (data?: string): Text };
    TextDecoder: {
        prototype: TextDecoder;
        new (label?: string, options?: TextDecoderOptions): TextDecoder;
    };
    TextDecoderStream: {
        prototype: TextDecoderStream;
        new (label?: string, options?: TextDecoderOptions): TextDecoderStream;
    };
    TextEncoder: { prototype: TextEncoder; new (): TextEncoder };
    TextEncoderStream: {
        prototype: TextEncoderStream;
        new (): TextEncoderStream;
    };
    TextEvent: { prototype: TextEvent; new (): TextEvent };
    TextMetrics: { prototype: TextMetrics; new (): TextMetrics };
    TextTrack: { prototype: TextTrack; new (): TextTrack };
    TextTrackCue: { prototype: TextTrackCue; new (): TextTrackCue };
    TextTrackCueList: { prototype: TextTrackCueList; new (): TextTrackCueList };
    TextTrackList: { prototype: TextTrackList; new (): TextTrackList };
    TimeRanges: { prototype: TimeRanges; new (): TimeRanges };
    ToggleEvent: {
        prototype: ToggleEvent;
        new (type: string, eventInitDict?: ToggleEventInit): ToggleEvent;
    };
    toolbar: BarProp;
    top: Window
    | null;
    toString: () => string;
    Touch: { prototype: Touch; new (touchInitDict: TouchInit): Touch };
    TouchEvent: {
        prototype: TouchEvent;
        new (type: string, eventInitDict?: TouchEventInit): TouchEvent;
    };
    TouchList: { prototype: TouchList; new (): TouchList };
    TrackEvent: {
        prototype: TrackEvent;
        new (type: string, eventInitDict?: TrackEventInit): TrackEvent;
    };
    TransformStream: {
        prototype: TransformStream;
        new <I = any, O = any>(
            transformer?: Transformer<I, O>,
            writableStrategy?: QueuingStrategy<I>,
            readableStrategy?: QueuingStrategy<O>,
        ): TransformStream<I, O>;
    };
    TransformStreamDefaultController: {
        prototype: TransformStreamDefaultController;
        new (): TransformStreamDefaultController;
    };
    TransitionEvent: {
        prototype: TransitionEvent;
        new (
            type: string,
            transitionEventInitDict?: TransitionEventInit,
        ): TransitionEvent;
    };
    TreeWalker: { prototype: TreeWalker; new (): TreeWalker };
    TypeError: TypeErrorConstructor;
    UIEvent: {
        prototype: UIEvent;
        new (type: string, eventInitDict?: UIEventInit): UIEvent;
    };
    Uint16Array: Uint16ArrayConstructor;
    Uint32Array: Uint32ArrayConstructor;
    Uint8Array: Uint8ArrayConstructor;
    Uint8ClampedArray: Uint8ClampedArrayConstructor;
    undefined: undefined;
    unescape: (string: string) => string;
    URIError: URIErrorConstructor;
    URL: {
        prototype: URL;
        canParse(url: string | URL, base?: string | URL): boolean;
        createObjectURL(obj: Blob | MediaSource): string;
        parse(url: string | URL, base?: string | URL): URL | null;
        revokeObjectURL(url: string): void;
        new (url: string | URL, base?: string | URL): URL;
    };
    URLPattern: {
        prototype: URLPattern;
        new (
            input: URLPatternInput,
            baseURL: string | URL,
            options?: URLPatternOptions,
        ): URLPattern;
        new (input?: URLPatternInput, options?: URLPatternOptions): URLPattern;
    };
    URLSearchParams: {
        prototype: URLSearchParams;
        new (
            init?: string | URLSearchParams | Record<string, string> | string[][],
        ): URLSearchParams;
    };
    UserActivation: { prototype: UserActivation; new (): UserActivation };
    ValidityState: { prototype: ValidityState; new (): ValidityState };
    VideoColorSpace: {
        prototype: VideoColorSpace;
        new (init?: VideoColorSpaceInit): VideoColorSpace;
    };
    VideoDecoder: {
        prototype: VideoDecoder;
        isConfigSupported(
            config: VideoDecoderConfig,
        ): Promise<VideoDecoderSupport>;
        new (init: VideoDecoderInit): VideoDecoder;
    };
    VideoEncoder: {
        prototype: VideoEncoder;
        isConfigSupported(
            config: VideoEncoderConfig,
        ): Promise<VideoEncoderSupport>;
        new (init: VideoEncoderInit): VideoEncoder;
    };
    VideoFrame: {
        prototype: VideoFrame;
        new (image: CanvasImageSource, init?: VideoFrameInit): VideoFrame;
        new (
            data: AllowSharedBufferSource,
            init: VideoFrameBufferInit,
        ): VideoFrame;
    };
    VideoPlaybackQuality: {
        prototype: VideoPlaybackQuality;
        new (): VideoPlaybackQuality;
    };
    ViewTimeline: {
        prototype: ViewTimeline;
        new (options?: ViewTimelineOptions): ViewTimeline;
    };
    ViewTransition: { prototype: ViewTransition; new (): ViewTransition };
    ViewTransitionTypeSet: {
        prototype: ViewTransitionTypeSet;
        new (): ViewTransitionTypeSet;
    };
    visualViewport: VisualViewport
    | null;
    VisualViewport: { prototype: VisualViewport; new (): VisualViewport };
    VTTCue: {
        prototype: VTTCue;
        new (startTime: number, endTime: number, text: string): VTTCue;
    };
    VTTRegion: { prototype: VTTRegion; new (): VTTRegion };
    WakeLock: { prototype: WakeLock; new (): WakeLock };
    WakeLockSentinel: { prototype: WakeLockSentinel; new (): WakeLockSentinel };
    WaveShaperNode: {
        prototype: WaveShaperNode;
        new (
            context: BaseAudioContext,
            options?: WaveShaperOptions,
        ): WaveShaperNode;
    };
    WeakMap: WeakMapConstructor;
    WeakSet: WeakSetConstructor;
    WebAssembly: typeof WebAssembly;
    WebGL2RenderingContext: {
        ACTIVE_ATTRIBUTES: 35721;
        ACTIVE_TEXTURE: 34016;
        ACTIVE_UNIFORM_BLOCKS: 35382;
        ACTIVE_UNIFORMS: 35718;
        ALIASED_LINE_WIDTH_RANGE: 33902;
        ALIASED_POINT_SIZE_RANGE: 33901;
        ALPHA: 6406;
        ALPHA_BITS: 3413;
        ALREADY_SIGNALED: 37146;
        ALWAYS: 519;
        ANY_SAMPLES_PASSED: 35887;
        ANY_SAMPLES_PASSED_CONSERVATIVE: 36202;
        ARRAY_BUFFER: 34962;
        ARRAY_BUFFER_BINDING: 34964;
        ATTACHED_SHADERS: 35717;
        BACK: 1029;
        BLEND: 3042;
        BLEND_COLOR: 32773;
        BLEND_DST_ALPHA: 32970;
        BLEND_DST_RGB: 32968;
        BLEND_EQUATION: 32777;
        BLEND_EQUATION_ALPHA: 34877;
        BLEND_EQUATION_RGB: 32777;
        BLEND_SRC_ALPHA: 32971;
        BLEND_SRC_RGB: 32969;
        BLUE_BITS: 3412;
        BOOL: 35670;
        BOOL_VEC2: 35671;
        BOOL_VEC3: 35672;
        BOOL_VEC4: 35673;
        BROWSER_DEFAULT_WEBGL: 37444;
        BUFFER_SIZE: 34660;
        BUFFER_USAGE: 34661;
        BYTE: 5120;
        CCW: 2305;
        CLAMP_TO_EDGE: 33071;
        COLOR: 6144;
        COLOR_ATTACHMENT0: 36064;
        COLOR_ATTACHMENT1: 36065;
        COLOR_ATTACHMENT10: 36074;
        COLOR_ATTACHMENT11: 36075;
        COLOR_ATTACHMENT12: 36076;
        COLOR_ATTACHMENT13: 36077;
        COLOR_ATTACHMENT14: 36078;
        COLOR_ATTACHMENT15: 36079;
        COLOR_ATTACHMENT2: 36066;
        COLOR_ATTACHMENT3: 36067;
        COLOR_ATTACHMENT4: 36068;
        COLOR_ATTACHMENT5: 36069;
        COLOR_ATTACHMENT6: 36070;
        COLOR_ATTACHMENT7: 36071;
        COLOR_ATTACHMENT8: 36072;
        COLOR_ATTACHMENT9: 36073;
        COLOR_BUFFER_BIT: 16384;
        COLOR_CLEAR_VALUE: 3106;
        COLOR_WRITEMASK: 3107;
        COMPARE_REF_TO_TEXTURE: 34894;
        COMPILE_STATUS: 35713;
        COMPRESSED_TEXTURE_FORMATS: 34467;
        CONDITION_SATISFIED: 37148;
        CONSTANT_ALPHA: 32771;
        CONSTANT_COLOR: 32769;
        CONTEXT_LOST_WEBGL: 37442;
        COPY_READ_BUFFER: 36662;
        COPY_READ_BUFFER_BINDING: 36662;
        COPY_WRITE_BUFFER: 36663;
        COPY_WRITE_BUFFER_BINDING: 36663;
        CULL_FACE: 2884;
        CULL_FACE_MODE: 2885;
        CURRENT_PROGRAM: 35725;
        CURRENT_QUERY: 34917;
        CURRENT_VERTEX_ATTRIB: 34342;
        CW: 2304;
        DECR: 7683;
        DECR_WRAP: 34056;
        DELETE_STATUS: 35712;
        DEPTH: 6145;
        DEPTH_ATTACHMENT: 36096;
        DEPTH_BITS: 3414;
        DEPTH_BUFFER_BIT: 256;
        DEPTH_CLEAR_VALUE: 2931;
        DEPTH_COMPONENT: 6402;
        DEPTH_COMPONENT16: 33189;
        DEPTH_COMPONENT24: 33190;
        DEPTH_COMPONENT32F: 36012;
        DEPTH_FUNC: 2932;
        DEPTH_RANGE: 2928;
        DEPTH_STENCIL: 34041;
        DEPTH_STENCIL_ATTACHMENT: 33306;
        DEPTH_TEST: 2929;
        DEPTH_WRITEMASK: 2930;
        DEPTH24_STENCIL8: 35056;
        DEPTH32F_STENCIL8: 36013;
        DITHER: 3024;
        DONT_CARE: 4352;
        DRAW_BUFFER0: 34853;
        DRAW_BUFFER1: 34854;
        DRAW_BUFFER10: 34863;
        DRAW_BUFFER11: 34864;
        DRAW_BUFFER12: 34865;
        DRAW_BUFFER13: 34866;
        DRAW_BUFFER14: 34867;
        DRAW_BUFFER15: 34868;
        DRAW_BUFFER2: 34855;
        DRAW_BUFFER3: 34856;
        DRAW_BUFFER4: 34857;
        DRAW_BUFFER5: 34858;
        DRAW_BUFFER6: 34859;
        DRAW_BUFFER7: 34860;
        DRAW_BUFFER8: 34861;
        DRAW_BUFFER9: 34862;
        DRAW_FRAMEBUFFER: 36009;
        DRAW_FRAMEBUFFER_BINDING: 36006;
        DST_ALPHA: 772;
        DST_COLOR: 774;
        DYNAMIC_COPY: 35050;
        DYNAMIC_DRAW: 35048;
        DYNAMIC_READ: 35049;
        ELEMENT_ARRAY_BUFFER: 34963;
        ELEMENT_ARRAY_BUFFER_BINDING: 34965;
        EQUAL: 514;
        FASTEST: 4353;
        FLOAT: 5126;
        FLOAT_32_UNSIGNED_INT_24_8_REV: 36269;
        FLOAT_MAT2: 35674;
        FLOAT_MAT2x3: 35685;
        FLOAT_MAT2x4: 35686;
        FLOAT_MAT3: 35675;
        FLOAT_MAT3x2: 35687;
        FLOAT_MAT3x4: 35688;
        FLOAT_MAT4: 35676;
        FLOAT_MAT4x2: 35689;
        FLOAT_MAT4x3: 35690;
        FLOAT_VEC2: 35664;
        FLOAT_VEC3: 35665;
        FLOAT_VEC4: 35666;
        FRAGMENT_SHADER: 35632;
        FRAGMENT_SHADER_DERIVATIVE_HINT: 35723;
        FRAMEBUFFER: 36160;
        FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE: 33301;
        FRAMEBUFFER_ATTACHMENT_BLUE_SIZE: 33300;
        FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING: 33296;
        FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE: 33297;
        FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE: 33302;
        FRAMEBUFFER_ATTACHMENT_GREEN_SIZE: 33299;
        FRAMEBUFFER_ATTACHMENT_OBJECT_NAME: 36049;
        FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE: 36048;
        FRAMEBUFFER_ATTACHMENT_RED_SIZE: 33298;
        FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE: 33303;
        FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE: 36051;
        FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER: 36052;
        FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL: 36050;
        FRAMEBUFFER_BINDING: 36006;
        FRAMEBUFFER_COMPLETE: 36053;
        FRAMEBUFFER_DEFAULT: 33304;
        FRAMEBUFFER_INCOMPLETE_ATTACHMENT: 36054;
        FRAMEBUFFER_INCOMPLETE_DIMENSIONS: 36057;
        FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: 36055;
        FRAMEBUFFER_INCOMPLETE_MULTISAMPLE: 36182;
        FRAMEBUFFER_UNSUPPORTED: 36061;
        FRONT: 1028;
        FRONT_AND_BACK: 1032;
        FRONT_FACE: 2886;
        FUNC_ADD: 32774;
        FUNC_REVERSE_SUBTRACT: 32779;
        FUNC_SUBTRACT: 32778;
        GENERATE_MIPMAP_HINT: 33170;
        GEQUAL: 518;
        GREATER: 516;
        GREEN_BITS: 3411;
        HALF_FLOAT: 5131;
        HIGH_FLOAT: 36338;
        HIGH_INT: 36341;
        IMPLEMENTATION_COLOR_READ_FORMAT: 35739;
        IMPLEMENTATION_COLOR_READ_TYPE: 35738;
        INCR: 7682;
        INCR_WRAP: 34055;
        INT: 5124;
        INT_2_10_10_10_REV: 36255;
        INT_SAMPLER_2D: 36298;
        INT_SAMPLER_2D_ARRAY: 36303;
        INT_SAMPLER_3D: 36299;
        INT_SAMPLER_CUBE: 36300;
        INT_VEC2: 35667;
        INT_VEC3: 35668;
        INT_VEC4: 35669;
        INTERLEAVED_ATTRIBS: 35980;
        INVALID_ENUM: 1280;
        INVALID_FRAMEBUFFER_OPERATION: 1286;
        INVALID_INDEX: 4294967295;
        INVALID_OPERATION: 1282;
        INVALID_VALUE: 1281;
        INVERT: 5386;
        KEEP: 7680;
        LEQUAL: 515;
        LESS: 513;
        LINE_LOOP: 2;
        LINE_STRIP: 3;
        LINE_WIDTH: 2849;
        LINEAR: 9729;
        LINEAR_MIPMAP_LINEAR: 9987;
        LINEAR_MIPMAP_NEAREST: 9985;
        LINES: 1;
        LINK_STATUS: 35714;
        LOW_FLOAT: 36336;
        LOW_INT: 36339;
        LUMINANCE: 6409;
        LUMINANCE_ALPHA: 6410;
        MAX: 32776;
        MAX_3D_TEXTURE_SIZE: 32883;
        MAX_ARRAY_TEXTURE_LAYERS: 35071;
        MAX_CLIENT_WAIT_TIMEOUT_WEBGL: 37447;
        MAX_COLOR_ATTACHMENTS: 36063;
        MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS: 35379;
        MAX_COMBINED_TEXTURE_IMAGE_UNITS: 35661;
        MAX_COMBINED_UNIFORM_BLOCKS: 35374;
        MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS: 35377;
        MAX_CUBE_MAP_TEXTURE_SIZE: 34076;
        MAX_DRAW_BUFFERS: 34852;
        MAX_ELEMENT_INDEX: 36203;
        MAX_ELEMENTS_INDICES: 33001;
        MAX_ELEMENTS_VERTICES: 33000;
        MAX_FRAGMENT_INPUT_COMPONENTS: 37157;
        MAX_FRAGMENT_UNIFORM_BLOCKS: 35373;
        MAX_FRAGMENT_UNIFORM_COMPONENTS: 35657;
        MAX_FRAGMENT_UNIFORM_VECTORS: 36349;
        MAX_PROGRAM_TEXEL_OFFSET: 35077;
        MAX_RENDERBUFFER_SIZE: 34024;
        MAX_SAMPLES: 36183;
        MAX_SERVER_WAIT_TIMEOUT: 37137;
        MAX_TEXTURE_IMAGE_UNITS: 34930;
        MAX_TEXTURE_LOD_BIAS: 34045;
        MAX_TEXTURE_SIZE: 3379;
        MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS: 35978;
        MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS: 35979;
        MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS: 35968;
        MAX_UNIFORM_BLOCK_SIZE: 35376;
        MAX_UNIFORM_BUFFER_BINDINGS: 35375;
        MAX_VARYING_COMPONENTS: 35659;
        MAX_VARYING_VECTORS: 36348;
        MAX_VERTEX_ATTRIBS: 34921;
        MAX_VERTEX_OUTPUT_COMPONENTS: 37154;
        MAX_VERTEX_TEXTURE_IMAGE_UNITS: 35660;
        MAX_VERTEX_UNIFORM_BLOCKS: 35371;
        MAX_VERTEX_UNIFORM_COMPONENTS: 35658;
        MAX_VERTEX_UNIFORM_VECTORS: 36347;
        MAX_VIEWPORT_DIMS: 3386;
        MEDIUM_FLOAT: 36337;
        MEDIUM_INT: 36340;
        MIN: 32775;
        MIN_PROGRAM_TEXEL_OFFSET: 35076;
        MIRRORED_REPEAT: 33648;
        NEAREST: 9728;
        NEAREST_MIPMAP_LINEAR: 9986;
        NEAREST_MIPMAP_NEAREST: 9984;
        NEVER: 512;
        NICEST: 4354;
        NO_ERROR: 0;
        NONE: 0;
        NOTEQUAL: 517;
        OBJECT_TYPE: 37138;
        ONE: 1;
        ONE_MINUS_CONSTANT_ALPHA: 32772;
        ONE_MINUS_CONSTANT_COLOR: 32770;
        ONE_MINUS_DST_ALPHA: 773;
        ONE_MINUS_DST_COLOR: 775;
        ONE_MINUS_SRC_ALPHA: 771;
        ONE_MINUS_SRC_COLOR: 769;
        OUT_OF_MEMORY: 1285;
        PACK_ALIGNMENT: 3333;
        PACK_ROW_LENGTH: 3330;
        PACK_SKIP_PIXELS: 3332;
        PACK_SKIP_ROWS: 3331;
        PIXEL_PACK_BUFFER: 35051;
        PIXEL_PACK_BUFFER_BINDING: 35053;
        PIXEL_UNPACK_BUFFER: 35052;
        PIXEL_UNPACK_BUFFER_BINDING: 35055;
        POINTS: 0;
        POLYGON_OFFSET_FACTOR: 32824;
        POLYGON_OFFSET_FILL: 32823;
        POLYGON_OFFSET_UNITS: 10752;
        prototype: WebGL2RenderingContext;
        QUERY_RESULT: 34918;
        QUERY_RESULT_AVAILABLE: 34919;
        R11F_G11F_B10F: 35898;
        R16F: 33325;
        R16I: 33331;
        R16UI: 33332;
        R32F: 33326;
        R32I: 33333;
        R32UI: 33334;
        R8: 33321;
        R8_SNORM: 36756;
        R8I: 33329;
        R8UI: 33330;
        RASTERIZER_DISCARD: 35977;
        READ_BUFFER: 3074;
        READ_FRAMEBUFFER: 36008;
        READ_FRAMEBUFFER_BINDING: 36010;
        RED: 6403;
        RED_BITS: 3410;
        RED_INTEGER: 36244;
        RENDERBUFFER: 36161;
        RENDERBUFFER_ALPHA_SIZE: 36179;
        RENDERBUFFER_BINDING: 36007;
        RENDERBUFFER_BLUE_SIZE: 36178;
        RENDERBUFFER_DEPTH_SIZE: 36180;
        RENDERBUFFER_GREEN_SIZE: 36177;
        RENDERBUFFER_HEIGHT: 36163;
        RENDERBUFFER_INTERNAL_FORMAT: 36164;
        RENDERBUFFER_RED_SIZE: 36176;
        RENDERBUFFER_SAMPLES: 36011;
        RENDERBUFFER_STENCIL_SIZE: 36181;
        RENDERBUFFER_WIDTH: 36162;
        RENDERER: 7937;
        REPEAT: 10497;
        REPLACE: 7681;
        RG: 33319;
        RG_INTEGER: 33320;
        RG16F: 33327;
        RG16I: 33337;
        RG16UI: 33338;
        RG32F: 33328;
        RG32I: 33339;
        RG32UI: 33340;
        RG8: 33323;
        RG8_SNORM: 36757;
        RG8I: 33335;
        RG8UI: 33336;
        RGB: 6407;
        RGB_INTEGER: 36248;
        RGB10_A2: 32857;
        RGB10_A2UI: 36975;
        RGB16F: 34843;
        RGB16I: 36233;
        RGB16UI: 36215;
        RGB32F: 34837;
        RGB32I: 36227;
        RGB32UI: 36209;
        RGB5_A1: 32855;
        RGB565: 36194;
        RGB8: 32849;
        RGB8_SNORM: 36758;
        RGB8I: 36239;
        RGB8UI: 36221;
        RGB9_E5: 35901;
        RGBA: 6408;
        RGBA_INTEGER: 36249;
        RGBA16F: 34842;
        RGBA16I: 36232;
        RGBA16UI: 36214;
        RGBA32F: 34836;
        RGBA32I: 36226;
        RGBA32UI: 36208;
        RGBA4: 32854;
        RGBA8: 32856;
        RGBA8_SNORM: 36759;
        RGBA8I: 36238;
        RGBA8UI: 36220;
        SAMPLE_ALPHA_TO_COVERAGE: 32926;
        SAMPLE_BUFFERS: 32936;
        SAMPLE_COVERAGE: 32928;
        SAMPLE_COVERAGE_INVERT: 32939;
        SAMPLE_COVERAGE_VALUE: 32938;
        SAMPLER_2D: 35678;
        SAMPLER_2D_ARRAY: 36289;
        SAMPLER_2D_ARRAY_SHADOW: 36292;
        SAMPLER_2D_SHADOW: 35682;
        SAMPLER_3D: 35679;
        SAMPLER_BINDING: 35097;
        SAMPLER_CUBE: 35680;
        SAMPLER_CUBE_SHADOW: 36293;
        SAMPLES: 32937;
        SCISSOR_BOX: 3088;
        SCISSOR_TEST: 3089;
        SEPARATE_ATTRIBS: 35981;
        SHADER_TYPE: 35663;
        SHADING_LANGUAGE_VERSION: 35724;
        SHORT: 5122;
        SIGNALED: 37145;
        SIGNED_NORMALIZED: 36764;
        SRC_ALPHA: 770;
        SRC_ALPHA_SATURATE: 776;
        SRC_COLOR: 768;
        SRGB: 35904;
        SRGB8: 35905;
        SRGB8_ALPHA8: 35907;
        STATIC_COPY: 35046;
        STATIC_DRAW: 35044;
        STATIC_READ: 35045;
        STENCIL: 6146;
        STENCIL_ATTACHMENT: 36128;
        STENCIL_BACK_FAIL: 34817;
        STENCIL_BACK_FUNC: 34816;
        STENCIL_BACK_PASS_DEPTH_FAIL: 34818;
        STENCIL_BACK_PASS_DEPTH_PASS: 34819;
        STENCIL_BACK_REF: 36003;
        STENCIL_BACK_VALUE_MASK: 36004;
        STENCIL_BACK_WRITEMASK: 36005;
        STENCIL_BITS: 3415;
        STENCIL_BUFFER_BIT: 1024;
        STENCIL_CLEAR_VALUE: 2961;
        STENCIL_FAIL: 2964;
        STENCIL_FUNC: 2962;
        STENCIL_INDEX8: 36168;
        STENCIL_PASS_DEPTH_FAIL: 2965;
        STENCIL_PASS_DEPTH_PASS: 2966;
        STENCIL_REF: 2967;
        STENCIL_TEST: 2960;
        STENCIL_VALUE_MASK: 2963;
        STENCIL_WRITEMASK: 2968;
        STREAM_COPY: 35042;
        STREAM_DRAW: 35040;
        STREAM_READ: 35041;
        SUBPIXEL_BITS: 3408;
        SYNC_CONDITION: 37139;
        SYNC_FENCE: 37142;
        SYNC_FLAGS: 37141;
        SYNC_FLUSH_COMMANDS_BIT: 1;
        SYNC_GPU_COMMANDS_COMPLETE: 37143;
        SYNC_STATUS: 37140;
        TEXTURE: 5890;
        TEXTURE_2D: 3553;
        TEXTURE_2D_ARRAY: 35866;
        TEXTURE_3D: 32879;
        TEXTURE_BASE_LEVEL: 33084;
        TEXTURE_BINDING_2D: 32873;
        TEXTURE_BINDING_2D_ARRAY: 35869;
        TEXTURE_BINDING_3D: 32874;
        TEXTURE_BINDING_CUBE_MAP: 34068;
        TEXTURE_COMPARE_FUNC: 34893;
        TEXTURE_COMPARE_MODE: 34892;
        TEXTURE_CUBE_MAP: 34067;
        TEXTURE_CUBE_MAP_NEGATIVE_X: 34070;
        TEXTURE_CUBE_MAP_NEGATIVE_Y: 34072;
        TEXTURE_CUBE_MAP_NEGATIVE_Z: 34074;
        TEXTURE_CUBE_MAP_POSITIVE_X: 34069;
        TEXTURE_CUBE_MAP_POSITIVE_Y: 34071;
        TEXTURE_CUBE_MAP_POSITIVE_Z: 34073;
        TEXTURE_IMMUTABLE_FORMAT: 37167;
        TEXTURE_IMMUTABLE_LEVELS: 33503;
        TEXTURE_MAG_FILTER: 10240;
        TEXTURE_MAX_LEVEL: 33085;
        TEXTURE_MAX_LOD: 33083;
        TEXTURE_MIN_FILTER: 10241;
        TEXTURE_MIN_LOD: 33082;
        TEXTURE_WRAP_R: 32882;
        TEXTURE_WRAP_S: 10242;
        TEXTURE_WRAP_T: 10243;
        TEXTURE0: 33984;
        TEXTURE1: 33985;
        TEXTURE10: 33994;
        TEXTURE11: 33995;
        TEXTURE12: 33996;
        TEXTURE13: 33997;
        TEXTURE14: 33998;
        TEXTURE15: 33999;
        TEXTURE16: 34000;
        TEXTURE17: 34001;
        TEXTURE18: 34002;
        TEXTURE19: 34003;
        TEXTURE2: 33986;
        TEXTURE20: 34004;
        TEXTURE21: 34005;
        TEXTURE22: 34006;
        TEXTURE23: 34007;
        TEXTURE24: 34008;
        TEXTURE25: 34009;
        TEXTURE26: 34010;
        TEXTURE27: 34011;
        TEXTURE28: 34012;
        TEXTURE29: 34013;
        TEXTURE3: 33987;
        TEXTURE30: 34014;
        TEXTURE31: 34015;
        TEXTURE4: 33988;
        TEXTURE5: 33989;
        TEXTURE6: 33990;
        TEXTURE7: 33991;
        TEXTURE8: 33992;
        TEXTURE9: 33993;
        TIMEOUT_EXPIRED: 37147;
        TIMEOUT_IGNORED: -1;
        TRANSFORM_FEEDBACK: 36386;
        TRANSFORM_FEEDBACK_ACTIVE: 36388;
        TRANSFORM_FEEDBACK_BINDING: 36389;
        TRANSFORM_FEEDBACK_BUFFER: 35982;
        TRANSFORM_FEEDBACK_BUFFER_BINDING: 35983;
        TRANSFORM_FEEDBACK_BUFFER_MODE: 35967;
        TRANSFORM_FEEDBACK_BUFFER_SIZE: 35973;
        TRANSFORM_FEEDBACK_BUFFER_START: 35972;
        TRANSFORM_FEEDBACK_PAUSED: 36387;
        TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN: 35976;
        TRANSFORM_FEEDBACK_VARYINGS: 35971;
        TRIANGLE_FAN: 6;
        TRIANGLE_STRIP: 5;
        TRIANGLES: 4;
        UNIFORM_ARRAY_STRIDE: 35388;
        UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES: 35395;
        UNIFORM_BLOCK_ACTIVE_UNIFORMS: 35394;
        UNIFORM_BLOCK_BINDING: 35391;
        UNIFORM_BLOCK_DATA_SIZE: 35392;
        UNIFORM_BLOCK_INDEX: 35386;
        UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER: 35398;
        UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER: 35396;
        UNIFORM_BUFFER: 35345;
        UNIFORM_BUFFER_BINDING: 35368;
        UNIFORM_BUFFER_OFFSET_ALIGNMENT: 35380;
        UNIFORM_BUFFER_SIZE: 35370;
        UNIFORM_BUFFER_START: 35369;
        UNIFORM_IS_ROW_MAJOR: 35390;
        UNIFORM_MATRIX_STRIDE: 35389;
        UNIFORM_OFFSET: 35387;
        UNIFORM_SIZE: 35384;
        UNIFORM_TYPE: 35383;
        UNPACK_ALIGNMENT: 3317;
        UNPACK_COLORSPACE_CONVERSION_WEBGL: 37443;
        UNPACK_FLIP_Y_WEBGL: 37440;
        UNPACK_IMAGE_HEIGHT: 32878;
        UNPACK_PREMULTIPLY_ALPHA_WEBGL: 37441;
        UNPACK_ROW_LENGTH: 3314;
        UNPACK_SKIP_IMAGES: 32877;
        UNPACK_SKIP_PIXELS: 3316;
        UNPACK_SKIP_ROWS: 3315;
        UNSIGNALED: 37144;
        UNSIGNED_BYTE: 5121;
        UNSIGNED_INT: 5125;
        UNSIGNED_INT_10F_11F_11F_REV: 35899;
        UNSIGNED_INT_2_10_10_10_REV: 33640;
        UNSIGNED_INT_24_8: 34042;
        UNSIGNED_INT_5_9_9_9_REV: 35902;
        UNSIGNED_INT_SAMPLER_2D: 36306;
        UNSIGNED_INT_SAMPLER_2D_ARRAY: 36311;
        UNSIGNED_INT_SAMPLER_3D: 36307;
        UNSIGNED_INT_SAMPLER_CUBE: 36308;
        UNSIGNED_INT_VEC2: 36294;
        UNSIGNED_INT_VEC3: 36295;
        UNSIGNED_INT_VEC4: 36296;
        UNSIGNED_NORMALIZED: 35863;
        UNSIGNED_SHORT: 5123;
        UNSIGNED_SHORT_4_4_4_4: 32819;
        UNSIGNED_SHORT_5_5_5_1: 32820;
        UNSIGNED_SHORT_5_6_5: 33635;
        VALIDATE_STATUS: 35715;
        VENDOR: 7936;
        VERSION: 7938;
        VERTEX_ARRAY_BINDING: 34229;
        VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: 34975;
        VERTEX_ATTRIB_ARRAY_DIVISOR: 35070;
        VERTEX_ATTRIB_ARRAY_ENABLED: 34338;
        VERTEX_ATTRIB_ARRAY_INTEGER: 35069;
        VERTEX_ATTRIB_ARRAY_NORMALIZED: 34922;
        VERTEX_ATTRIB_ARRAY_POINTER: 34373;
        VERTEX_ATTRIB_ARRAY_SIZE: 34339;
        VERTEX_ATTRIB_ARRAY_STRIDE: 34340;
        VERTEX_ATTRIB_ARRAY_TYPE: 34341;
        VERTEX_SHADER: 35633;
        VIEWPORT: 2978;
        WAIT_FAILED: 37149;
        ZERO: 0;
        new (): WebGL2RenderingContext;
    };
    WebGLActiveInfo: { prototype: WebGLActiveInfo; new (): WebGLActiveInfo };
    WebGLBuffer: { prototype: WebGLBuffer; new (): WebGLBuffer };
    WebGLContextEvent: {
        prototype: WebGLContextEvent;
        new (type: string, eventInit?: WebGLContextEventInit): WebGLContextEvent;
    };
    WebGLFramebuffer: { prototype: WebGLFramebuffer; new (): WebGLFramebuffer };
    WebGLProgram: { prototype: WebGLProgram; new (): WebGLProgram };
    WebGLQuery: { prototype: WebGLQuery; new (): WebGLQuery };
    WebGLRenderbuffer: {
        prototype: WebGLRenderbuffer;
        new (): WebGLRenderbuffer;
    };
    WebGLRenderingContext: {
        ACTIVE_ATTRIBUTES: 35721;
        ACTIVE_TEXTURE: 34016;
        ACTIVE_UNIFORMS: 35718;
        ALIASED_LINE_WIDTH_RANGE: 33902;
        ALIASED_POINT_SIZE_RANGE: 33901;
        ALPHA: 6406;
        ALPHA_BITS: 3413;
        ALWAYS: 519;
        ARRAY_BUFFER: 34962;
        ARRAY_BUFFER_BINDING: 34964;
        ATTACHED_SHADERS: 35717;
        BACK: 1029;
        BLEND: 3042;
        BLEND_COLOR: 32773;
        BLEND_DST_ALPHA: 32970;
        BLEND_DST_RGB: 32968;
        BLEND_EQUATION: 32777;
        BLEND_EQUATION_ALPHA: 34877;
        BLEND_EQUATION_RGB: 32777;
        BLEND_SRC_ALPHA: 32971;
        BLEND_SRC_RGB: 32969;
        BLUE_BITS: 3412;
        BOOL: 35670;
        BOOL_VEC2: 35671;
        BOOL_VEC3: 35672;
        BOOL_VEC4: 35673;
        BROWSER_DEFAULT_WEBGL: 37444;
        BUFFER_SIZE: 34660;
        BUFFER_USAGE: 34661;
        BYTE: 5120;
        CCW: 2305;
        CLAMP_TO_EDGE: 33071;
        COLOR_ATTACHMENT0: 36064;
        COLOR_BUFFER_BIT: 16384;
        COLOR_CLEAR_VALUE: 3106;
        COLOR_WRITEMASK: 3107;
        COMPILE_STATUS: 35713;
        COMPRESSED_TEXTURE_FORMATS: 34467;
        CONSTANT_ALPHA: 32771;
        CONSTANT_COLOR: 32769;
        CONTEXT_LOST_WEBGL: 37442;
        CULL_FACE: 2884;
        CULL_FACE_MODE: 2885;
        CURRENT_PROGRAM: 35725;
        CURRENT_VERTEX_ATTRIB: 34342;
        CW: 2304;
        DECR: 7683;
        DECR_WRAP: 34056;
        DELETE_STATUS: 35712;
        DEPTH_ATTACHMENT: 36096;
        DEPTH_BITS: 3414;
        DEPTH_BUFFER_BIT: 256;
        DEPTH_CLEAR_VALUE: 2931;
        DEPTH_COMPONENT: 6402;
        DEPTH_COMPONENT16: 33189;
        DEPTH_FUNC: 2932;
        DEPTH_RANGE: 2928;
        DEPTH_STENCIL: 34041;
        DEPTH_STENCIL_ATTACHMENT: 33306;
        DEPTH_TEST: 2929;
        DEPTH_WRITEMASK: 2930;
        DITHER: 3024;
        DONT_CARE: 4352;
        DST_ALPHA: 772;
        DST_COLOR: 774;
        DYNAMIC_DRAW: 35048;
        ELEMENT_ARRAY_BUFFER: 34963;
        ELEMENT_ARRAY_BUFFER_BINDING: 34965;
        EQUAL: 514;
        FASTEST: 4353;
        FLOAT: 5126;
        FLOAT_MAT2: 35674;
        FLOAT_MAT3: 35675;
        FLOAT_MAT4: 35676;
        FLOAT_VEC2: 35664;
        FLOAT_VEC3: 35665;
        FLOAT_VEC4: 35666;
        FRAGMENT_SHADER: 35632;
        FRAMEBUFFER: 36160;
        FRAMEBUFFER_ATTACHMENT_OBJECT_NAME: 36049;
        FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE: 36048;
        FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE: 36051;
        FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL: 36050;
        FRAMEBUFFER_BINDING: 36006;
        FRAMEBUFFER_COMPLETE: 36053;
        FRAMEBUFFER_INCOMPLETE_ATTACHMENT: 36054;
        FRAMEBUFFER_INCOMPLETE_DIMENSIONS: 36057;
        FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: 36055;
        FRAMEBUFFER_UNSUPPORTED: 36061;
        FRONT: 1028;
        FRONT_AND_BACK: 1032;
        FRONT_FACE: 2886;
        FUNC_ADD: 32774;
        FUNC_REVERSE_SUBTRACT: 32779;
        FUNC_SUBTRACT: 32778;
        GENERATE_MIPMAP_HINT: 33170;
        GEQUAL: 518;
        GREATER: 516;
        GREEN_BITS: 3411;
        HIGH_FLOAT: 36338;
        HIGH_INT: 36341;
        IMPLEMENTATION_COLOR_READ_FORMAT: 35739;
        IMPLEMENTATION_COLOR_READ_TYPE: 35738;
        INCR: 7682;
        INCR_WRAP: 34055;
        INT: 5124;
        INT_VEC2: 35667;
        INT_VEC3: 35668;
        INT_VEC4: 35669;
        INVALID_ENUM: 1280;
        INVALID_FRAMEBUFFER_OPERATION: 1286;
        INVALID_OPERATION: 1282;
        INVALID_VALUE: 1281;
        INVERT: 5386;
        KEEP: 7680;
        LEQUAL: 515;
        LESS: 513;
        LINE_LOOP: 2;
        LINE_STRIP: 3;
        LINE_WIDTH: 2849;
        LINEAR: 9729;
        LINEAR_MIPMAP_LINEAR: 9987;
        LINEAR_MIPMAP_NEAREST: 9985;
        LINES: 1;
        LINK_STATUS: 35714;
        LOW_FLOAT: 36336;
        LOW_INT: 36339;
        LUMINANCE: 6409;
        LUMINANCE_ALPHA: 6410;
        MAX_COMBINED_TEXTURE_IMAGE_UNITS: 35661;
        MAX_CUBE_MAP_TEXTURE_SIZE: 34076;
        MAX_FRAGMENT_UNIFORM_VECTORS: 36349;
        MAX_RENDERBUFFER_SIZE: 34024;
        MAX_TEXTURE_IMAGE_UNITS: 34930;
        MAX_TEXTURE_SIZE: 3379;
        MAX_VARYING_VECTORS: 36348;
        MAX_VERTEX_ATTRIBS: 34921;
        MAX_VERTEX_TEXTURE_IMAGE_UNITS: 35660;
        MAX_VERTEX_UNIFORM_VECTORS: 36347;
        MAX_VIEWPORT_DIMS: 3386;
        MEDIUM_FLOAT: 36337;
        MEDIUM_INT: 36340;
        MIRRORED_REPEAT: 33648;
        NEAREST: 9728;
        NEAREST_MIPMAP_LINEAR: 9986;
        NEAREST_MIPMAP_NEAREST: 9984;
        NEVER: 512;
        NICEST: 4354;
        NO_ERROR: 0;
        NONE: 0;
        NOTEQUAL: 517;
        ONE: 1;
        ONE_MINUS_CONSTANT_ALPHA: 32772;
        ONE_MINUS_CONSTANT_COLOR: 32770;
        ONE_MINUS_DST_ALPHA: 773;
        ONE_MINUS_DST_COLOR: 775;
        ONE_MINUS_SRC_ALPHA: 771;
        ONE_MINUS_SRC_COLOR: 769;
        OUT_OF_MEMORY: 1285;
        PACK_ALIGNMENT: 3333;
        POINTS: 0;
        POLYGON_OFFSET_FACTOR: 32824;
        POLYGON_OFFSET_FILL: 32823;
        POLYGON_OFFSET_UNITS: 10752;
        prototype: WebGLRenderingContext;
        RED_BITS: 3410;
        RENDERBUFFER: 36161;
        RENDERBUFFER_ALPHA_SIZE: 36179;
        RENDERBUFFER_BINDING: 36007;
        RENDERBUFFER_BLUE_SIZE: 36178;
        RENDERBUFFER_DEPTH_SIZE: 36180;
        RENDERBUFFER_GREEN_SIZE: 36177;
        RENDERBUFFER_HEIGHT: 36163;
        RENDERBUFFER_INTERNAL_FORMAT: 36164;
        RENDERBUFFER_RED_SIZE: 36176;
        RENDERBUFFER_STENCIL_SIZE: 36181;
        RENDERBUFFER_WIDTH: 36162;
        RENDERER: 7937;
        REPEAT: 10497;
        REPLACE: 7681;
        RGB: 6407;
        RGB5_A1: 32855;
        RGB565: 36194;
        RGBA: 6408;
        RGBA4: 32854;
        RGBA8: 32856;
        SAMPLE_ALPHA_TO_COVERAGE: 32926;
        SAMPLE_BUFFERS: 32936;
        SAMPLE_COVERAGE: 32928;
        SAMPLE_COVERAGE_INVERT: 32939;
        SAMPLE_COVERAGE_VALUE: 32938;
        SAMPLER_2D: 35678;
        SAMPLER_CUBE: 35680;
        SAMPLES: 32937;
        SCISSOR_BOX: 3088;
        SCISSOR_TEST: 3089;
        SHADER_TYPE: 35663;
        SHADING_LANGUAGE_VERSION: 35724;
        SHORT: 5122;
        SRC_ALPHA: 770;
        SRC_ALPHA_SATURATE: 776;
        SRC_COLOR: 768;
        STATIC_DRAW: 35044;
        STENCIL_ATTACHMENT: 36128;
        STENCIL_BACK_FAIL: 34817;
        STENCIL_BACK_FUNC: 34816;
        STENCIL_BACK_PASS_DEPTH_FAIL: 34818;
        STENCIL_BACK_PASS_DEPTH_PASS: 34819;
        STENCIL_BACK_REF: 36003;
        STENCIL_BACK_VALUE_MASK: 36004;
        STENCIL_BACK_WRITEMASK: 36005;
        STENCIL_BITS: 3415;
        STENCIL_BUFFER_BIT: 1024;
        STENCIL_CLEAR_VALUE: 2961;
        STENCIL_FAIL: 2964;
        STENCIL_FUNC: 2962;
        STENCIL_INDEX8: 36168;
        STENCIL_PASS_DEPTH_FAIL: 2965;
        STENCIL_PASS_DEPTH_PASS: 2966;
        STENCIL_REF: 2967;
        STENCIL_TEST: 2960;
        STENCIL_VALUE_MASK: 2963;
        STENCIL_WRITEMASK: 2968;
        STREAM_DRAW: 35040;
        SUBPIXEL_BITS: 3408;
        TEXTURE: 5890;
        TEXTURE_2D: 3553;
        TEXTURE_BINDING_2D: 32873;
        TEXTURE_BINDING_CUBE_MAP: 34068;
        TEXTURE_CUBE_MAP: 34067;
        TEXTURE_CUBE_MAP_NEGATIVE_X: 34070;
        TEXTURE_CUBE_MAP_NEGATIVE_Y: 34072;
        TEXTURE_CUBE_MAP_NEGATIVE_Z: 34074;
        TEXTURE_CUBE_MAP_POSITIVE_X: 34069;
        TEXTURE_CUBE_MAP_POSITIVE_Y: 34071;
        TEXTURE_CUBE_MAP_POSITIVE_Z: 34073;
        TEXTURE_MAG_FILTER: 10240;
        TEXTURE_MIN_FILTER: 10241;
        TEXTURE_WRAP_S: 10242;
        TEXTURE_WRAP_T: 10243;
        TEXTURE0: 33984;
        TEXTURE1: 33985;
        TEXTURE10: 33994;
        TEXTURE11: 33995;
        TEXTURE12: 33996;
        TEXTURE13: 33997;
        TEXTURE14: 33998;
        TEXTURE15: 33999;
        TEXTURE16: 34000;
        TEXTURE17: 34001;
        TEXTURE18: 34002;
        TEXTURE19: 34003;
        TEXTURE2: 33986;
        TEXTURE20: 34004;
        TEXTURE21: 34005;
        TEXTURE22: 34006;
        TEXTURE23: 34007;
        TEXTURE24: 34008;
        TEXTURE25: 34009;
        TEXTURE26: 34010;
        TEXTURE27: 34011;
        TEXTURE28: 34012;
        TEXTURE29: 34013;
        TEXTURE3: 33987;
        TEXTURE30: 34014;
        TEXTURE31: 34015;
        TEXTURE4: 33988;
        TEXTURE5: 33989;
        TEXTURE6: 33990;
        TEXTURE7: 33991;
        TEXTURE8: 33992;
        TEXTURE9: 33993;
        TRIANGLE_FAN: 6;
        TRIANGLE_STRIP: 5;
        TRIANGLES: 4;
        UNPACK_ALIGNMENT: 3317;
        UNPACK_COLORSPACE_CONVERSION_WEBGL: 37443;
        UNPACK_FLIP_Y_WEBGL: 37440;
        UNPACK_PREMULTIPLY_ALPHA_WEBGL: 37441;
        UNSIGNED_BYTE: 5121;
        UNSIGNED_INT: 5125;
        UNSIGNED_SHORT: 5123;
        UNSIGNED_SHORT_4_4_4_4: 32819;
        UNSIGNED_SHORT_5_5_5_1: 32820;
        UNSIGNED_SHORT_5_6_5: 33635;
        VALIDATE_STATUS: 35715;
        VENDOR: 7936;
        VERSION: 7938;
        VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: 34975;
        VERTEX_ATTRIB_ARRAY_ENABLED: 34338;
        VERTEX_ATTRIB_ARRAY_NORMALIZED: 34922;
        VERTEX_ATTRIB_ARRAY_POINTER: 34373;
        VERTEX_ATTRIB_ARRAY_SIZE: 34339;
        VERTEX_ATTRIB_ARRAY_STRIDE: 34340;
        VERTEX_ATTRIB_ARRAY_TYPE: 34341;
        VERTEX_SHADER: 35633;
        VIEWPORT: 2978;
        ZERO: 0;
        new (): WebGLRenderingContext;
    };
    WebGLSampler: { prototype: WebGLSampler; new (): WebGLSampler };
    WebGLShader: { prototype: WebGLShader; new (): WebGLShader };
    WebGLShaderPrecisionFormat: {
        prototype: WebGLShaderPrecisionFormat;
        new (): WebGLShaderPrecisionFormat;
    };
    WebGLSync: { prototype: WebGLSync; new (): WebGLSync };
    WebGLTexture: { prototype: WebGLTexture; new (): WebGLTexture };
    WebGLTransformFeedback: {
        prototype: WebGLTransformFeedback;
        new (): WebGLTransformFeedback;
    };
    WebGLUniformLocation: {
        prototype: WebGLUniformLocation;
        new (): WebGLUniformLocation;
    };
    WebGLVertexArrayObject: {
        prototype: WebGLVertexArrayObject;
        new (): WebGLVertexArrayObject;
    };
    WebKitCSSMatrix: {
        prototype: DOMMatrix;
        fromFloat32Array(array32: Float32Array<ArrayBuffer>): DOMMatrix;
        fromFloat64Array(array64: Float64Array<ArrayBuffer>): DOMMatrix;
        fromMatrix(other?: DOMMatrixInit): DOMMatrix;
        new (init?: string | number[]): DOMMatrix;
    };
    webkitURL: {
        prototype: URL;
        canParse(url: string | URL, base?: string | URL): boolean;
        createObjectURL(obj: Blob | MediaSource): string;
        parse(url: string | URL, base?: string | URL): URL | null;
        revokeObjectURL(url: string): void;
        new (url: string | URL, base?: string | URL): URL;
    };
    WebSocket: {
        CLOSED: 3;
        CLOSING: 2;
        CONNECTING: 0;
        OPEN: 1;
        prototype: WebSocket;
        new (url: string | URL, protocols?: string | string[]): WebSocket;
    };
    WebTransport: {
        prototype: WebTransport;
        new (url: string | URL, options?: WebTransportOptions): WebTransport;
    };
    WebTransportBidirectionalStream: {
        prototype: WebTransportBidirectionalStream;
        new (): WebTransportBidirectionalStream;
    };
    WebTransportDatagramDuplexStream: {
        prototype: WebTransportDatagramDuplexStream;
        new (): WebTransportDatagramDuplexStream;
    };
    WebTransportError: {
        prototype: WebTransportError;
        new (
            message?: string,
            options?: WebTransportErrorOptions,
        ): WebTransportError;
    };
    WGSLLanguageFeatures: {
        prototype: WGSLLanguageFeatures;
        new (): WGSLLanguageFeatures;
    };
    WheelEvent: {
        DOM_DELTA_LINE: 1;
        DOM_DELTA_PAGE: 2;
        DOM_DELTA_PIXEL: 0;
        prototype: WheelEvent;
        new (type: string, eventInitDict?: WheelEventInit): WheelEvent;
    };
    window?: Window;
    Window: { prototype: Window; new (): Window };
    WindowClient: { prototype: WindowClient; new (): WindowClient };
    Worker: {
        prototype: Worker;
        new (scriptURL: string | URL, options?: WorkerOptions): Worker;
    };
    WorkerGlobalScope: {
        prototype: WorkerGlobalScope;
        new (): WorkerGlobalScope;
    };
    WorkerLocation: { prototype: WorkerLocation; new (): WorkerLocation };
    WorkerNavigator: { prototype: WorkerNavigator; new (): WorkerNavigator };
    Worklet: { prototype: Worklet; new (): Worklet };
    WritableStream: {
        prototype: WritableStream;
        new <W = any>(
            underlyingSink?: UnderlyingSink<W>,
            strategy?: QueuingStrategy<W>,
        ): WritableStream<W>;
    };
    WritableStreamDefaultController: {
        prototype: WritableStreamDefaultController;
        new (): WritableStreamDefaultController;
    };
    WritableStreamDefaultWriter: {
        prototype: WritableStreamDefaultWriter;
        new <W = any>(stream: WritableStream<W>): WritableStreamDefaultWriter<W>;
    };
    xdescribe: (description: string, specDefinitions: () => void) => void;
    xit: (
        expectation: string,
        assertion?: ImplementationCallback,
        timeout?: number,
    ) => void;
    XMLDocument: { prototype: XMLDocument; new (): XMLDocument };
    XMLHttpRequest: {
        DONE: 4;
        HEADERS_RECEIVED: 2;
        LOADING: 3;
        OPENED: 1;
        prototype: XMLHttpRequest;
        UNSENT: 0;
        new (): XMLHttpRequest;
    };
    XMLHttpRequestEventTarget: {
        prototype: XMLHttpRequestEventTarget;
        new (): XMLHttpRequestEventTarget;
    };
    XMLHttpRequestUpload: {
        prototype: XMLHttpRequestUpload;
        new (): XMLHttpRequestUpload;
    };
    XMLSerializer: { prototype: XMLSerializer; new (): XMLSerializer };
    XPathEvaluator: { prototype: XPathEvaluator; new (): XPathEvaluator };
    XPathExpression: { prototype: XPathExpression; new (): XPathExpression };
    XPathResult: {
        ANY_TYPE: 0;
        ANY_UNORDERED_NODE_TYPE: 8;
        BOOLEAN_TYPE: 3;
        FIRST_ORDERED_NODE_TYPE: 9;
        NUMBER_TYPE: 1;
        ORDERED_NODE_ITERATOR_TYPE: 5;
        ORDERED_NODE_SNAPSHOT_TYPE: 7;
        prototype: XPathResult;
        STRING_TYPE: 2;
        UNORDERED_NODE_ITERATOR_TYPE: 4;
        UNORDERED_NODE_SNAPSHOT_TYPE: 6;
        new (): XPathResult;
    };
    XSLTProcessor: { prototype: XSLTProcessor; new (): XSLTProcessor };
}