W3C DOM and Browser APIs

/**
 * Document interface representing the HTML document
 */
external interface Document : Node, DocumentOrShadowRoot, GlobalEventHandlers {
    val documentElement: Element?
    val body: HTMLElement?
    val head: HTMLHeadElement?
    val title: String
    
    fun createElement(localName: String): Element
    fun createTextNode(data: String): Text
    fun getElementById(elementId: String): Element?
    fun getElementsByTagName(qualifiedName: String): HTMLCollection
    fun getElementsByClassName(classNames: String): HTMLCollection
    fun querySelector(selectors: String): Element?
    fun querySelectorAll(selectors: String): NodeList
}

/**
 * Base element interface
 */
external interface Element : Node, DocumentOrShadowRoot, GlobalEventHandlers {
    val tagName: String
    val id: String
    val className: String  
    val classList: DOMTokenList
    
    fun getAttribute(qualifiedName: String): String?
    fun setAttribute(qualifiedName: String, value: String)
    fun removeAttribute(qualifiedName: String)
    fun hasAttribute(qualifiedName: String): Boolean
    
    fun querySelector(selectors: String): Element?
    fun querySelectorAll(selectors: String): NodeList
    fun getElementsByTagName(qualifiedName: String): HTMLCollection
    fun getElementsByClassName(classNames: String): HTMLCollection
}

/**
 * Base node interface for DOM tree
 */
external interface Node : EventTarget {
    val nodeType: Short
    val nodeName: String
    val nodeValue: String?
    val textContent: String?
    val parentNode: Node?
    val childNodes: NodeList
    val firstChild: Node?
    val lastChild: Node?
    val nextSibling: Node?
    val previousSibling: Node?
    
    fun appendChild(node: Node): Node
    fun insertBefore(node: Node, child: Node?): Node
    fun removeChild(child: Node): Node
    fun replaceChild(node: Node, child: Node): Node
    fun cloneNode(deep: Boolean): Node
}

/**
 * Base HTML element interface
 */
external interface HTMLElement : Element, GlobalEventHandlers {
    var title: String
    var lang: String
    var dir: String
    var hidden: Boolean
    val style: CSSStyleDeclaration
    val offsetParent: Element?
    val offsetTop: Int
    val offsetLeft: Int
    val offsetWidth: Int
    val offsetHeight: Int
    
    fun click()
    fun focus()
    fun blur()
}

/**
 * HTML input element
 */
external interface HTMLInputElement : HTMLElement {
    var type: String
    var value: String
    var placeholder: String
    var disabled: Boolean
    var readonly: Boolean
    var required: Boolean
    var checked: Boolean
    var name: String
    var form: HTMLFormElement?
    
    fun select()
    fun focus()
    fun blur()
    fun checkValidity(): Boolean
}

/**
 * HTML form element
 */
external interface HTMLFormElement : HTMLElement {
    val elements: HTMLFormControlsCollection
    val length: Int
    var action: String
    var method: String
    var target: String
    var enctype: String
    
    fun submit()
    fun reset()
    fun checkValidity(): Boolean
}

/**
 * HTML div element
 */
external interface HTMLDivElement : HTMLElement

/**
 * HTML span element  
 */
external interface HTMLSpanElement : HTMLElement

/**
 * HTML anchor element
 */
external interface HTMLAnchorElement : HTMLElement {
    var href: String
    var target: String
    var download: String
    var rel: String
    val hostname: String
    val pathname: String
    val search: String
    val hash: String
}

/**
 * HTML image element
 */
external interface HTMLImageElement : HTMLElement {
    var src: String
    var alt: String
    var width: Int
    var height: Int
    var crossOrigin: String?
    val naturalWidth: Int
    val naturalHeight: Int
    val complete: Boolean
}

/**
 * Base event interface
 */
