npm - @anvil-works/anvil-pyright - Versions diffs - 0.0.1 → 0.0.2-canary - Mend

@anvil-works/anvil-pyright 0.0.1 → 0.0.2-canary

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (98) hide show

package/dist/anvil-typeshed/client/anvil/js/window/__init__.pyi ADDED Viewed

@@ -0,0 +1,2935 @@
+# AUTO-GENERATED FILE - DO NOT EDIT
+# Edit the source file in anvil-typeshed/source/ instead, then run:
+#   npm run generate-anvil-stubs
+#
+# AUTO-GENERATED from webtypy - https://github.com/pyodide/webtypy
+# Run `npm run generate-anvil-dom-stubs` to regenerate
+#
+"""The anvil.js.window module provides access to the browser's window object.
+In Anvil, `window` is registered in `sys.modules` as `anvil.js.window`, allowing:
+    from anvil.js.window import document
+    from anvil.js.window import location
+    from anvil.js.window import HTMLDivElement
+This module exports all window properties as module-level attributes for convenient access.
+DOM types are also available for type annotations.
+[Anvil Docs](https://anvil.works/docs/client/javascript)
+Generated from WebIDL specifications via webtypy.
+"""
+from typing import Any, Awaitable, Callable, Sequence, overload
+class EventTarget:
+    @classmethod
+    def new(self) -> EventTarget: ...
+    def addEventListener(self, type: str, callback: EventListener | None, options: AddEventListenerOptions | bool | None = {}) -> None: ...
+    def removeEventListener(self, type: str, callback: EventListener | None, options: EventListenerOptions | bool | None = {}) -> None: ...
+    def dispatchEvent(self, event: Event) -> bool: ...
+class Event:
+    @classmethod
+    def new(self, type: str, eventInitDict: EventInit | None = {}) -> Event: ...
+    type: str
+    target: EventTarget | None
+    srcElement: EventTarget | None
+    currentTarget: EventTarget | None
+    def composedPath(self) -> Sequence[EventTarget]: ...
+    NONE = 0
+    CAPTURING_PHASE = 1
+    AT_TARGET = 2
+    BUBBLING_PHASE = 3
+    eventPhase: int
+    def stopPropagation(self) -> None: ...
+    cancelBubble: bool
+    def stopImmediatePropagation(self) -> None: ...
+    bubbles: bool
+    cancelable: bool
+    returnValue: bool
+    def preventDefault(self) -> None: ...
+    defaultPrevented: bool
+    composed: bool
+    isTrusted: bool
+    timeStamp: DOMHighResTimeStamp
+    def initEvent(self, type: str, bubbles: bool | None = False, cancelable: bool | None = False) -> None: ...
+class UIEvent(Event):
+    @classmethod
+    def new(self, type: str, eventInitDict: UIEventInit | None = {}) -> UIEvent: ...
+    sourceCapabilities: InputDeviceCapabilities | None
+    view: Window | None
+    detail: int
+    def initUIEvent(self, typeArg: str, bubblesArg: bool | None = False, cancelableArg: bool | None = False, viewArg: Window | None = None, detailArg: int | None = 0) -> None: ...
+    which: int
+class MouseEvent(UIEvent):
+    @classmethod
+    def new(self, type: str, eventInitDict: MouseEventInit | None = {}) -> MouseEvent: ...
+    pageX: float
+    pageY: float
+    x: float
+    y: float
+    offsetX: float
+    offsetY: float
+    movementX: float
+    movementY: float
+    screenX: int
+    screenY: int
+    clientX: int
+    clientY: int
+    ctrlKey: bool
+    shiftKey: bool
+    altKey: bool
+    metaKey: bool
+    button: short
+    buttons: int
+    relatedTarget: EventTarget | None
+    def getModifierState(self, keyArg: str) -> bool: ...
+    def initMouseEvent(self, typeArg: str, bubblesArg: bool | None = False, cancelableArg: bool | None = False, viewArg: Window | None = None, detailArg: int | None = 0, screenXArg: int | None = 0, screenYArg: int | None = 0, clientXArg: int | None = 0, clientYArg: int | None = 0, ctrlKeyArg: bool | None = False, altKeyArg: bool | None = False, shiftKeyArg: bool | None = False, metaKeyArg: bool | None = False, buttonArg: short | None = 0, relatedTargetArg: EventTarget | None = None) -> None: ...
+class KeyboardEvent(UIEvent):
+    @classmethod
+    def new(self, type: str, eventInitDict: KeyboardEventInit | None = {}) -> KeyboardEvent: ...
+    DOM_KEY_LOCATION_STANDARD = 0x00
+    DOM_KEY_LOCATION_LEFT = 0x01
+    DOM_KEY_LOCATION_RIGHT = 0x02
+    DOM_KEY_LOCATION_NUMPAD = 0x03
+    key: str
+    code: str
+    location: int
+    ctrlKey: bool
+    shiftKey: bool
+    altKey: bool
+    metaKey: bool
+    repeat: bool
+    isComposing: bool
+    def getModifierState(self, keyArg: str) -> bool: ...
+    def initKeyboardEvent(self, typeArg: str, bubblesArg: bool | None = False, cancelableArg: bool | None = False, viewArg: Window | None = None, keyArg: str | None = "", locationArg: int | None = 0, ctrlKey: bool | None = False, altKey: bool | None = False, shiftKey: bool | None = False, metaKey: bool | None = False) -> None: ...
+    charCode: int
+    keyCode: int
+class FocusEvent(UIEvent):
+    @classmethod
+    def new(self, type: str, eventInitDict: FocusEventInit | None = {}) -> FocusEvent: ...
+    relatedTarget: EventTarget | None
+class InputEvent(UIEvent):
+    @classmethod
+    def new(self, type: str, eventInitDict: InputEventInit | None = {}) -> InputEvent: ...
+    dataTransfer: DataTransfer | None
+    def getTargetRanges(self) -> Sequence[StaticRange]: ...
+    data: str | None
+    isComposing: bool
+    inputType: str
+class WheelEvent(MouseEvent):
+    @classmethod
+    def new(self, type: str, eventInitDict: WheelEventInit | None = {}) -> WheelEvent: ...
+    DOM_DELTA_PIXEL = 0x00
+    DOM_DELTA_LINE = 0x01
+    DOM_DELTA_PAGE = 0x02
+    deltaX: float
+    deltaY: float
+    deltaZ: float
+    deltaMode: int
+class TouchEvent(UIEvent):
+    @classmethod
+    def new(self, type: str, eventInitDict: TouchEventInit | None = {}) -> TouchEvent: ...
+    touches: TouchList
+    targetTouches: TouchList
+    changedTouches: TouchList
+    altKey: bool
+    metaKey: bool
+    ctrlKey: bool
+    shiftKey: bool
+class Touch:
+    @classmethod
+    def new(self, touchInitDict: TouchInit) -> Touch: ...
+    identifier: int
+    target: EventTarget
+    screenX: float
+    screenY: float
+    clientX: float
+    clientY: float
+    pageX: float
+    pageY: float
+    radiusX: float
+    radiusY: float
+    rotationAngle: float
+    force: float
+    altitudeAngle: float
+    azimuthAngle: float
+    touchType: TouchType
+class TouchList:
+    length: int
+class PointerEvent(MouseEvent):
+    @classmethod
+    def new(self, type: str, eventInitDict: PointerEventInit | None = {}) -> PointerEvent: ...
+    pointerId: int
+    width: float
+    height: float
+    pressure: float
+    tangentialPressure: float
+    tiltX: int
+    tiltY: int
+    twist: int
+    altitudeAngle: float
+    azimuthAngle: float
+    pointerType: str
+    isPrimary: bool
+    def getCoalescedEvents(self) -> Sequence[PointerEvent]: ...
+    def getPredictedEvents(self) -> Sequence[PointerEvent]: ...
+class DragEvent(MouseEvent):
+    @classmethod
+    def new(self, type: str, eventInitDict: DragEventInit | None = {}) -> DragEvent: ...
+    dataTransfer: DataTransfer | None
+class ClipboardEvent(Event):
+    @classmethod
+    def new(self, type: str, eventInitDict: ClipboardEventInit | None = {}) -> ClipboardEvent: ...
+    clipboardData: DataTransfer | None
+class AnimationEvent(Event):
+    @classmethod
+    def new(self, type: CSSOMString, animationEventInitDict: AnimationEventInit | None = {}) -> AnimationEvent: ...
+    animationName: CSSOMString
+    elapsedTime: float
+    pseudoElement: CSSOMString
+class TransitionEvent(Event):
+    @classmethod
+    def new(self, type: CSSOMString, transitionEventInitDict: TransitionEventInit | None = {}) -> TransitionEvent: ...
+    propertyName: CSSOMString
+    elapsedTime: float
+    pseudoElement: CSSOMString
+class CustomEvent(Event):
+    @classmethod
+    def new(self, type: str, eventInitDict: CustomEventInit | None = {}) -> CustomEvent: ...
+    detail: Any
+    def initCustomEvent(self, type: str, bubbles: bool | None = False, cancelable: bool | None = False, detail: Any | None = None) -> None: ...
+class ErrorEvent(Event):
+    @classmethod
+    def new(self, type: str, eventInitDict: ErrorEventInit | None = {}) -> ErrorEvent: ...
+    message: str
+    filename: USVString
+    lineno: int
+    colno: int
+    error: Any
+class ProgressEvent(Event):
+    @classmethod
+    def new(self, type: str, eventInitDict: ProgressEventInit | None = {}) -> ProgressEvent: ...
+    lengthComputable: bool
+    loaded: int
+    total: int
+class SubmitEvent(Event):
+    @classmethod
+    def new(self, type: str, eventInitDict: SubmitEventInit | None = {}) -> SubmitEvent: ...
+    submitter: HTMLElement | None
+class FormDataEvent(Event):
+    @classmethod
+    def new(self, type: str, eventInitDict: FormDataEventInit) -> FormDataEvent: ...
+    formData: FormData
+class HashChangeEvent(Event):
+    @classmethod
+    def new(self, type: str, eventInitDict: HashChangeEventInit | None = {}) -> HashChangeEvent: ...
+    oldURL: USVString
+    newURL: USVString
+class PopStateEvent(Event):
+    @classmethod
+    def new(self, type: str, eventInitDict: PopStateEventInit | None = {}) -> PopStateEvent: ...
+    state: Any
+class StorageEvent(Event):
+    @classmethod
+    def new(self, type: str, eventInitDict: StorageEventInit | None = {}) -> StorageEvent: ...
+    key: str | None
+    oldValue: str | None
+    newValue: str | None
+    url: USVString
+    storageArea: Storage | None
+    def initStorageEvent(self, type: str, bubbles: bool | None = False, cancelable: bool | None = False, key: str | None = None, oldValue: str | None = None, newValue: str | None = None, url: USVString | None = "", storageArea: Storage | None = None) -> None: ...
+class MessageEvent(Event):
+    @classmethod
+    def new(self, type: str, eventInitDict: MessageEventInit | None = {}) -> MessageEvent: ...
+    data: Any
+    origin: USVString
+    lastEventId: str
+    source: MessageEventSource | None
+    ports: Sequence[MessagePort]
+    def initMessageEvent(self, type: str, bubbles: bool | None = False, cancelable: bool | None = False, data: Any | None = None, origin: USVString | None = "", lastEventId: str | None = "", source: MessageEventSource | None = None, ports: Sequence[MessagePort] | None = []) -> None: ...
+class BeforeUnloadEvent(Event):
+    returnValue: str
+class Node(EventTarget):
+    ELEMENT_NODE = 1
+    ATTRIBUTE_NODE = 2
+    TEXT_NODE = 3
+    CDATA_SECTION_NODE = 4
+    ENTITY_REFERENCE_NODE = 5
+    ENTITY_NODE = 6
+    PROCESSING_INSTRUCTION_NODE = 7
+    COMMENT_NODE = 8
+    DOCUMENT_NODE = 9
+    DOCUMENT_TYPE_NODE = 10
+    DOCUMENT_FRAGMENT_NODE = 11
+    NOTATION_NODE = 12
+    nodeType: int
+    nodeName: str
+    baseURI: USVString
+    isConnected: bool
+    ownerDocument: Document | None
+    def getRootNode(self, options: GetRootNodeOptions | None = {}) -> Node: ...
+    parentNode: Node | None
+    parentElement: Element | None
+    def hasChildNodes(self) -> bool: ...
+    childNodes: NodeList
+    firstChild: Node | None
+    lastChild: Node | None
+    previousSibling: Node | None
+    nextSibling: Node | None
+    nodeValue: str | None
+    textContent: str | None
+    def normalize(self) -> None: ...
+    def cloneNode(self, deep: bool | None = False) -> Node: ...
+    def isEqualNode(self, otherNode: Node | None) -> bool: ...
+    def isSameNode(self, otherNode: Node | None) -> bool: ...
+    DOCUMENT_POSITION_DISCONNECTED = 0x01
+    DOCUMENT_POSITION_PRECEDING = 0x02
+    DOCUMENT_POSITION_FOLLOWING = 0x04
+    DOCUMENT_POSITION_CONTAINS = 0x08
+    DOCUMENT_POSITION_CONTAINED_BY = 0x10
+    DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC = 0x20
+    def compareDocumentPosition(self, other: Node) -> int: ...
+    def contains(self, other: Node | None) -> bool: ...
+    def lookupPrefix(self, namespace: str | None) -> str | None: ...
+    def lookupNamespaceURI(self, prefix: str | None) -> str | None: ...
+    def isDefaultNamespace(self, namespace: str | None) -> bool: ...
+    def insertBefore(self, node: Node, child: Node | None) -> Node: ...
+    def appendChild(self, node: Node) -> Node: ...
+    def replaceChild(self, node: Node, child: Node) -> Node: ...
+    def removeChild(self, child: Node) -> Node: ...
+class NodeList:
+    length: int
+class Element(Node, InnerHTML, Region, GeometryUtils, ParentNode, NonDocumentTypeChildNode, ChildNode, Slottable, ARIAMixin, Animatable):
+    outerHTML: str
+    def insertAdjacentHTML(self, position: str, text: str) -> None: ...
+    def getSpatialNavigationContainer(self) -> Node: ...
+    def focusableAreas(self, option: FocusableAreasOption | None = {}) -> Sequence[Node]: ...
+    def spatialNavigationSearch(self, dir: SpatialNavigationDirection, options: SpatialNavigationSearchOptions | None = {}) -> Node | None: ...
+    def pseudo(self, type: CSSOMString) -> CSSPseudoElement | None: ...
+    part: DOMTokenList
+    def computedStyleMap(self) -> StylePropertyMapReadOnly: ...
+    def getClientRects(self) -> DOMRectList: ...
+    def getBoundingClientRect(self) -> DOMRect: ...
+    def checkVisibility(self, options: CheckVisibilityOptions | None = {}) -> bool: ...
+    def scrollIntoView(self, arg: bool | ScrollIntoViewOptions | None = {}) -> None: ...
+    @overload
+    def scroll(self, options: ScrollToOptions | None = {}) -> None: ...
+    @overload
+    def scroll(self, x: float, y: float) -> None: ...
+    @overload
+    def scrollTo(self, options: ScrollToOptions | None = {}) -> None: ...
+    @overload
+    def scrollTo(self, x: float, y: float) -> None: ...
+    @overload
+    def scrollBy(self, options: ScrollToOptions | None = {}) -> None: ...
+    @overload
+    def scrollBy(self, x: float, y: float) -> None: ...
+    scrollTop: float
+    scrollLeft: float
+    scrollWidth: int
+    scrollHeight: int
+    clientTop: int
+    clientLeft: int
+    clientWidth: int
+    clientHeight: int
+    namespaceURI: str | None
+    prefix: str | None
+    localName: str
+    tagName: str
+    id: str
+    className: str
+    classList: DOMTokenList
+    slot: str
+    def hasAttributes(self) -> bool: ...
+    attributes: NamedNodeMap
+    def getAttributeNames(self) -> Sequence[str]: ...
+    def getAttribute(self, qualifiedName: str) -> str | None: ...
+    def getAttributeNS(self, namespace: str | None, localName: str) -> str | None: ...
+    def setAttribute(self, qualifiedName: str, value: str) -> None: ...
+    def setAttributeNS(self, namespace: str | None, qualifiedName: str, value: str) -> None: ...
+    def removeAttribute(self, qualifiedName: str) -> None: ...
+    def removeAttributeNS(self, namespace: str | None, localName: str) -> None: ...
+    def toggleAttribute(self, qualifiedName: str, force: bool | None = None) -> bool: ...
+    def hasAttribute(self, qualifiedName: str) -> bool: ...
+    def hasAttributeNS(self, namespace: str | None, localName: str) -> bool: ...
+    def getAttributeNode(self, qualifiedName: str) -> Attr | None: ...
+    def getAttributeNodeNS(self, namespace: str | None, localName: str) -> Attr | None: ...
+    def setAttributeNode(self, attr: Attr) -> Attr | None: ...
+    def setAttributeNodeNS(self, attr: Attr) -> Attr | None: ...
+    def removeAttributeNode(self, attr: Attr) -> Attr: ...
+    def attachShadow(self, init: ShadowRootInit) -> ShadowRoot: ...
+    shadowRoot: ShadowRoot | None
+    def closest(self, selectors: str) -> Element | None: ...
+    def matches(self, selectors: str) -> bool: ...
+    def webkitMatchesSelector(self, selectors: str) -> bool: ...
+    def getElementsByTagName(self, qualifiedName: str) -> HTMLCollection: ...
+    def getElementsByTagNameNS(self, namespace: str | None, localName: str) -> HTMLCollection: ...
+    def getElementsByClassName(self, classNames: str) -> HTMLCollection: ...
+    def insertAdjacentElement(self, where: str, element: Element) -> Element | None: ...
+    def insertAdjacentText(self, where: str, data: str) -> None: ...
+    editContext: EditContext | None
+    elementTiming: str
+    def requestFullscreen(self, options: FullscreenOptions | None = {}) -> Awaitable[None]: ...
+    onfullscreenchange: EventHandler
+    onfullscreenerror: EventHandler
+    def setPointerCapture(self, pointerId: int) -> None: ...
+    def releasePointerCapture(self, pointerId: int) -> None: ...
+    def hasPointerCapture(self, pointerId: int) -> bool: ...
+    def requestPointerLock(self) -> None: ...
+    def setHTML(self, input: str, options: SetHTMLOptions | None = {}) -> None: ...
+class HTMLCollection:
+    length: int
+class DOMTokenList:
+    length: int
+    def contains(self, token: str) -> bool: ...
+    def add(self, *tokens: str) -> None: ...
+    def remove(self, *tokens: str) -> None: ...
+    def toggle(self, token: str, force: bool | None = None) -> bool: ...
+    def replace(self, token: str, newToken: str) -> bool: ...
+    def supports(self, token: str) -> bool: ...
+    value: str
+class DOMRect(DOMRectReadOnly):
+    @classmethod
+    def new(self, x: float | None = 0, y: float | None = 0, width: float | None = 0, height: float | None = 0) -> DOMRect: ...
+    x: float
+    y: float
+    width: float
+    height: float
+class DOMRectReadOnly:
+    @classmethod
+    def new(self, x: float | None = 0, y: float | None = 0, width: float | None = 0, height: float | None = 0) -> DOMRectReadOnly: ...
+    x: float
+    y: float
+    width: float
+    height: float
+    top: float
+    right: float
+    bottom: float
+    left: float
+    def toJSON(self) -> object: ...
+class InnerHTML:
+    innerHTML: str
+class Region:
+    regionOverset: CSSOMString
+    def getRegionFlowRanges(self) -> Sequence[Range]: ...
+class GeometryUtils:
+    def getBoxQuads(self, options: BoxQuadOptions | None = {}) -> Sequence[DOMQuad]: ...
+    def convertQuadFromNode(self, quad: DOMQuadInit, from_: GeometryNode, options: ConvertCoordinateOptions | None = {}) -> DOMQuad: ...
+    def convertRectFromNode(self, rect: DOMRectReadOnly, from_: GeometryNode, options: ConvertCoordinateOptions | None = {}) -> DOMQuad: ...
+    def convertPointFromNode(self, point: DOMPointInit, from_: GeometryNode, options: ConvertCoordinateOptions | None = {}) -> DOMPoint: ...
+class NonDocumentTypeChildNode:
+    previousElementSibling: Element | None
+    nextElementSibling: Element | None
+class ARIAMixin:
+    role: str | None
+    ariaActiveDescendantElement: Element | None
+    ariaAtomic: str | None
+    ariaAutoComplete: str | None
+    ariaBusy: str | None
+    ariaChecked: str | None
+    ariaColCount: str | None
+    ariaColIndex: str | None
+    ariaColIndexText: str | None
+    ariaColSpan: str | None
+    ariaControlsElements: Sequence[Element]
+    ariaCurrent: str | None
+    ariaDescribedByElements: Sequence[Element]
+    ariaDescription: str | None
+    ariaDetailsElements: Sequence[Element]
+    ariaDisabled: str | None
+    ariaErrorMessageElements: Sequence[Element]
+    ariaExpanded: str | None
+    ariaFlowToElements: Sequence[Element]
+    ariaHasPopup: str | None
+    ariaHidden: str | None
+    ariaInvalid: str | None
+    ariaKeyShortcuts: str | None
+    ariaLabel: str | None
+    ariaLabelledByElements: Sequence[Element]
+    ariaLevel: str | None
+    ariaLive: str | None
+    ariaModal: str | None
+    ariaMultiLine: str | None
+    ariaMultiSelectable: str | None
+    ariaOrientation: str | None
+    ariaOwnsElements: Sequence[Element]
+    ariaPlaceholder: str | None
+    ariaPosInSet: str | None
+    ariaPressed: str | None
+    ariaReadOnly: str | None
+    ariaRequired: str | None
+    ariaRoleDescription: str | None
+    ariaRowCount: str | None
+    ariaRowIndex: str | None
+    ariaRowIndexText: str | None
+    ariaRowSpan: str | None
+    ariaSelected: str | None
+    ariaSetSize: str | None
+    ariaSort: str | None
+    ariaValueMax: str | None
+    ariaValueMin: str | None
+    ariaValueNow: str | None
+    ariaValueText: str | None
+class Animatable:
+    def animate(self, keyframes: object | None, options: float | KeyframeAnimationOptions | None = {}) -> Animation: ...
+    def getAnimations(self, options: GetAnimationsOptions | None = {}) -> Sequence[Animation]: ...
+class ElementCSSInlineStyle:
+    attributeStyleMap: StylePropertyMap
+    style: CSSStyleDeclaration
+class ElementContentEditable:
+    contentEditable: str
+    enterKeyHint: str
+    isContentEditable: bool
+    inputMode: str
+    virtualKeyboardPolicy: str
+class HTMLOrSVGElement:
+    dataset: DOMStringMap
+    nonce: str
+    autofocus: bool
+    tabIndex: int
+    def focus(self, options: FocusOptions | None = {}) -> None: ...
+    def blur(self) -> None: ...
+class NonElementParentNode:
+    def getElementById(self, elementId: str) -> Element | None: ...
+class ParentNode:
+    children: HTMLCollection
+    firstElementChild: Element | None
+    lastElementChild: Element | None
+    childElementCount: int
+    def prepend(self, *nodes: Node | str) -> None: ...
+    def append(self, *nodes: Node | str) -> None: ...
+    def replaceChildren(self, *nodes: Node | str) -> None: ...
+    def querySelector(self, selectors: str) -> Element | None: ...
+    def querySelectorAll(self, selectors: str) -> NodeList: ...
+class ChildNode:
+    def before(self, *nodes: Node | str) -> None: ...
+    def after(self, *nodes: Node | str) -> None: ...
+    def replaceWith(self, *nodes: Node | str) -> None: ...
+    def remove(self) -> None: ...
+class Slottable:
+    assignedSlot: HTMLSlotElement | None
+class DocumentOrShadowRoot:
+    styleSheets: StyleSheetList
+    adoptedStyleSheets: Sequence[CSSStyleSheet]
+    fullscreenElement: Element | None
+    activeElement: Element | None
+    pictureInPictureElement: Element | None
+    pointerLockElement: Element | None
+    def getAnimations(self) -> Sequence[Animation]: ...
+class GlobalEventHandlers:
+    onanimationstart: EventHandler
+    onanimationiteration: EventHandler
+    onanimationend: EventHandler
+    onanimationcancel: EventHandler
+    ontransitionrun: EventHandler
+    ontransitionstart: EventHandler
+    ontransitionend: EventHandler
+    ontransitioncancel: EventHandler
+    onabort: EventHandler
+    onauxclick: EventHandler
+    onbeforeinput: EventHandler
+    onbeforematch: EventHandler
+    onblur: EventHandler
+    oncancel: EventHandler
+    oncanplay: EventHandler
+    oncanplaythrough: EventHandler
+    onchange: EventHandler
+    onclick: EventHandler
+    onclose: EventHandler
+    oncontextlost: EventHandler
+    oncontextmenu: EventHandler
+    oncontextrestored: EventHandler
+    oncopy: EventHandler
+    oncuechange: EventHandler
+    oncut: EventHandler
+    ondblclick: EventHandler
+    ondrag: EventHandler
+    ondragend: EventHandler
+    ondragenter: EventHandler
+    ondragleave: EventHandler
+    ondragover: EventHandler
+    ondragstart: EventHandler
+    ondrop: EventHandler
+    ondurationchange: EventHandler
+    onemptied: EventHandler
+    onended: EventHandler
+    onerror: OnErrorEventHandler
+    onfocus: EventHandler
+    onformdata: EventHandler
+    oninput: EventHandler
+    oninvalid: EventHandler
+    onkeydown: EventHandler
+    onkeypress: EventHandler
+    onkeyup: EventHandler
+    onload: EventHandler
+    onloadeddata: EventHandler
+    onloadedmetadata: EventHandler
+    onloadstart: EventHandler
+    onmousedown: EventHandler
+    onmouseenter: EventHandler
+    onmouseleave: EventHandler
+    onmousemove: EventHandler
+    onmouseout: EventHandler
+    onmouseover: EventHandler
+    onmouseup: EventHandler
+    onpaste: EventHandler
+    onpause: EventHandler
+    onplay: EventHandler
+    onplaying: EventHandler
+    onprogress: EventHandler
+    onratechange: EventHandler
+    onreset: EventHandler
+    onresize: EventHandler
+    onscroll: EventHandler
+    onscrollend: EventHandler
+    onsecuritypolicyviolation: EventHandler
+    onseeked: EventHandler
+    onseeking: EventHandler
+    onselect: EventHandler
+    onslotchange: EventHandler
+    onstalled: EventHandler
+    onsubmit: EventHandler
+    onsuspend: EventHandler
+    ontimeupdate: EventHandler
+    ontoggle: EventHandler
+    onvolumechange: EventHandler
+    onwaiting: EventHandler
+    onwebkitanimationend: EventHandler
+    onwebkitanimationiteration: EventHandler
+    onwebkitanimationstart: EventHandler
+    onwebkittransitionend: EventHandler
+    onwheel: EventHandler
+    onpointerover: EventHandler
+    onpointerenter: EventHandler
+    onpointerdown: EventHandler
+    onpointermove: EventHandler
+    onpointerrawupdate: EventHandler
+    onpointerup: EventHandler
+    onpointercancel: EventHandler
+    onpointerout: EventHandler
+    onpointerleave: EventHandler
+    ongotpointercapture: EventHandler
+    onlostpointercapture: EventHandler
+    onselectstart: EventHandler
+    onselectionchange: EventHandler
+    ontouchstart: EventHandler
+    ontouchend: EventHandler
+    ontouchmove: EventHandler
+    ontouchcancel: EventHandler
+    onbeforexrselect: EventHandler
+class FontFaceSource:
+    fonts: FontFaceSet
+class XPathEvaluatorBase:
+    def createExpression(self, expression: str, resolver: XPathNSResolver | None = None) -> XPathExpression: ...
+    def createNSResolver(self, nodeResolver: Node) -> XPathNSResolver: ...
+    def evaluate(self, expression: str, contextNode: Node, resolver: XPathNSResolver | None = None, type: int | None = 0, result: XPathResult | None = None) -> XPathResult: ...
+class Document(Node, FontFaceSource, GeometryUtils, NonElementParentNode, DocumentOrShadowRoot, ParentNode, XPathEvaluatorBase, GlobalEventHandlers):
+    @classmethod
+    def new(self) -> Document: ...
+    rootElement: SVGSVGElement | None
+    namedFlows: NamedFlowMap
+    def startViewTransition(self, callback: UpdateCallback | None = None) -> ViewTransition: ...
+    def elementFromPoint(self, x: float, y: float) -> Element | None: ...
+    def elementsFromPoint(self, x: float, y: float) -> Sequence[Element]: ...
+    def caretPositionFromPoint(self, x: float, y: float) -> CaretPosition | None: ...
+    scrollingElement: Element | None
+    implementation: DOMImplementation
+    URL: USVString
+    documentURI: USVString
+    compatMode: str
+    characterSet: str
+    charset: str
+    inputEncoding: str
+    contentType: str
+    doctype: DocumentType | None
+    documentElement: Element | None
+    def getElementsByTagName(self, qualifiedName: str) -> HTMLCollection: ...
+    def getElementsByTagNameNS(self, namespace: str | None, localName: str) -> HTMLCollection: ...
+    def getElementsByClassName(self, classNames: str) -> HTMLCollection: ...
+    def createElement(self, localName: str, options: str | ElementCreationOptions | None = {}) -> Element: ...
+    def createElementNS(self, namespace: str | None, qualifiedName: str, options: str | ElementCreationOptions | None = {}) -> Element: ...
+    def createDocumentFragment(self) -> DocumentFragment: ...
+    def createTextNode(self, data: str) -> Text: ...
+    def createCDATASection(self, data: str) -> CDATASection: ...
+    def createComment(self, data: str) -> Comment: ...
+    def createProcessingInstruction(self, target: str, data: str) -> ProcessingInstruction: ...
+    def importNode(self, node: Node, deep: bool | None = False) -> Node: ...
+    def adoptNode(self, node: Node) -> Node: ...
+    def createAttribute(self, localName: str) -> Attr: ...
+    def createAttributeNS(self, namespace: str | None, qualifiedName: str) -> Attr: ...
+    def createEvent(self, interface: str) -> Event: ...
+    def createRange(self) -> Range: ...
+    def createNodeIterator(self, root: Node, whatToShow: int | None = 0xFFFFFFFF, filter: NodeFilter | None = None) -> NodeIterator: ...
+    def createTreeWalker(self, root: Node, whatToShow: int | None = 0xFFFFFFFF, filter: NodeFilter | None = None) -> TreeWalker: ...
+    def measureElement(self, element: Element) -> FontMetrics: ...
+    def measureText(self, text: str, styleMap: StylePropertyMapReadOnly) -> FontMetrics: ...
+    fullscreenEnabled: bool
+    fullscreen: bool
+    def exitFullscreen(self) -> Awaitable[None]: ...
+    onfullscreenchange: EventHandler
+    onfullscreenerror: EventHandler
+    location: Location | None
+    domain: USVString
+    referrer: USVString
+    cookie: USVString
+    lastModified: str
+    readyState: DocumentReadyState
+    title: str
+    dir: str
+    body: HTMLElement | None
+    head: HTMLHeadElement | None
+    images: HTMLCollection
+    embeds: HTMLCollection
+    plugins: HTMLCollection
+    links: HTMLCollection
+    forms: HTMLCollection
+    scripts: HTMLCollection
+    def getElementsByName(self, elementName: str) -> NodeList: ...
+    currentScript: HTMLOrSVGScriptElement | None
+    @overload
+    def open(self, unused1: str | None = None, unused2: str | None = None) -> Document: ...
+    @overload
+    def open(self, url: USVString, name: str, features: str) -> WindowProxy | None: ...
+    def close(self) -> None: ...
+    def write(self, *text: str) -> None: ...
+    def writeln(self, *text: str) -> None: ...
+    defaultView: WindowProxy | None
+    def hasFocus(self) -> bool: ...
+    designMode: str
+    def execCommand(self, commandId: str, showUI: bool | None = False, value: str | None = "") -> bool: ...
+    def queryCommandEnabled(self, commandId: str) -> bool: ...
+    def queryCommandIndeterm(self, commandId: str) -> bool: ...
+    def queryCommandState(self, commandId: str) -> bool: ...
+    def queryCommandSupported(self, commandId: str) -> bool: ...
+    def queryCommandValue(self, commandId: str) -> str: ...
+    hidden: bool
+    visibilityState: DocumentVisibilityState
+    onreadystatechange: EventHandler
+    onvisibilitychange: EventHandler
+    fgColor: str
+    linkColor: str
+    vlinkColor: str
+    alinkColor: str
+    bgColor: str
+    anchors: HTMLCollection
+    applets: HTMLCollection
+    def clear(self) -> None: ...
+    def captureEvents(self) -> None: ...
+    def releaseEvents(self) -> None: ...
+    all: HTMLAllCollection
+    onfreeze: EventHandler
+    onresume: EventHandler
+    wasDiscarded: bool
+    permissionsPolicy: PermissionsPolicy
+    pictureInPictureEnabled: bool
+    def exitPictureInPicture(self) -> Awaitable[None]: ...
+    onpointerlockchange: EventHandler
+    onpointerlockerror: EventHandler
+    def exitPointerLock(self) -> None: ...
+    prerendering: bool
+    onprerenderingchange: EventHandler
+    fragmentDirective: FragmentDirective
+    def getSelection(self) -> Selection | None: ...
+    def hasStorageAccess(self) -> Awaitable[bool]: ...
+    def requestStorageAccess(self) -> Awaitable[None]: ...
+    timeline: DocumentTimeline
+class DocumentFragment(Node, NonElementParentNode, ParentNode):
+    @classmethod
+    def new(self) -> DocumentFragment: ...
+class HTMLElement(Element, ElementCSSInlineStyle, GlobalEventHandlers, ElementContentEditable, HTMLOrSVGElement):
+    @classmethod
+    def new(self) -> HTMLElement: ...
+    offsetParent: Element | None
+    offsetTop: int
+    offsetLeft: int
+    offsetWidth: int
+    offsetHeight: int
+    title: str
+    lang: str
+    translate: bool
+    dir: str
+    hidden: bool | float | str | None
+    inert: bool
+    def click(self) -> None: ...
+    accessKey: str
+    accessKeyLabel: str
+    draggable: bool
+    spellcheck: bool
+    autocapitalize: str
+    innerText: str
+    outerText: str
+    def attachInternals(self) -> ElementInternals: ...
+class HTMLDivElement(HTMLElement):
+    @classmethod
+    def new(self) -> HTMLDivElement: ...
+    align: str
+class HTMLSpanElement(HTMLElement):
+    @classmethod
+    def new(self) -> HTMLSpanElement: ...
+class HTMLParagraphElement(HTMLElement):
+    @classmethod
+    def new(self) -> HTMLParagraphElement: ...
+    align: str
+class HTMLHeadingElement(HTMLElement):
+    @classmethod
+    def new(self) -> HTMLHeadingElement: ...
+    align: str
+class HTMLBRElement(HTMLElement):
+    @classmethod
+    def new(self) -> HTMLBRElement: ...
+    clear: str
+class HTMLHRElement(HTMLElement):
+    @classmethod
+    def new(self) -> HTMLHRElement: ...
+    align: str
+    color: str
+    noShade: bool
+    size: str
+    width: str
+class HTMLPreElement(HTMLElement):
+    @classmethod
+    def new(self) -> HTMLPreElement: ...
+    width: int
+class HTMLQuoteElement(HTMLElement):
+    @classmethod
+    def new(self) -> HTMLQuoteElement: ...
+    cite: USVString
+class HTMLLabelElement(HTMLElement):
+    @classmethod
+    def new(self) -> HTMLLabelElement: ...
+    form: HTMLFormElement | None
+    htmlFor: str
+    control: HTMLElement | None
+class HTMLLIElement(HTMLElement):
+    @classmethod
+    def new(self) -> HTMLLIElement: ...
+    value: int
+    type: str
+class HTMLUListElement(HTMLElement):
+    @classmethod
+    def new(self) -> HTMLUListElement: ...
+    compact: bool
+    type: str
+class HTMLOListElement(HTMLElement):
+    @classmethod
+    def new(self) -> HTMLOListElement: ...
+    reversed: bool
+    start: int
+    type: str
+    compact: bool
+class HTMLTableElement(HTMLElement):
+    @classmethod
+    def new(self) -> HTMLTableElement: ...
+    caption: HTMLTableCaptionElement | None
+    def createCaption(self) -> HTMLTableCaptionElement: ...
+    def deleteCaption(self) -> None: ...
+    tHead: HTMLTableSectionElement | None
+    def createTHead(self) -> HTMLTableSectionElement: ...
+    def deleteTHead(self) -> None: ...
+    tFoot: HTMLTableSectionElement | None
+    def createTFoot(self) -> HTMLTableSectionElement: ...
+    def deleteTFoot(self) -> None: ...
+    tBodies: HTMLCollection
+    def createTBody(self) -> HTMLTableSectionElement: ...
+    rows: HTMLCollection
+    def insertRow(self, index: int | None = -1) -> HTMLTableRowElement: ...
+    def deleteRow(self, index: int) -> None: ...
+    align: str
+    border: str
+    frame: str
+    rules: str
+    summary: str
+    width: str
+    bgColor: str
+    cellPadding: str
+    cellSpacing: str
+class HTMLTableRowElement(HTMLElement):
+    @classmethod
+    def new(self) -> HTMLTableRowElement: ...
+    rowIndex: int
+    sectionRowIndex: int
+    cells: HTMLCollection
+    def insertCell(self, index: int | None = -1) -> HTMLTableCellElement: ...
+    def deleteCell(self, index: int) -> None: ...
+    align: str
+    ch: str
+    chOff: str
+    vAlign: str
+    bgColor: str
+class HTMLTableCellElement(HTMLElement):
+    @classmethod
+    def new(self) -> HTMLTableCellElement: ...
+    colSpan: int
+    rowSpan: int
+    headers: str
+    cellIndex: int
+    scope: str
+    abbr: str
+    align: str
+    axis: str
+    height: str
+    width: str
+    ch: str
+    chOff: str
+    noWrap: bool
+    vAlign: str
+    bgColor: str
+class HTMLTableSectionElement(HTMLElement):
+    @classmethod
+    def new(self) -> HTMLTableSectionElement: ...
+    rows: HTMLCollection
+    def insertRow(self, index: int | None = -1) -> HTMLTableRowElement: ...
+    def deleteRow(self, index: int) -> None: ...
+    align: str
+    ch: str
+    chOff: str
+    vAlign: str
+class HTMLFormElement(HTMLElement):
+    @classmethod
+    def new(self) -> HTMLFormElement: ...
+    acceptCharset: str
+    action: USVString
+    autocomplete: str
+    enctype: str
+    encoding: str
+    method: str
+    name: str
+    noValidate: bool
+    target: str
+    rel: str
+    relList: DOMTokenList
+    elements: HTMLFormControlsCollection
+    length: int
+    def submit(self) -> None: ...
+    def requestSubmit(self, submitter: HTMLElement | None = None) -> None: ...
+    def reset(self) -> None: ...
+    def checkValidity(self) -> bool: ...
+    def reportValidity(self) -> bool: ...
+class HTMLInputElement(HTMLElement):
+    @classmethod
+    def new(self) -> HTMLInputElement: ...
+    webkitdirectory: bool
+    webkitEntries: Sequence[FileSystemEntry]
+    capture: str
+    accept: str
+    alt: str
+    autocomplete: str
+    defaultChecked: bool
+    checked: bool
+    dirName: str
+    disabled: bool
+    form: HTMLFormElement | None
+    files: FileList | None
+    formAction: USVString
+    formEnctype: str
+    formMethod: str
+    formNoValidate: bool
+    formTarget: str
+    height: int
+    indeterminate: bool
+    list: HTMLDataListElement | None
+    max: str
+    maxLength: int
+    min: str
+    minLength: int
+    multiple: bool
+    name: str
+    pattern: str
+    placeholder: str
+    readOnly: bool
+    required: bool
+    size: int
+    src: USVString
+    step: str
+    type: str
+    defaultValue: str
+    value: str
+    valueAsDate: object | None
+    valueAsNumber: float
+    width: int
+    def stepUp(self, n: int | None = 1) -> None: ...
+    def stepDown(self, n: int | None = 1) -> None: ...
+    willValidate: bool
+    validity: ValidityState
+    validationMessage: str
+    def checkValidity(self) -> bool: ...
+    def reportValidity(self) -> bool: ...
+    def setCustomValidity(self, error: str) -> None: ...
+    labels: NodeList | None
+    def select(self) -> None: ...
+    selectionStart: int | None
+    selectionEnd: int | None
+    selectionDirection: str | None
+    @overload
+    def setRangeText(self, replacement: str) -> None: ...
+    @overload
+    def setRangeText(self, replacement: str, start: int, end: int, selectionMode: SelectionMode | None = "preserve") -> None: ...
+    def setSelectionRange(self, start: int, end: int, direction: str | None = None) -> None: ...
+    def showPicker(self) -> None: ...
+    align: str
+    useMap: str
+class HTMLTextAreaElement(HTMLElement):
+    @classmethod
+    def new(self) -> HTMLTextAreaElement: ...
+    autocomplete: str
+    cols: int
+    dirName: str
+    disabled: bool
+    form: HTMLFormElement | None
+    maxLength: int
+    minLength: int
+    name: str
+    placeholder: str
+    readOnly: bool
+    required: bool
+    rows: int
+    wrap: str
+    type: str
+    defaultValue: str
+    value: str
+    textLength: int
+    willValidate: bool
+    validity: ValidityState
+    validationMessage: str
+    def checkValidity(self) -> bool: ...
+    def reportValidity(self) -> bool: ...
+    def setCustomValidity(self, error: str) -> None: ...
+    labels: NodeList
+    def select(self) -> None: ...
+    selectionStart: int
+    selectionEnd: int
+    selectionDirection: str
+    @overload
+    def setRangeText(self, replacement: str) -> None: ...
+    @overload
+    def setRangeText(self, replacement: str, start: int, end: int, selectionMode: SelectionMode | None = "preserve") -> None: ...
+    def setSelectionRange(self, start: int, end: int, direction: str | None = None) -> None: ...
+class HTMLSelectElement(HTMLElement):
+    @classmethod
+    def new(self) -> HTMLSelectElement: ...
+    autocomplete: str
+    disabled: bool
+    form: HTMLFormElement | None
+    multiple: bool
+    name: str
+    required: bool
+    size: int
+    type: str
+    options: HTMLOptionsCollection
+    length: int
+    def namedItem(self, name: str) -> HTMLOptionElement | None: ...
+    def add(self, element: HTMLOptionElement | HTMLOptGroupElement, before: HTMLElement | int | None = None) -> None: ...
+    @overload
+    def remove(self) -> None: ...
+    @overload
+    def remove(self, index: int) -> None: ...
+    selectedOptions: HTMLCollection
+    selectedIndex: int
+    value: str
+    willValidate: bool
+    validity: ValidityState
+    validationMessage: str
+    def checkValidity(self) -> bool: ...
+    def reportValidity(self) -> bool: ...
+    def setCustomValidity(self, error: str) -> None: ...
+    labels: NodeList
+class HTMLOptionElement(HTMLElement):
+    @classmethod
+    def new(self) -> HTMLOptionElement: ...
+    """ # GIgnoredStmt
+    LegacyFactoryFunction=Option(optional DOMString text = "", optional DOMString value, optional boolean defaultSelected = False, optional boolean selected = False)
+    """
+    disabled: bool
+    form: HTMLFormElement | None
+    label: str
+    defaultSelected: bool
+    selected: bool
+    value: str
+    text: str
+    index: int
+class HTMLOptGroupElement(HTMLElement):
+    @classmethod
+    def new(self) -> HTMLOptGroupElement: ...
+    disabled: bool
+    label: str
+class HTMLButtonElement(HTMLElement):
+    @classmethod
+    def new(self) -> HTMLButtonElement: ...
+    disabled: bool
+    form: HTMLFormElement | None
+    formAction: USVString
+    formEnctype: str
+    formMethod: str
+    formNoValidate: bool
+    formTarget: str
+    name: str
+    type: str
+    value: str
+    willValidate: bool
+    validity: ValidityState
+    validationMessage: str
+    def checkValidity(self) -> bool: ...
+    def reportValidity(self) -> bool: ...
+    def setCustomValidity(self, error: str) -> None: ...
+    labels: NodeList
+class HTMLAnchorElement(HTMLElement, HTMLAttributionSrcElementUtils, HTMLHyperlinkElementUtils):
+    @classmethod
+    def new(self) -> HTMLAnchorElement: ...
+    target: str
+    download: str
+    ping: USVString
+    rel: str
+    relList: DOMTokenList
+    hreflang: str
+    type: str
+    text: str
+    referrerPolicy: str
+    coords: str
+    charset: str
+    name: str
+    rev: str
+    shape: str
+    attributionSourceId: int
+class HTMLImageElement(HTMLElement, HTMLAttributionSrcElementUtils):
+    @classmethod
+    def new(self) -> HTMLImageElement: ...
+    x: int
+    y: int
+    """ # GIgnoredStmt
+    LegacyFactoryFunction=Image(optional unsigned long width, optional unsigned long height)
+    """
+    alt: str
+    src: USVString
+    srcset: USVString
+    sizes: str
+    crossOrigin: str | None
+    useMap: str
+    isMap: bool
+    width: int
+    height: int
+    naturalWidth: int
+    naturalHeight: int
+    complete: bool
+    currentSrc: USVString
+    referrerPolicy: str
+    decoding: str
+    loading: str
+    def decode(self) -> Awaitable[None]: ...
+    name: str
+    lowsrc: USVString
+    align: str
+    hspace: int
+    vspace: int
+    longDesc: USVString
+    border: str
+    fetchPriority: str
+class HTMLCanvasElement(HTMLElement):
+    @classmethod
+    def new(self) -> HTMLCanvasElement: ...
+    width: int
+    height: int
+    def getContext(self, contextId: str, options: Any | None = None) -> RenderingContext | None: ...
+    def toDataURL(self, type: str | None = "image/png", quality: Any | None = None) -> USVString: ...
+    def toBlob(self, callback: BlobCallback, type: str | None = "image/png", quality: Any | None = None) -> None: ...
+    def transferControlToOffscreen(self) -> OffscreenCanvas: ...
+    def captureStream(self, frameRequestRate: float | None = None) -> MediaStream: ...
+class HTMLVideoElement(HTMLMediaElement):
+    @classmethod
+    def new(self) -> HTMLVideoElement: ...
+    width: int
+    height: int
+    videoWidth: int
+    videoHeight: int
+    poster: USVString
+    playsInline: bool
+    def getVideoPlaybackQuality(self) -> VideoPlaybackQuality: ...
+    def requestPictureInPicture(self) -> Awaitable[PictureInPictureWindow]: ...
+    onenterpictureinpicture: EventHandler
+    onleavepictureinpicture: EventHandler
+    disablePictureInPicture: bool
+    def requestVideoFrameCallback(self, callback: VideoFrameRequestCallback) -> int: ...
+    def cancelVideoFrameCallback(self, handle: int) -> None: ...
+class HTMLAudioElement(HTMLMediaElement):
+    @classmethod
+    def new(self) -> HTMLAudioElement: ...
+    """ # GIgnoredStmt
+    LegacyFactoryFunction=Audio(optional DOMString src)
+    """
+class HTMLSourceElement(HTMLElement):
+    @classmethod
+    def new(self) -> HTMLSourceElement: ...
+    src: USVString
+    type: str
+    srcset: USVString
+    sizes: str
+    media: str
+    width: int
+    height: int
+class HTMLMediaElement(HTMLElement):
+    sinkId: str
+    def setSinkId(self, sinkId: str) -> Awaitable[None]: ...
+    mediaKeys: MediaKeys | None
+    onencrypted: EventHandler
+    onwaitingforkey: EventHandler
+    def setMediaKeys(self, mediaKeys: MediaKeys | None) -> Awaitable[None]: ...
+    error: MediaError | None
+    src: USVString
+    srcObject: MediaProvider | None
+    currentSrc: USVString
+    crossOrigin: str | None
+    NETWORK_EMPTY = 0
+    NETWORK_IDLE = 1
+    NETWORK_LOADING = 2
+    NETWORK_NO_SOURCE = 3
+    networkState: int
+    preload: str
+    buffered: TimeRanges
+    def load(self) -> None: ...
+    def canPlayType(self, type: str) -> CanPlayTypeResult: ...
+    HAVE_NOTHING = 0
+    HAVE_METADATA = 1
+    HAVE_CURRENT_DATA = 2
+    HAVE_FUTURE_DATA = 3
+    HAVE_ENOUGH_DATA = 4
+    readyState: int
+    seeking: bool
+    currentTime: float
+    def fastSeek(self, time: float) -> None: ...
+    duration: float
+    def getStartDate(self) -> object: ...
+    paused: bool
+    defaultPlaybackRate: float
+    playbackRate: float
+    preservesPitch: bool
+    played: TimeRanges
+    seekable: TimeRanges
+    ended: bool
+    autoplay: bool
+    loop: bool
+    def play(self) -> Awaitable[None]: ...
+    def pause(self) -> None: ...
+    controls: bool
+    volume: float
+    muted: bool
+    defaultMuted: bool
+    audioTracks: AudioTrackList
+    videoTracks: VideoTrackList
+    textTracks: TextTrackList
+    def addTextTrack(self, kind: TextTrackKind, label: str | None = "", language: str | None = "") -> TextTrack: ...
+    def captureStream(self) -> MediaStream: ...
+    remote: RemotePlayback
+    disableRemotePlayback: bool
+class HTMLIFrameElement(HTMLElement):
+    @classmethod
+    def new(self) -> HTMLIFrameElement: ...
+    csp: str
+    src: USVString
+    srcdoc: str
+    name: str
+    sandbox: DOMTokenList
+    allow: str
+    allowFullscreen: bool
+    width: str
+    height: str
+    referrerPolicy: str
+    loading: str
+    contentDocument: Document | None
+    contentWindow: WindowProxy | None
+    def getSVGDocument(self) -> Document | None: ...
+    align: str
+    scrolling: str
+    frameBorder: str
+    longDesc: USVString
+    marginHeight: str
+    marginWidth: str
+    permissionsPolicy: PermissionsPolicy
+    fetchPriority: str
+class HTMLScriptElement(HTMLElement, HTMLAttributionSrcElementUtils):
+    @classmethod
+    def new(self) -> HTMLScriptElement: ...
+    src: USVString
+    type: str
+    noModule: bool
+    async_: bool
+    defer: bool
+    crossOrigin: str | None
+    text: str
+    integrity: str
+    referrerPolicy: str
+    blocking: DOMTokenList
+    charset: str
+    event: str
+    htmlFor: str
+    fetchPriority: str
+class HTMLStyleElement(HTMLElement, LinkStyle):
+    @classmethod
+    def new(self) -> HTMLStyleElement: ...
+    disabled: bool
+    media: str
+    blocking: DOMTokenList
+    type: str
+class HTMLLinkElement(HTMLElement, LinkStyle):
+    @classmethod
+    def new(self) -> HTMLLinkElement: ...
+    href: USVString
+    crossOrigin: str | None
+    rel: str
+    relList: DOMTokenList
+    media: str
+    integrity: str
+    hreflang: str
+    type: str
+    sizes: DOMTokenList
+    imageSrcset: USVString
+    imageSizes: str
+    referrerPolicy: str
+    blocking: DOMTokenList
+    disabled: bool
+    charset: str
+    rev: str
+    target: str
+    fetchPriority: str
+class HTMLMetaElement(HTMLElement):
+    @classmethod
+    def new(self) -> HTMLMetaElement: ...
+    name: str
+    httpEquiv: str
+    content: str
+    media: str
+    scheme: str
+class HTMLTemplateElement(HTMLElement):
+    @classmethod
+    def new(self) -> HTMLTemplateElement: ...
+    content: DocumentFragment
+class HTMLDialogElement(HTMLElement):
+    @classmethod
+    def new(self) -> HTMLDialogElement: ...
+    open: bool
+    returnValue: str
+    def show(self) -> None: ...
+    def showModal(self) -> None: ...
+    def close(self, returnValue: str | None = None) -> None: ...
+class Window(EventTarget, GlobalEventHandlers, WindowEventHandlers, WindowOrWorkerGlobalScope, AnimationFrameProvider, WindowSessionStorage, WindowLocalStorage):
+    orientation: short
+    onorientationchange: EventHandler
+    cookieStore: CookieStore
+    def navigate(self, dir: SpatialNavigationDirection) -> None: ...
+    def matchMedia(self, query: CSSOMString) -> MediaQueryList: ...
+    screen: Screen
+    visualViewport: VisualViewport | None
+    def moveTo(self, x: int, y: int) -> None: ...
+    def moveBy(self, x: int, y: int) -> None: ...
+    def resizeTo(self, width: int, height: int) -> None: ...
+    def resizeBy(self, x: int, y: int) -> None: ...
+    innerWidth: int
+    innerHeight: int
+    scrollX: float
+    pageXOffset: float
+    scrollY: float
+    pageYOffset: float
+    @overload
+    def scroll(self, options: ScrollToOptions | None = {}) -> None: ...
+    @overload
+    def scroll(self, x: float, y: float) -> None: ...
+    @overload
+    def scrollTo(self, options: ScrollToOptions | None = {}) -> None: ...
+    @overload
+    def scrollTo(self, x: float, y: float) -> None: ...
+    @overload
+    def scrollBy(self, options: ScrollToOptions | None = {}) -> None: ...
+    @overload
+    def scrollBy(self, x: float, y: float) -> None: ...
+    screenX: int
+    screenLeft: int
+    screenY: int
+    screenTop: int
+    outerWidth: int
+    outerHeight: int
+    devicePixelRatio: float
+    def getComputedStyle(self, elt: Element, pseudoElt: CSSOMString | None = None) -> CSSStyleDeclaration: ...
+    def getDigitalGoodsService(self, serviceProvider: str) -> Awaitable[DigitalGoodsService]: ...
+    event: Event | None
+    def showOpenFilePicker(self, options: OpenFilePickerOptions | None = {}) -> Awaitable[Sequence[FileSystemFileHandle]]: ...
+    def showSaveFilePicker(self, options: SaveFilePickerOptions | None = {}) -> Awaitable[FileSystemFileHandle]: ...
+    def showDirectoryPicker(self, options: DirectoryPickerOptions | None = {}) -> Awaitable[FileSystemDirectoryHandle]: ...
+    window: WindowProxy
+    self: WindowProxy
+    document: Document
+    name: str
+    location: Location
+    history: History
+    customElements: CustomElementRegistry
+    locationbar: BarProp
+    menubar: BarProp
+    personalbar: BarProp
+    scrollbars: BarProp
+    statusbar: BarProp
+    toolbar: BarProp
+    status: str
+    def close(self) -> None: ...
+    closed: bool
+    def stop(self) -> None: ...
+    def focus(self) -> None: ...
+    def blur(self) -> None: ...
+    frames: WindowProxy
+    length: int
+    top: WindowProxy | None
+    opener: Any
+    parent: WindowProxy | None
+    frameElement: Element | None
+    def open(self, url: USVString | None = "", target: str | None = "_blank", features: str | None = "") -> WindowProxy | None: ...
+    navigator: Navigator
+    clientInformation: Navigator
+    originAgentCluster: bool
+    @overload
+    def alert(self) -> None: ...
+    @overload
+    def alert(self, message: str) -> None: ...
+    def confirm(self, message: str | None = "") -> bool: ...
+    def prompt(self, message: str | None = "", default: str | None = "") -> str | None: ...
+    def print(self) -> None: ...
+    @overload
+    def postMessage(self, message: Any, targetOrigin: USVString, transfer: Sequence[object] | None = []) -> None: ...
+    @overload
+    def postMessage(self, message: Any, options: WindowPostMessageOptions | None = {}) -> None: ...
+    def captureEvents(self) -> None: ...
+    def releaseEvents(self) -> None: ...
+    external: External
+    def queryLocalFonts(self, options: QueryOptions | None = {}) -> Awaitable[Sequence[FontData]]: ...
+    onappinstalled: EventHandler
+    onbeforeinstallprompt: EventHandler
+    navigation: Navigation
+    ondeviceorientation: EventHandler
+    ondeviceorientationabsolute: EventHandler
+    oncompassneedscalibration: EventHandler
+    ondevicemotion: EventHandler
+    portalHost: PortalHost | None
+    def requestIdleCallback(self, callback: IdleRequestCallback, options: IdleRequestOptions | None = {}) -> int: ...
+    def cancelIdleCallback(self, handle: int) -> None: ...
+    def getSelection(self) -> Selection | None: ...
+    speechSynthesis: SpeechSynthesis
+    launchQueue: LaunchQueue
+    def getScreenDetails(self) -> Awaitable[ScreenDetails]: ...
+class Location:
+    href: USVString
+    origin: USVString
+    protocol: USVString
+    host: USVString
+    hostname: USVString
+    port: USVString
+    pathname: USVString
+    search: USVString
+    hash: USVString
+    def assign(self, url: USVString) -> None: ...
+    def replace(self, url: USVString) -> None: ...
+    def reload(self) -> None: ...
+    ancestorOrigins: DOMStringList
+class History:
+    length: int
+    scrollRestoration: ScrollRestoration
+    state: Any
+    def go(self, delta: int | None = 0) -> None: ...
+    def back(self) -> None: ...
+    def forward(self) -> None: ...
+    def pushState(self, data: Any, unused: str, url: USVString | None = None) -> None: ...
+    def replaceState(self, data: Any, unused: str, url: USVString | None = None) -> None: ...
+class Navigator(NavigatorBadge, NavigatorDeviceMemory, NavigatorID, NavigatorLanguage, NavigatorOnLine, NavigatorContentUtils, NavigatorCookies, NavigatorPlugins, NavigatorConcurrentHardware, NavigatorNetworkInformation, NavigatorStorage, NavigatorUA, NavigatorLocks, NavigatorAutomationInformation, NavigatorGPU, NavigatorML):
+    @overload
+    def getAutoplayPolicy(self, type: AutoplayPolicyMediaType) -> AutoplayPolicy: ...
+    @overload
+    def getAutoplayPolicy(self, element: HTMLMediaElement) -> AutoplayPolicy: ...
+    @overload
+    def getAutoplayPolicy(self, context: AudioContext) -> AutoplayPolicy: ...
+    def setClientBadge(self, contents: int | None = None) -> Awaitable[None]: ...
+    def clearClientBadge(self) -> Awaitable[None]: ...
+    def getBattery(self) -> Awaitable[BatteryManager]: ...
+    def sendBeacon(self, url: USVString, data: BodyInit | None = None) -> bool: ...
+    clipboard: Clipboard
+    contacts: ContactsManager
+    credentials: CredentialsContainer
+    devicePosture: DevicePosture
+    def requestMediaKeySystemAccess(self, keySystem: str, supportedConfigurations: Sequence[MediaKeySystemConfiguration]) -> Awaitable[MediaKeySystemAccess]: ...
+    epubReadingSystem: EpubReadingSystem
+    def getGamepads(self) -> Sequence[Gamepad | None]: ...
+    geolocation: Geolocation
+    def getInstalledRelatedApps(self) -> Awaitable[Sequence[RelatedApplication]]: ...
+    userActivation: UserActivation
+    ink: Ink
+    scheduling: Scheduling
+    keyboard: Keyboard
+    mediaCapabilities: MediaCapabilities
+    mediaDevices: MediaDevices
+    def getUserMedia(self, constraints: MediaStreamConstraints, successCallback: NavigatorUserMediaSuccessCallback, errorCallback: NavigatorUserMediaErrorCallback) -> None: ...
+    mediaSession: MediaSession
+    permissions: Permissions
+    maxTouchPoints: int
+    presentation: Presentation
+    wakeLock: WakeLock
+    serial: Serial
+    serviceWorker: ServiceWorkerContainer
+    def vibrate(self, pattern: VibratePattern) -> bool: ...
+    virtualKeyboard: VirtualKeyboard
+    bluetooth: Bluetooth
+    def share(self, data: ShareData | None = {}) -> Awaitable[None]: ...
+    def canShare(self, data: ShareData | None = {}) -> bool: ...
+    hid: HID
+    def requestMIDIAccess(self, options: MIDIOptions | None = {}) -> Awaitable[MIDIAccess]: ...
+    usb: USB
+    xr: XRSystem
+    windowControlsOverlay: WindowControlsOverlay
+class Storage:
+    length: int
+    def key(self, index: int) -> str | None: ...
+    def clear(self) -> None: ...
+class ConsoleNamespace:
+    def assert_(self, condition: bool | None = False, *data: Any) -> None: ...
+    def clear(self) -> None: ...
+    def debug(self, *data: Any) -> None: ...
+    def error(self, *data: Any) -> None: ...
+    def info(self, *data: Any) -> None: ...
+    def log(self, *data: Any) -> None: ...
+    def table(self, tabularData: Any | None = None, properties: Sequence[str] | None = None) -> None: ...
+    def trace(self, *data: Any) -> None: ...
+    def warn(self, *data: Any) -> None: ...
+    def dir(self, item: Any | None = None, options: object | None = None) -> None: ...
+    def dirxml(self, *data: Any) -> None: ...
+    def count(self, label: str | None = "default") -> None: ...
+    def countReset(self, label: str | None = "default") -> None: ...
+    def group(self, *data: Any) -> None: ...
+    def groupCollapsed(self, *data: Any) -> None: ...
+    def groupEnd(self) -> None: ...
+    def time(self, label: str | None = "default") -> None: ...
+    def timeLog(self, label: str | None = "default", *data: Any) -> None: ...
+    def timeEnd(self, label: str | None = "default") -> None: ...
+class Clipboard(EventTarget):
+    def read(self) -> Awaitable[ClipboardItems]: ...
+    def readText(self) -> Awaitable[str]: ...
+    def write(self, data: ClipboardItems) -> Awaitable[None]: ...
+    def writeText(self, data: str) -> Awaitable[None]: ...
+class Geolocation:
+    def getCurrentPosition(self, successCallback: PositionCallback, errorCallback: PositionErrorCallback | None = None, options: PositionOptions | None = {}) -> None: ...
+    def watchPosition(self, successCallback: PositionCallback, errorCallback: PositionErrorCallback | None = None, options: PositionOptions | None = {}) -> int: ...
+    def clearWatch(self, watchId: int) -> None: ...
+class Screen:
+    availWidth: int
+    availHeight: int
+    width: int
+    height: int
+    colorDepth: int
+    pixelDepth: int
+    orientation: ScreenOrientation
+    isExtended: bool
+    onchange: EventHandler
+class CSSStyleDeclaration:
+    cssText: CSSOMString
+    length: int
+    def getPropertyValue(self, property: CSSOMString) -> CSSOMString: ...
+    def getPropertyPriority(self, property: CSSOMString) -> CSSOMString: ...
+    def setProperty(self, property: CSSOMString, value: CSSOMString, priority: CSSOMString | None = "") -> None: ...
+    def removeProperty(self, property: CSSOMString) -> CSSOMString: ...
+    parentRule: CSSRule | None
+    cssFloat: CSSOMString
+    accentColor: str
+    additiveSymbols: str
+    alignContent: str
+    alignItems: str
+    alignSelf: str
+    alignmentBaseline: str
+    all: str
+    animation: str
+    animationComposition: str
+    animationDelay: str
+    animationDirection: str
+    animationDuration: str
+    animationFillMode: str
+    animationIterationCount: str
+    animationName: str
+    animationPlayState: str
+    animationTimingFunction: str
+    appRegion: str
+    appearance: str
+    ascentOverride: str
+    aspectRatio: str
+    backdropFilter: str
+    backfaceVisibility: str
+    background: str
+    backgroundAttachment: str
+    backgroundBlendMode: str
+    backgroundClip: str
+    backgroundColor: str
+    backgroundImage: str
+    backgroundOrigin: str
+    backgroundPosition: str
+    backgroundPositionX: str
+    backgroundPositionY: str
+    backgroundRepeat: str
+    backgroundRepeatX: str
+    backgroundRepeatY: str
+    backgroundSize: str
+    basePalette: str
+    baselineShift: str
+    baselineSource: str
+    blockSize: str
+    border: str
+    borderBlock: str
+    borderBlockColor: str
+    borderBlockEnd: str
+    borderBlockEndColor: str
+    borderBlockEndStyle: str
+    borderBlockEndWidth: str
+    borderBlockStart: str
+    borderBlockStartColor: str
+    borderBlockStartStyle: str
+    borderBlockStartWidth: str
+    borderBlockStyle: str
+    borderBlockWidth: str
+    borderBottom: str
+    borderBottomColor: str
+    borderBottomLeftRadius: str
+    borderBottomRightRadius: str
+    borderBottomStyle: str
+    borderBottomWidth: str
+    borderCollapse: str
+    borderColor: str
+    borderEndEndRadius: str
+    borderEndStartRadius: str
+    borderImage: str
+    borderImageOutset: str
+    borderImageRepeat: str
+    borderImageSlice: str
+    borderImageSource: str
+    borderImageWidth: str
+    borderInline: str
+    borderInlineColor: str
+    borderInlineEnd: str
+    borderInlineEndColor: str
+    borderInlineEndStyle: str
+    borderInlineEndWidth: str
+    borderInlineStart: str
+    borderInlineStartColor: str
+    borderInlineStartStyle: str
+    borderInlineStartWidth: str
+    borderInlineStyle: str
+    borderInlineWidth: str
+    borderLeft: str
+    borderLeftColor: str
+    borderLeftStyle: str
+    borderLeftWidth: str
+    borderRadius: str
+    borderRight: str
+    borderRightColor: str
+    borderRightStyle: str
+    borderRightWidth: str
+    borderSpacing: str
+    borderStartEndRadius: str
+    borderStartStartRadius: str
+    borderStyle: str
+    borderTop: str
+    borderTopColor: str
+    borderTopLeftRadius: str
+    borderTopRightRadius: str
+    borderTopStyle: str
+    borderTopWidth: str
+    borderWidth: str
+    bottom: str
+    boxShadow: str
+    boxSizing: str
+    breakAfter: str
+    breakBefore: str
+    breakInside: str
+    bufferedRendering: str
+    captionSide: str
+    caretColor: str
+    clear: str
+    clip: str
+    clipPath: str
+    clipRule: str
+    color: str
+    colorInterpolation: str
+    colorInterpolationFilters: str
+    colorRendering: str
+    colorScheme: str
+    columnCount: str
+    columnFill: str
+    columnGap: str
+    columnRule: str
+    columnRuleColor: str
+    columnRuleStyle: str
+    columnRuleWidth: str
+    columnSpan: str
+    columnWidth: str
+    columns: str
+    contain: str
+    containIntrinsicBlockSize: str
+    containIntrinsicHeight: str
+    containIntrinsicInlineSize: str
+    containIntrinsicSize: str
+    containIntrinsicWidth: str
+    container: str
+    containerName: str
+    containerType: str
+    content: str
+    contentVisibility: str
+    counterIncrement: str
+    counterReset: str
+    counterSet: str
+    cursor: str
+    cx: str
+    cy: str
+    descentOverride: str
+    direction: str
+    display: str
+    dominantBaseline: str
+    emptyCells: str
+    fallback: str
+    fill: str
+    fillOpacity: str
+    fillRule: str
+    filter: str
+    flex: str
+    flexBasis: str
+    flexDirection: str
+    flexFlow: str
+    flexGrow: str
+    flexShrink: str
+    flexWrap: str
+    floodColor: str
+    floodOpacity: str
+    font: str
+    fontDisplay: str
+    fontFamily: str
+    fontFeatureSettings: str
+    fontKerning: str
+    fontOpticalSizing: str
+    fontPalette: str
+    fontSize: str
+    fontStretch: str
+    fontStyle: str
+    fontSynthesis: str
+    fontSynthesisSmallCaps: str
+    fontSynthesisStyle: str
+    fontSynthesisWeight: str
+    fontVariant: str
+    fontVariantAlternates: str
+    fontVariantCaps: str
+    fontVariantEastAsian: str
+    fontVariantLigatures: str
+    fontVariantNumeric: str
+    fontVariationSettings: str
+    fontWeight: str
+    forcedColorAdjust: str
+    gap: str
+    grid: str
+    gridArea: str
+    gridAutoColumns: str
+    gridAutoFlow: str
+    gridAutoRows: str
+    gridColumn: str
+    gridColumnEnd: str
+    gridColumnGap: str
+    gridColumnStart: str
+    gridGap: str
+    gridRow: str
+    gridRowEnd: str
+    gridRowGap: str
+    gridRowStart: str
+    gridTemplate: str
+    gridTemplateAreas: str
+    gridTemplateColumns: str
+    gridTemplateRows: str
+    height: str
+    hyphenateCharacter: str
+    hyphenateLimitChars: str
+    hyphens: str
+    imageOrientation: str
+    imageRendering: str
+    inherits: str
+    initialLetter: str
+    initialValue: str
+    inlineSize: str
+    inset: str
+    insetBlock: str
+    insetBlockEnd: str
+    insetBlockStart: str
+    insetInline: str
+    insetInlineEnd: str
+    insetInlineStart: str
+    isolation: str
+    justifyContent: str
+    justifyItems: str
+    justifySelf: str
+    left: str
+    letterSpacing: str
+    lightingColor: str
+    lineBreak: str
+    lineGapOverride: str
+    lineHeight: str
+    listStyle: str
+    listStyleImage: str
+    listStylePosition: str
+    listStyleType: str
+    margin: str
+    marginBlock: str
+    marginBlockEnd: str
+    marginBlockStart: str
+    marginBottom: str
+    marginInline: str
+    marginInlineEnd: str
+    marginInlineStart: str
+    marginLeft: str
+    marginRight: str
+    marginTop: str
+    marker: str
+    markerEnd: str
+    markerMid: str
+    markerStart: str
+    mask: str
+    maskType: str
+    mathDepth: str
+    mathShift: str
+    mathStyle: str
+    maxBlockSize: str
+    maxHeight: str
+    maxInlineSize: str
+    maxWidth: str
+    minBlockSize: str
+    minHeight: str
+    minInlineSize: str
+    minWidth: str
+    mixBlendMode: str
+    negative: str
+    objectFit: str
+    objectPosition: str
+    objectViewBox: str
+    offset: str
+    offsetDistance: str
+    offsetPath: str
+    offsetRotate: str
+    opacity: str
+    order: str
+    orphans: str
+    outline: str
+    outlineColor: str
+    outlineOffset: str
+    outlineStyle: str
+    outlineWidth: str
+    overflow: str
+    overflowAnchor: str
+    overflowClipMargin: str
+    overflowWrap: str
+    overflowX: str
+    overflowY: str
+    overrideColors: str
+    overscrollBehavior: str
+    overscrollBehaviorBlock: str
+    overscrollBehaviorInline: str
+    overscrollBehaviorX: str
+    overscrollBehaviorY: str
+    pad: str
+    padding: str
+    paddingBlock: str
+    paddingBlockEnd: str
+    paddingBlockStart: str
+    paddingBottom: str
+    paddingInline: str
+    paddingInlineEnd: str
+    paddingInlineStart: str
+    paddingLeft: str
+    paddingRight: str
+    paddingTop: str
+    page: str
+    pageBreakAfter: str
+    pageBreakBefore: str
+    pageBreakInside: str
+    pageOrientation: str
+    paintOrder: str
+    perspective: str
+    perspectiveOrigin: str
+    placeContent: str
+    placeItems: str
+    placeSelf: str
+    pointerEvents: str
+    position: str
+    prefix: str
+    quotes: str
+    range: str
+    resize: str
+    right: str
+    rotate: str
+    rowGap: str
+    rubyPosition: str
+    rx: str
+    ry: str
+    scale: str
+    scrollBehavior: str
+    scrollMargin: str
+    scrollMarginBlock: str
+    scrollMarginBlockEnd: str
+    scrollMarginBlockStart: str
+    scrollMarginBottom: str
+    scrollMarginInline: str
+    scrollMarginInlineEnd: str
+    scrollMarginInlineStart: str
+    scrollMarginLeft: str
+    scrollMarginRight: str
+    scrollMarginTop: str
+    scrollPadding: str
+    scrollPaddingBlock: str
+    scrollPaddingBlockEnd: str
+    scrollPaddingBlockStart: str
+    scrollPaddingBottom: str
+    scrollPaddingInline: str
+    scrollPaddingInlineEnd: str
+    scrollPaddingInlineStart: str
+    scrollPaddingLeft: str
+    scrollPaddingRight: str
+    scrollPaddingTop: str
+    scrollSnapAlign: str
+    scrollSnapStop: str
+    scrollSnapType: str
+    scrollbarGutter: str
+    shapeImageThreshold: str
+    shapeMargin: str
+    shapeOutside: str
+    shapeRendering: str
+    size: str
+    sizeAdjust: str
+    speak: str
+    speakAs: str
+    src: str
+    stopColor: str
+    stopOpacity: str
+    stroke: str
+    strokeDasharray: str
+    strokeDashoffset: str
+    strokeLinecap: str
+    strokeLinejoin: str
+    strokeMiterlimit: str
+    strokeOpacity: str
+    strokeWidth: str
+    suffix: str
+    symbols: str
+    syntax: str
+    system: str
+    tabSize: str
+    tableLayout: str
+    textAlign: str
+    textAlignLast: str
+    textAnchor: str
+    textCombineUpright: str
+    textDecoration: str
+    textDecorationColor: str
+    textDecorationLine: str
+    textDecorationSkipInk: str
+    textDecorationStyle: str
+    textDecorationThickness: str
+    textEmphasis: str
+    textEmphasisColor: str
+    textEmphasisPosition: str
+    textEmphasisStyle: str
+    textIndent: str
+    textOrientation: str
+    textOverflow: str
+    textRendering: str
+    textShadow: str
+    textSizeAdjust: str
+    textTransform: str
+    textUnderlineOffset: str
+    textUnderlinePosition: str
+    top: str
+    touchAction: str
+    transform: str
+    transformBox: str
+    transformOrigin: str
+    transformStyle: str
+    transition: str
+    transitionDelay: str
+    transitionDuration: str
+    transitionProperty: str
+    transitionTimingFunction: str
+    translate: str
+    unicodeBidi: str
+    unicodeRange: str
+    userSelect: str
+    vectorEffect: str
+    verticalAlign: str
+    viewTransitionName: str
+    visibility: str
+    whiteSpace: str
+    widows: str
+    width: str
+    willChange: str
+    wordBreak: str
+    wordSpacing: str
+    wordWrap: str
+    writingMode: str
+    zIndex: str
+    zoom: str
+class CSSStyleSheet(StyleSheet):
+    @classmethod
+    def new(self, options: CSSStyleSheetInit | None = {}) -> CSSStyleSheet: ...
+    ownerRule: CSSRule | None
+    cssRules: CSSRuleList
+    def insertRule(self, rule: CSSOMString, index: int | None = 0) -> int: ...
+    def deleteRule(self, index: int) -> None: ...
+    def replace(self, text: USVString) -> Awaitable[CSSStyleSheet]: ...
+    def replaceSync(self, text: USVString) -> None: ...
+    rules: CSSRuleList
+    def addRule(self, selector: str | None = "undefined", style: str | None = "undefined", index: int | None = None) -> int: ...
+    def removeRule(self, index: int | None = 0) -> None: ...
+class StyleSheet:
+    type: CSSOMString
+    href: USVString | None
+    ownerNode: Element | ProcessingInstruction | None
+    parentStyleSheet: CSSStyleSheet | None
+    title: str | None
+    media: MediaList
+    disabled: bool
+class MediaQueryList(EventTarget):
+    media: CSSOMString
+    matches: bool
+    def addListener(self, callback: EventListener | None) -> None: ...
+    def removeListener(self, callback: EventListener | None) -> None: ...
+    onchange: EventHandler
+class File(Blob):
+    @classmethod
+    def new(self, fileBits: Sequence[BlobPart], fileName: USVString, options: FilePropertyBag | None = {}) -> File: ...
+    name: str
+    lastModified: int
+    webkitRelativePath: USVString
+class FileList:
+    length: int
+class Blob:
+    @classmethod
+    def new(self, blobParts: Sequence[BlobPart] | None = None, options: BlobPropertyBag | None = {}) -> Blob: ...
+    size: int
+    type: str
+    def slice(self, start: int | None = None, end: int | None = None, contentType: str | None = None) -> Blob: ...
+    def stream(self) -> ReadableStream: ...
+    def text(self) -> Awaitable[USVString]: ...
+    def arrayBuffer(self) -> Awaitable[ArrayBuffer]: ...
+class FileReader(EventTarget):
+    @classmethod
+    def new(self) -> FileReader: ...
+    def readAsArrayBuffer(self, blob: Blob) -> None: ...
+    def readAsBinaryString(self, blob: Blob) -> None: ...
+    def readAsText(self, blob: Blob, encoding: str | None = None) -> None: ...
+    def readAsDataURL(self, blob: Blob) -> None: ...
+    def abort(self) -> None: ...
+    EMPTY = 0
+    LOADING = 1
+    DONE = 2
+    readyState: int
+    result: str | ArrayBuffer | None
+    error: DOMException | None
+    onloadstart: EventHandler
+    onprogress: EventHandler
+    onload: EventHandler
+    onabort: EventHandler
+    onerror: EventHandler
+    onloadend: EventHandler
+class DataTransfer:
+    @classmethod
+    def new(self) -> DataTransfer: ...
+    dropEffect: str
+    effectAllowed: str
+    items: DataTransferItemList
+    def setDragImage(self, image: Element, x: int, y: int) -> None: ...
+    types: Sequence[str]
+    def getData(self, format: str) -> str: ...
+    def setData(self, format: str, data: str) -> None: ...
+    def clearData(self, format: str | None = None) -> None: ...
+    files: FileList
+class DataTransferItem:
+    def webkitGetAsEntry(self) -> FileSystemEntry | None: ...
+    def getAsFileSystemHandle(self) -> Awaitable[FileSystemHandle | None]: ...
+    kind: str
+    type: str
+    def getAsString(self, callback: FunctionStringCallback | None) -> None: ...
+    def getAsFile(self) -> File | None: ...
+class DataTransferItemList:
+    length: int
+    @overload
+    def add(self, data: str, type: str) -> DataTransferItem | None: ...
+    @overload
+    def add(self, data: File) -> DataTransferItem | None: ...
+    def remove(self, index: int) -> None: ...
+    def clear(self) -> None: ...
+class Range(AbstractRange):
+    @classmethod
+    def new(self) -> Range: ...
+    def createContextualFragment(self, fragment: str) -> DocumentFragment: ...
+    def getClientRects(self) -> DOMRectList: ...
+    def getBoundingClientRect(self) -> DOMRect: ...
+    commonAncestorContainer: Node
+    def setStart(self, node: Node, offset: int) -> None: ...
+    def setEnd(self, node: Node, offset: int) -> None: ...
+    def setStartBefore(self, node: Node) -> None: ...
+    def setStartAfter(self, node: Node) -> None: ...
+    def setEndBefore(self, node: Node) -> None: ...
+    def setEndAfter(self, node: Node) -> None: ...
+    def collapse(self, toStart: bool | None = False) -> None: ...
+    def selectNode(self, node: Node) -> None: ...
+    def selectNodeContents(self, node: Node) -> None: ...
+    START_TO_START = 0
+    START_TO_END = 1
+    END_TO_END = 2
+    END_TO_START = 3
+    def compareBoundaryPoints(self, how: int, sourceRange: Range) -> short: ...
+    def deleteContents(self) -> None: ...
+    def extractContents(self) -> DocumentFragment: ...
+    def cloneContents(self) -> DocumentFragment: ...
+    def insertNode(self, node: Node) -> None: ...
+    def surroundContents(self, newParent: Node) -> None: ...
+    def cloneRange(self) -> Range: ...
+    def detach(self) -> None: ...
+    def isPointInRange(self, node: Node, offset: int) -> bool: ...
+    def comparePoint(self, node: Node, offset: int) -> short: ...
+    def intersectsNode(self, node: Node) -> bool: ...
+class Selection:
+    anchorNode: Node | None
+    anchorOffset: int
+    focusNode: Node | None
+    focusOffset: int
+    isCollapsed: bool
+    rangeCount: int
+    type: str
+    def getRangeAt(self, index: int) -> Range: ...
+    def addRange(self, range: Range) -> None: ...
+    def removeRange(self, range: Range) -> None: ...
+    def removeAllRanges(self) -> None: ...
+    def empty(self) -> None: ...
+    def getComposedRange(self, *shadowRoots: ShadowRoot) -> StaticRange: ...
+    def collapse(self, node: Node | None, offset: int | None = 0) -> None: ...
+    def setPosition(self, node: Node | None, offset: int | None = 0) -> None: ...
+    def collapseToStart(self) -> None: ...
+    def collapseToEnd(self) -> None: ...
+    def extend(self, node: Node, offset: int | None = 0) -> None: ...
+    def setBaseAndExtent(self, anchorNode: Node, anchorOffset: int, focusNode: Node, focusOffset: int) -> None: ...
+    def selectAllChildren(self, node: Node) -> None: ...
+    def modify(self, alter: str | None = None, direction: str | None = None, granularity: str | None = None) -> None: ...
+    def deleteFromDocument(self) -> None: ...
+    def containsNode(self, node: Node, allowPartialContainment: bool | None = False) -> bool: ...
+class MutationObserver:
+    @classmethod
+    def new(self, callback: MutationCallback) -> MutationObserver: ...
+    def observe(self, target: Node, options: MutationObserverInit | None = {}) -> None: ...
+    def disconnect(self) -> None: ...
+    def takeRecords(self) -> Sequence[MutationRecord]: ...
+class MutationRecord:
+    type: str
+    target: Node
+    addedNodes: NodeList
+    removedNodes: NodeList
+    previousSibling: Node | None
+    nextSibling: Node | None
+    attributeName: str | None
+    attributeNamespace: str | None
+    oldValue: str | None
+class IntersectionObserver:
+    @classmethod
+    def new(self, callback: IntersectionObserverCallback, options: IntersectionObserverInit | None = {}) -> IntersectionObserver: ...
+    root: Element | Document | None
+    rootMargin: str
+    thresholds: Sequence[float]
+    def observe(self, target: Element) -> None: ...
+    def unobserve(self, target: Element) -> None: ...
+    def disconnect(self) -> None: ...
+    def takeRecords(self) -> Sequence[IntersectionObserverEntry]: ...
+class IntersectionObserverEntry:
+    @classmethod
+    def new(self, intersectionObserverEntryInit: IntersectionObserverEntryInit) -> IntersectionObserverEntry: ...
+    time: DOMHighResTimeStamp
+    rootBounds: DOMRectReadOnly | None
+    boundingClientRect: DOMRectReadOnly
+    intersectionRect: DOMRectReadOnly
+    isIntersecting: bool
+    intersectionRatio: float
+    target: Element
+class ResizeObserver:
+    @classmethod
+    def new(self, callback: ResizeObserverCallback) -> ResizeObserver: ...
+    def observe(self, target: Element, options: ResizeObserverOptions | None = {}) -> None: ...
+    def unobserve(self, target: Element) -> None: ...
+    def disconnect(self) -> None: ...
+class ResizeObserverEntry:
+    target: Element
+    contentRect: DOMRectReadOnly
+    borderBoxSize: Sequence[ResizeObserverSize]
+    contentBoxSize: Sequence[ResizeObserverSize]
+    devicePixelContentBoxSize: Sequence[ResizeObserverSize]
+class CanvasRenderingContext2D(CanvasState, CanvasTransform, CanvasCompositing, CanvasImageSmoothing, CanvasFillStrokeStyles, CanvasShadowStyles, CanvasFilters, CanvasRect, CanvasDrawPath, CanvasUserInterface, CanvasText, CanvasDrawImage, CanvasImageData, CanvasPathDrawingStyles, CanvasTextDrawingStyles, CanvasPath):
+    canvas: HTMLCanvasElement
+    def getContextAttributes(self) -> CanvasRenderingContext2DSettings: ...
+class ImageData:
+    @overload
+    @classmethod
+    def new(self, sw: int, sh: int, settings: ImageDataSettings | None = {}) -> ImageData: ...
+    @overload
+    @classmethod
+    def new(self, data: Uint8ClampedArray, sw: int, sh: int | None = None, settings: ImageDataSettings | None = {}) -> ImageData: ...
+    width: int
+    height: int
+    data: Uint8ClampedArray
+    colorSpace: PredefinedColorSpace
+class Path2D(CanvasPath):
+    @classmethod
+    def new(self, path: Path2D | str | None = None) -> Path2D: ...
+    def addPath(self, path: Path2D, transform: DOMMatrix2DInit | None = {}) -> None: ...
+class URL:
+    @classmethod
+    def new(self, url: USVString, base: USVString | None = None) -> URL: ...
+    href: USVString
+    origin: USVString
+    protocol: USVString
+    username: USVString
+    password: USVString
+    host: USVString
+    hostname: USVString
+    port: USVString
+    pathname: USVString
+    search: USVString
+    searchParams: URLSearchParams
+    hash: USVString
+    def toJSON(self) -> USVString: ...
+class URLSearchParams:
+    @classmethod
+    def new(self, init: Sequence[Sequence[USVString]] | USVString | USVString | None = "") -> URLSearchParams: ...
+    def append(self, name: USVString, value: USVString) -> None: ...
+    def delete(self, name: USVString) -> None: ...
+    def get(self, name: USVString) -> USVString | None: ...
+    def getAll(self, name: USVString) -> Sequence[USVString]: ...
+    def has(self, name: USVString) -> bool: ...
+    def set(self, name: USVString, value: USVString) -> None: ...
+    def sort(self) -> None: ...
+class Headers:
+    @classmethod
+    def new(self, init: HeadersInit | None = None) -> Headers: ...
+    def append(self, name: ByteString, value: ByteString) -> None: ...
+    def delete(self, name: ByteString) -> None: ...
+    def get(self, name: ByteString) -> ByteString | None: ...
+    def has(self, name: ByteString) -> bool: ...
+    def set(self, name: ByteString, value: ByteString) -> None: ...
+class Request(Body):
+    @classmethod
+    def new(self, input: RequestInfo, init: RequestInit | None = {}) -> Request: ...
+    method: ByteString
+    url: USVString
+    headers: Headers
+    destination: RequestDestination
+    referrer: USVString
+    referrerPolicy: ReferrerPolicy
+    mode: RequestMode
+    credentials: RequestCredentials
+    cache: RequestCache
+    redirect: RequestRedirect
+    integrity: str
+    keepalive: bool
+    isReloadNavigation: bool
+    isHistoryNavigation: bool
+    signal: AbortSignal
+    duplex: RequestDuplex
+    def clone(self) -> Request: ...
+class Response(Body):
+    @classmethod
+    def new(self, body: BodyInit | None = None, init: ResponseInit | None = {}) -> Response: ...
+    type: ResponseType
+    url: USVString
+    redirected: bool
+    status: int
+    ok: bool
+    statusText: ByteString
+    headers: Headers
+    def clone(self) -> Response: ...
+class DOMStringMap: ...
+class DOMParser:
+    @classmethod
+    def new(self) -> DOMParser: ...
+    def parseFromString(self, string: str, type: DOMParserSupportedType) -> Document: ...
+class XMLSerializer:
+    @classmethod
+    def new(self) -> XMLSerializer: ...
+    def serializeToString(self, root: Node) -> str: ...
+class FormData:
+    @classmethod
+    def new(self, form: HTMLFormElement | None = None) -> FormData: ...
+    @overload
+    def append(self, name: USVString, value: USVString) -> None: ...
+    @overload
+    def append(self, name: USVString, blobValue: Blob, filename: USVString | None = None) -> None: ...
+    def delete(self, name: USVString) -> None: ...
+    def get(self, name: USVString) -> FormDataEntryValue | None: ...
+    def getAll(self, name: USVString) -> Sequence[FormDataEntryValue]: ...
+    def has(self, name: USVString) -> bool: ...
+    @overload
+    def set(self, name: USVString, value: USVString) -> None: ...
+    @overload
+    def set(self, name: USVString, blobValue: Blob, filename: USVString | None = None) -> None: ...
+class AbortController:
+    @classmethod
+    def new(self) -> AbortController: ...
+    signal: AbortSignal
+    def abort(self, reason: Any | None = None) -> None: ...
+class AbortSignal(EventTarget):
+    aborted: bool
+    reason: Any
+    def throwIfAborted(self) -> None: ...
+    onabort: EventHandler
+# Type aliases for compatibility
+Console = ConsoleNamespace
+# USVString and ByteString are just str in Python
+USVString = str
+ByteString = str
+CSSOMString = str
+# WebIDL numeric types
+short = int
+DOMHighResTimeStamp = float
+# Note: webtypy's Storage is incomplete, so we override it here
+class Storage:
+    """Web Storage API interface for localStorage and sessionStorage."""
+    length: int
+    def key(self, index: int) -> str | None: ...
+    def getItem(self, key: str) -> str | None: ...
+    def setItem(self, key: str, value: str) -> None: ...
+    def removeItem(self, key: str) -> None: ...
+    def clear(self) -> None: ...
+# Undefined types from webtypy - aliased to Any for compatibility
+# These are WebIDL types not fully implemented in webtypy
+AbstractRange = Any
+AddEventListenerOptions = Any
+Animation = Any
+AnimationEventInit = Any
+AnimationFrameProvider = Any
+Anvil = Any
+ArrayBuffer = Any
+Attr = Any
+AudioContext = Any
+AudioTrackList = Any
+AutoplayPolicy = Any
+AutoplayPolicyMediaType = Any
+BarProp = Any
+BatteryManager = Any
+BlobCallback = Any
+BlobPart = Any
+BlobPropertyBag = Any
+Bluetooth = Any
+Body = Any
+BodyInit = Any
+BoxQuadOptions = Any
+CDATASection = Any
+CSSPseudoElement = Any
+CSSRule = Any
+CSSRuleList = Any
+CSSStyleSheetInit = Any
+CanPlayTypeResult = Any
+CanvasCompositing = Any
+CanvasDrawImage = Any
+CanvasDrawPath = Any
+CanvasFillStrokeStyles = Any
+CanvasFilters = Any
+CanvasImageData = Any
+CanvasImageSmoothing = Any
+CanvasPath = Any
+CanvasPathDrawingStyles = Any
+CanvasRect = Any
+CanvasRenderingContext2DSettings = Any
+CanvasShadowStyles = Any
+CanvasState = Any
+CanvasText = Any
+CanvasTextDrawingStyles = Any
+CanvasTransform = Any
+CanvasUserInterface = Any
+CaretPosition = Any
+CheckVisibilityOptions = Any
+ClipboardEventInit = Any
+ClipboardItems = Any
+Comment = Any
+ContactsManager = Any
+ConvertCoordinateOptions = Any
+CookieStore = Any
+CredentialsContainer = Any
+CustomElementRegistry = Any
+CustomEventInit = Any
+DOMException = Any
+DOMImplementation = Any
+DOMMatrix2DInit = Any
+DOMParserSupportedType = Any
+DOMPoint = Any
+DOMPointInit = Any
+DOMQuad = Any
+DOMQuadInit = Any
+DOMRectList = Any
+DOMStringList = Any
+DevicePosture = Any
+DigitalGoodsService = Any
+DirectoryPickerOptions = Any
+DocumentReadyState = Any
+DocumentTimeline = Any
+DocumentType = Any
+DocumentVisibilityState = Any
+DragEventInit = Any
+ELEMENT_NODE = Any
+EditContext = Any
+ElementCreationOptions = Any
+ElementInternals = Any
+EpubReadingSystem = Any
+ErrorEventInit = Any
+EventHandler = Any
+EventInit = Any
+EventListener = Any
+EventListenerOptions = Any
+External = Any
+FilePropertyBag = Any
+FileSystemDirectoryHandle = Any
+FileSystemEntry = Any
+FileSystemFileHandle = Any
+FileSystemHandle = Any
+FocusEventInit = Any
+FocusOptions = Any
+FocusableAreasOption = Any
+FontData = Any
+FontFaceSet = Any
+FontMetrics = Any
+FormDataEntryValue = Any
+FormDataEventInit = Any
+FragmentDirective = Any
+FullscreenOptions = Any
+FunctionStringCallback = Any
+GENERATED = Any
+Gamepad = Any
+GeometryNode = Any
+GetAnimationsOptions = Any
+GetRootNodeOptions = Any
+HID = Any
+HTMLAllCollection = Any
+HTMLAttributionSrcElementUtils = Any
+HTMLDataListElement = Any
+HTMLFormControlsCollection = Any
+HTMLHeadElement = Any
+HTMLHyperlinkElementUtils = Any
+HTMLOptionsCollection = Any
+HTMLOrSVGScriptElement = Any
+HTMLSlotElement = Any
+HTMLTableCaptionElement = Any
+HashChangeEventInit = Any
+HeadersInit = Any
+IdleRequestCallback = Any
+IdleRequestOptions = Any
+ImageDataSettings = Any
+Ink = Any
+InputDeviceCapabilities = Any
+InputEventInit = Any
+IntersectionObserverCallback = Any
+IntersectionObserverEntryInit = Any
+IntersectionObserverInit = Any
+Keyboard = Any
+KeyboardEventInit = Any
+KeyframeAnimationOptions = Any
+LaunchQueue = Any
+LinkStyle = Any
+MIDIAccess = Any
+MIDIOptions = Any
+MediaCapabilities = Any
+MediaDevices = Any
+MediaError = Any
+MediaKeySystemAccess = Any
+MediaKeySystemConfiguration = Any
+MediaKeys = Any
+MediaList = Any
+MediaProvider = Any
+MediaSession = Any
+MediaStream = Any
+MediaStreamConstraints = Any
+MessageEventInit = Any
+MessageEventSource = Any
+MessagePort = Any
+MouseEventInit = Any
+MutationCallback = Any
+MutationObserverInit = Any
+NamedFlowMap = Any
+NamedNodeMap = Any
+Navigation = Any
+NavigatorAutomationInformation = Any
+NavigatorBadge = Any
+NavigatorConcurrentHardware = Any
+NavigatorContentUtils = Any
+NavigatorCookies = Any
+NavigatorDeviceMemory = Any
+NavigatorGPU = Any
+NavigatorID = Any
+NavigatorLanguage = Any
+NavigatorLocks = Any
+NavigatorML = Any
+NavigatorNetworkInformation = Any
+NavigatorOnLine = Any
+NavigatorPlugins = Any
+NavigatorStorage = Any
+NavigatorUA = Any
+NavigatorUserMediaErrorCallback = Any
+NavigatorUserMediaSuccessCallback = Any
+NodeFilter = Any
+NodeIterator = Any
+OffscreenCanvas = Any
+OnErrorEventHandler = Any
+OpenFilePickerOptions = Any
+Permissions = Any
+PermissionsPolicy = Any
+PictureInPictureWindow = Any
+PointerEventInit = Any
+PopStateEventInit = Any
+PortalHost = Any
+PositionCallback = Any
+PositionErrorCallback = Any
+PositionOptions = Any
+PredefinedColorSpace = Any
+Presentation = Any
+ProcessingInstruction = Any
+ProgressEventInit = Any
+QueryOptions = Any
+ReadableStream = Any
+ReferrerPolicy = Any
+RelatedApplication = Any
+RemotePlayback = Any
+RenderingContext = Any
+RequestCache = Any
+RequestCredentials = Any
+RequestDestination = Any
+RequestDuplex = Any
+RequestInfo = Any
+RequestInit = Any
+RequestMode = Any
+RequestRedirect = Any
+ResizeObserverCallback = Any
+ResizeObserverOptions = Any
+ResizeObserverSize = Any
+ResponseInit = Any
+ResponseType = Any
+SVGSVGElement = Any
+SaveFilePickerOptions = Any
+Scheduling = Any
+ScreenDetails = Any
+ScreenOrientation = Any
+ScrollIntoViewOptions = Any
+ScrollRestoration = Any
+ScrollToOptions = Any
+SelectionMode = Any
+Serial = Any
+ServiceWorkerContainer = Any
+SetHTMLOptions = Any
+ShadowRoot = Any
+ShadowRootInit = Any
+ShareData = Any
+SpatialNavigationDirection = Any
+SpatialNavigationSearchOptions = Any
+SpeechSynthesis = Any
+StaticRange = Any
+StorageEventInit = Any
+StylePropertyMap = Any
+StylePropertyMapReadOnly = Any
+StyleSheetList = Any
+SubmitEventInit = Any
+Text = Any
+TextTrack = Any
+TextTrackKind = Any
+TextTrackList = Any
+TimeRanges = Any
+TouchEventInit = Any
+TouchInit = Any
+TouchType = Any
+TransitionEventInit = Any
+TreeWalker = Any
+UIEventInit = Any
+USB = Any
+Uint8ClampedArray = Any
+UpdateCallback = Any
+UserActivation = Any
+ValidityState = Any
+VibratePattern = Any
+VideoFrameRequestCallback = Any
+VideoPlaybackQuality = Any
+VideoTrackList = Any
+ViewTransition = Any
+VirtualKeyboard = Any
+VisualViewport = Any
+WakeLock = Any
+WheelEventInit = Any
+WindowControlsOverlay = Any
+WindowEventHandlers = Any
+WindowLocalStorage = Any
+WindowOrWorkerGlobalScope = Any
+WindowPostMessageOptions = Any
+WindowProxy = Any
+WindowSessionStorage = Any
+XPathExpression = Any
+XPathNSResolver = Any
+XPathResult = Any
+XRSystem = Any
+# =============================================================================
+# Window module-level exports
+# =============================================================================
+# The window object itself
+window: Window
+"""The global window object. Equivalent to `self` in JavaScript."""
+# Window properties exported as module-level attributes
+document: Document
+"""The document associated with the window."""
+location: Location
+"""The location (URL) of the window."""
+history: History
+"""The browser's session history."""
+navigator: Navigator
+"""Information about the browser/user agent."""
+localStorage: Storage
+"""Storage that persists across browser sessions."""
+sessionStorage: Storage
+"""Storage that lasts for the duration of the page session."""
+console: Console
+"""The browser's debugging console."""
+# Window dimensions
+innerWidth: int
+"""The interior width of the window in pixels."""
+innerHeight: int
+"""The interior height of the window in pixels."""
+outerWidth: int
+"""The width of the outside of the browser window."""
+outerHeight: int
+"""The height of the outside of the browser window."""
+# Scroll position
+scrollX: float
+"""The number of pixels scrolled horizontally."""
+scrollY: float
+"""The number of pixels scrolled vertically."""
+pageXOffset: float
+"""Alias for scrollX."""
+pageYOffset: float
+"""Alias for scrollY."""
+# Screen position
+screenX: int
+"""The horizontal distance from the left screen edge."""
+screenY: int
+"""The vertical distance from the top screen edge."""
+screenLeft: int
+"""Alias for screenX."""
+screenTop: int
+"""Alias for screenY."""
+# Device info
+devicePixelRatio: float
+"""The ratio between physical pixels and CSS pixels."""
+# Window state
+name: str
+"""The name of the window."""
+closed: bool
+"""Whether the window has been closed."""
+# Window methods (commonly used)
+def alert(message: str = "") -> None:
+    """Display an alert dialog."""
+    ...
+def confirm(message: str = "") -> bool:
+    """Display a confirmation dialog."""
+    ...
+def prompt(message: str = "", default: str = "") -> str | None:
+    """Display a prompt dialog."""
+    ...
+def open(
+    url: str = "",
+    target: str = "_blank",
+    features: str = "",
+) -> object | None:
+    """Open a new browser window."""
+    ...
+def close() -> None:
+    """Close the window."""
+    ...
+def focus() -> None:
+    """Focus the window."""
+    ...
+def blur() -> None:
+    """Remove focus from the window."""
+    ...
+def scroll(x: float | dict[str, object], y: float | None = None) -> None:
+    """Scroll to a position in the document."""
+    ...
+def scrollTo(x: float | dict[str, object], y: float | None = None) -> None:
+    """Scroll to a position in the document."""
+    ...
+def scrollBy(x: float | dict[str, object], y: float | None = None) -> None:
+    """Scroll by an amount."""
+    ...
+def requestAnimationFrame(callback: object) -> int:
+    """Request an animation frame callback."""
+    ...
+def cancelAnimationFrame(handle: int) -> None:
+    """Cancel an animation frame callback."""
+    ...
+def setTimeout(callback: object, delay: int = 0, *args: object) -> int:
+    """Set a timer to execute a callback."""
+    ...
+def clearTimeout(id: int) -> None:
+    """Clear a timer."""
+    ...
+def setInterval(callback: object, delay: int = 0, *args: object) -> int:
+    """Set a recurring timer."""
+    ...
+def clearInterval(id: int) -> None:
+    """Clear a recurring timer."""
+    ...
+def fetch(input: str | object, init: dict[str, object] | None = None) -> object:
+    """Fetch a resource from the network."""
+    ...
+def getComputedStyle(elt: object, pseudoElt: str | None = None) -> object:
+    """Get computed styles for an element."""
+    ...
+def matchMedia(query: str) -> object:
+    """Match a media query."""
+    ...
+def atob(data: str) -> str:
+    """Decode a base64-encoded string."""
+    ...
+def btoa(data: str) -> str:
+    """Encode a string to base64."""
+    ...
+def postMessage(
+    message: object, targetOrigin: str, transfer: list[object] | None = None
+) -> None:
+    """Post a message to another window."""
+    ...
+def print() -> None:
+    """Print the document."""
+    ...
+def stop() -> None:
+    """Stop loading the document."""
+    ...
+def getSelection() -> object | None:
+    """Get the current text selection."""
+    ...
+# Allow access to any window property not explicitly defined above.
+# This handles dynamically loaded globals like jQuery, lodash, etc.
+def __getattr__(name: str) -> Any:
+    """Access any window property by name.
+    The window object can have arbitrary properties, including:
+    - Dynamically loaded libraries (jQuery, lodash, React, etc.)
+    - Custom global variables set by JavaScript code
+    - Browser-specific APIs not covered by the standard stubs
+    Example:
+        from anvil.js.window import jQuery as _S
+        _S("#my-element").hide()
+    """
+    ...