external interface Event {
    val type: String
    val target: EventTarget?
    val currentTarget: EventTarget?
    val eventPhase: Short
    val bubbles: Boolean
    val cancelable: Boolean
    val defaultPrevented: Boolean
    val timeStamp: Number
    
    fun preventDefault()
    fun stopPropagation()
    fun stopImmediatePropagation()
}

/**
 * Event target interface for event handling
 */
external interface EventTarget {
    fun addEventListener(type: String, listener: EventListener?)
    fun addEventListener(type: String, listener: EventListener?, options: AddEventListenerOptions?)
    fun removeEventListener(type: String, listener: EventListener?)
    fun removeEventListener(type: String, listener: EventListener?, options: EventListenerOptions?)
    fun dispatchEvent(event: Event): Boolean
}

/**
 * Event listener interface
 */
external interface EventListener {
    fun handleEvent(event: Event)
}

/**
 * Mouse event interface
 */
external interface MouseEvent : UIEvent {
    val button: Short
    val buttons: Short
    val clientX: Int
    val clientY: Int
    val screenX: Int
    val screenY: Int
    val ctrlKey: Boolean
    val shiftKey: Boolean
    val altKey: Boolean
    val metaKey: Boolean
}

/**
 * Keyboard event interface
 */
external interface KeyboardEvent : UIEvent {
    val key: String
    val code: String
    val location: Int
    val ctrlKey: Boolean
    val shiftKey: Boolean
    val altKey: Boolean
    val metaKey: Boolean
    val repeat: Boolean
}

/**
 * Modern fetch API for HTTP requests
 */
external fun fetch(input: RequestInfo, init: RequestInit? = definedExternally): Promise<Response>

/**
 * HTTP request representation
 */
external interface Request {
    val method: String
    val url: String
    val headers: Headers
    val body: dynamic
    val mode: RequestMode
    val credentials: RequestCredentials
    
    fun text(): Promise<String>
    fun json(): Promise<dynamic>
    fun blob(): Promise<Blob>
    fun arrayBuffer(): Promise<ArrayBuffer>
}

/**
 * HTTP response representation
 */
external interface Response {
    val ok: Boolean
    val status: Short
    val statusText: String
    val headers: Headers
    val body: ReadableStream?
    val bodyUsed: Boolean
    
    fun text(): Promise<String>
    fun json(): Promise<dynamic>
    fun blob(): Promise<Blob>
    fun arrayBuffer(): Promise<ArrayBuffer>
    fun clone(): Response
}

/**
 * HTTP headers manipulation
 */
external interface Headers {
    fun append(name: String, value: String)
    fun delete(name: String)
    fun get(name: String): String?
    fun has(name: String): Boolean
    fun set(name: String, value: String)
}

/**
 * Traditional XMLHttpRequest
 */
external interface XMLHttpRequest : EventTarget {
    var onload: ((Event) -> Unit)?
    var onerror: ((Event) -> Unit)?
    var onreadystatechange: ((Event) -> Unit)?
    val readyState: Short
    val response: dynamic
    val responseText: String
    val responseType: XMLHttpRequestResponseType
    val status: Short
    val statusText: String
    
    fun open(method: String, url: String)
    fun open(method: String, url: String, async: Boolean)
    fun send()
    fun send(body: dynamic)
    fun setRequestHeader(name: String, value: String)
    fun getResponseHeader(name: String): String?
    fun getAllResponseHeaders(): String
    fun abort()
}

/**
 * Binary large object representation
 */
external interface Blob {
    val size: Number
    val type: String
    
    fun slice(): Blob
    fun slice(start: Number): Blob
    fun slice(start: Number, end: Number): Blob
    fun slice(start: Number, end: Number, contentType: String): Blob
    fun stream(): ReadableStream
    fun text(): Promise<String>
    fun arrayBuffer(): Promise<ArrayBuffer>
}

/**
 * File system file representation
 */
external interface File : Blob {
    val name: String
    val lastModified: Number
}

/**
 * Collection of files (from input[type=file])
 */
external interface FileList {
    val length: Int
    fun item(index: Int): File?
    operator fun get(index: Int): File?
}

/**
 * Asynchronous file reading
 */
external interface FileReader : EventTarget {
    val readyState: Short
    val result: dynamic
    val error: dynamic
    var onload: ((Event) -> Unit)?
    var onerror: ((Event) -> Unit)?
    var onloadend: ((Event) -> Unit)?
    
    fun readAsArrayBuffer(file: Blob)
    fun readAsDataURL(file: Blob) 
    fun readAsText(file: Blob)
    fun readAsText(file: Blob, encoding: String)
    fun abort()
}

/**
 * Form data encoding
 */
external interface FormData {
    fun append(name: String, value: String)
    fun append(name: String, value: Blob)
    fun append(name: String, value: Blob, filename: String)
    fun delete(name: String)
    fun get(name: String): dynamic
    fun getAll(name: String): Array<dynamic>
    fun has(name: String): Boolean
    fun set(name: String, value: String)
    fun set(name: String, value: Blob)
    fun set(name: String, value: Blob, filename: String)
}

/**
 * Media stream representation
 */
external interface MediaStream : EventTarget {
    val id: String
    val active: Boolean
    
    fun getAudioTracks(): Array<MediaStreamTrack>
    fun getVideoTracks(): Array<MediaStreamTrack>
    fun getTracks(): Array<MediaStreamTrack>
    fun addTrack(track: MediaStreamTrack)
    fun removeTrack(track: MediaStreamTrack)
    fun clone(): MediaStream
}

/**
 * Individual media track
 */
external interface MediaStreamTrack : EventTarget {
    val id: String
    val kind: String
    val label: String
    val enabled: Boolean
    val muted: Boolean
    val readyState: MediaStreamTrackState
    
    fun clone(): MediaStreamTrack
    fun stop()
    fun getCapabilities(): MediaTrackCapabilities
    fun getConstraints(): MediaTrackConstraints
}

/**
 * Media device access
 */
external interface MediaDevices : EventTarget {
    fun getUserMedia(constraints: MediaStreamConstraints): Promise<MediaStream>
    fun getDisplayMedia(constraints: DisplayMediaStreamConstraints): Promise<MediaStream>
    fun enumerateDevices(): Promise<Array<MediaDeviceInfo>>
}

/**
 * HTML video element
 */
external interface HTMLVideoElement : HTMLMediaElement {
    var width: Int
    var height: Int
    val videoWidth: Int
    val videoHeight: Int
    var poster: String
}

/**
 * HTML audio element
 */
external interface HTMLAudioElement : HTMLMediaElement

/**
 * WebGL rendering context
 */
external interface WebGLRenderingContext {
    // Context constants
    val DEPTH_BUFFER_BIT: Int
    val STENCIL_BUFFER_BIT: Int  
    val COLOR_BUFFER_BIT: Int
    val TRIANGLES: Int
    val TRIANGLE_STRIP: Int
    val TRIANGLE_FAN: Int
    
    // Buffer operations
    fun createBuffer(): WebGLBuffer?
    fun bindBuffer(target: Int, buffer: WebGLBuffer?)
    fun bufferData(target: Int, size: Int, usage: Int)
    fun bufferData(target: Int, data: ArrayBufferView, usage: Int)
    fun deleteBuffer(buffer: WebGLBuffer?)
    
    // Shader operations  
    fun createShader(type: Int): WebGLShader?
    fun shaderSource(shader: WebGLShader, source: String)
    fun compileShader(shader: WebGLShader)
    fun deleteShader(shader: WebGLShader?)
    
    // Program operations
    fun createProgram(): WebGLProgram?
    fun attachShader(program: WebGLProgram, shader: WebGLShader)
    fun linkProgram(program: WebGLProgram)
    fun useProgram(program: WebGLProgram?)
    fun deleteProgram(program: WebGLProgram?)
    
    // Drawing operations
    fun clear(mask: Int)
    fun clearColor(red: Float, green: Float, blue: Float, alpha: Float)
    fun drawArrays(mode: Int, first: Int, count: Int)
    fun drawElements(mode: Int, count: Int, type: Int, offset: Int)
    
    // Viewport and scissor
    fun viewport(x: Int, y: Int, width: Int, height: Int)
    fun scissor(x: Int, y: Int, width: Int, height: Int)
}

/**
 * WebGL buffer object
 */
external interface WebGLBuffer

/**
 * WebGL shader object  
 */
external interface WebGLShader

/**
 * WebGL program object
 */
external interface WebGLProgram

/**
 * WebGL texture object
 */
external interface WebGLTexture

/**
 * Typed array for 32-bit floats
 */
external interface Float32Array : ArrayBufferView {
    val length: Int
    operator fun get(index: Int): Float
    operator fun set(index: Int, value: Float)
}

/**
 * Typed array for unsigned 8-bit integers
 */
external interface Uint8Array : ArrayBufferView {
    val length: Int
    operator fun get(index: Int): Byte
    operator fun set(index: Int, value: Byte)
}

/**
 * Service worker representation
 */
external interface ServiceWorker : EventTarget {
    val scriptURL: String
    val state: ServiceWorkerState
    
    fun postMessage(message: dynamic)
}

/**
 * Service worker registration
 */
external interface ServiceWorkerRegistration : EventTarget {
    val scope: String
    val installing: ServiceWorker?
    val waiting: ServiceWorker?
    val active: ServiceWorker?
    
    fun update(): Promise<Unit>
    fun unregister(): Promise<Boolean>
}

/**
 * Cache storage interface
 */
external interface CacheStorage {
    fun open(cacheName: String): Promise<Cache>
    fun has(cacheName: String): Promise<Boolean>
    fun delete(cacheName: String): Promise<Boolean>
    fun keys(): Promise<Array<String>>
}

/**
 * Individual cache interface
 */
external interface Cache {
    fun match(request: RequestInfo): Promise<Response?>
    fun matchAll(request: RequestInfo): Promise<Array<Response>>
    fun add(request: RequestInfo): Promise<Unit>
    fun addAll(requests: Array<RequestInfo>): Promise<Unit>
    fun put(request: RequestInfo, response: Response): Promise<Unit>
    fun delete(request: RequestInfo): Promise<Boolean>
    fun keys(): Promise<Array<Request>>
}

// Core DOM types
external interface Document : Node
external interface Element : Node  
external interface Node : EventTarget
external interface EventTarget

// HTML element types
external interface HTMLElement : Element
external interface HTMLInputElement : HTMLElement
external interface HTMLFormElement : HTMLElement
external interface HTMLDivElement : HTMLElement
external interface HTMLAnchorElement : HTMLElement
external interface HTMLImageElement : HTMLElement

// Event types
external interface Event
external interface MouseEvent : UIEvent
external interface KeyboardEvent : UIEvent
external interface EventListener

// Network types
external interface Request
external interface Response  
external interface Headers
external interface XMLHttpRequest : EventTarget

// File types
external interface Blob
external interface File : Blob
external interface FileList
external interface FileReader : EventTarget
external interface FormData

// Media types
external interface MediaStream : EventTarget
external interface MediaStreamTrack : EventTarget
external interface MediaDevices : EventTarget
external interface HTMLVideoElement : HTMLMediaElement
external interface HTMLAudioElement : HTMLMediaElement

// WebGL types
external interface WebGLRenderingContext
external interface WebGLBuffer
external interface WebGLShader
external interface WebGLProgram
external interface WebGLTexture
external interface Float32Array : ArrayBufferView
external interface Uint8Array : ArrayBufferView

// Service Worker types
external interface ServiceWorker : EventTarget
external interface ServiceWorkerRegistration : EventTarget
external interface Cache
external interface CacheStorage

// Utility types
external interface ArrayBuffer
external interface ArrayBufferView
external interface ReadableStream
external interface DOMTokenList
external interface HTMLCollection
external interface NodeList