EventTarget = ref EventTargetObj

DomEvent {...}{.pure.} = enum
  Abort = "abort", BeforeInput = "beforeinput", Blur = "blur", Click = "click",
  CompositionEnd = "compositionend", CompositionStart = "compositionstart",
  CompositionUpdate = "compositionupdate", DblClick = "dblclick", Error = "error",
  Focus = "focus", FocusIn = "focusin", FocusOut = "focusout", Input = "input",
  KeyDown = "keydown", KeyPress = "keypress", KeyUp = "keyup", Load = "load",
  MouseDown = "mousedown", MouseEnter = "mouseenter", MouseLeave = "mouseleave",
  MouseMove = "mousemove", MouseOut = "mouseout", MouseOver = "mouseover",
  MouseUp = "mouseup", Resize = "resize", Scroll = "scroll", Select = "select",
  Unload = "unload", Wheel = "wheel"

PerformanceMemory {...}{.importc.} = ref object
  jsHeapSizeLimit*: float
  totalJSHeapSize*: float
  usedJSHeapSize*: float

PerformanceTiming {...}{.importc.} = ref object
  connectStart*: float
  domComplete*: float
  domContentLoadedEventEnd*: float
  domContentLoadedEventStart*: float
  domInteractive*: float
  domLoading*: float
  domainLookupEnd*: float
  domainLookupStart*: float
  fetchStart*: float
  loadEventEnd*: float
  loadEventStart*: float
  navigationStart*: float
  redirectEnd*: float
  redirectStart*: float
  requestStart*: float
  responseEnd*: float
  responseStart*: float
  secureConnectionStart*: float
  unloadEventEnd*: float
  unloadEventStart*: float

Performance {...}{.importc.} = ref object
  memory*: PerformanceMemory
  timing*: PerformanceTiming

LocalStorage {...}{.importc.} = ref object

Window = ref WindowObj

Frame = ref FrameObj

ClassList = ref ClassListObj

NodeType = enum
  ElementNode = 1, AttributeNode, TextNode, CDATANode, EntityRefNode, EntityNode,
  ProcessingInstructionNode, CommentNode, DocumentNode, DocumentTypeNode,
  DocumentFragmentNode, NotationNode

Node = ref NodeObj

Document = ref DocumentObj

Element = ref ElementObj

ValidityState = ref ValidityStateObj

Blob = ref BlobObj

File = ref FileObj

TextAreaElement = ref TextAreaElementObj

InputElement = ref InputElementObj

LinkElement = ref LinkObj

EmbedElement = ref EmbedObj

AnchorElement = ref AnchorObj

OptionElement = ref OptionObj

FormElement = ref FormObj

ImageElement = ref ImageObj

Style = ref StyleObj

EventPhase = enum
  None = 0, CapturingPhase, AtTarget, BubblingPhase

Event = ref EventObj

UIEvent = ref UIEventObj

KeyboardEvent = ref KeyboardEventObj

KeyboardEventKey {...}{.pure.} = enum
  Alt, AltGraph, CapsLock, Control, Fn, FnLock, Hyper, Meta, NumLock, ScrollLock, Shift,
  Super, Symbol, SymbolLock, ArrowDown, ArrowLeft, ArrowRight, ArrowUp, End, Home,
  PageDown, PageUp, Backspace, Clear, Copy, CrSel, Cut, Delete, EraseEof, ExSel, Insert,
  Paste, Redo, Undo, Accept, Again, Attn, Cancel, ContextMenu, Escape, Execute, Find,
  Finish, Help, Pause, Play, Props, Select, ZoomIn, ZoomOut, BrigtnessDown, BrigtnessUp,
  Eject, LogOff, Power, PowerOff, PrintScreen, Hibernate, Standby, WakeUp,
  AllCandidates, Alphanumeric, CodeInput, Compose, Convert, Dead, FinalMode,
  GroupFirst, GroupLast, GroupNext, GroupPrevious, ModeChange, NextCandidate,
  NonConvert, PreviousCandidate, Process, SingleCandidate, HangulMode, HanjaMode,
  JunjaMode, Eisu, Hankaku, Hiragana, HiraganaKatakana, KanaMode, KanjiMode, Katakana,
  Romaji, Zenkaku, ZenkakuHanaku, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14,
  F15, F16, F17, F18, F19, F20, Soft1, Soft2, Soft3, Soft4, AppSwitch, Call, Camera,
  CameraFocus, EndCall, GoBack, GoHome, HeadsetHook, LastNumberRedial, Notification,
  MannerMode, VoiceDial, ChannelDown, ChannelUp, MediaFastForward, MediaPause,
  MediaPlay, MediaPlayPause, MediaRecord, MediaRewind, MediaStop, MediaTrackNext,
  MediaTrackPrevious, AudioBalanceLeft, AudioBalanceRight, AudioBassDown,
  AudioBassBoostDown, AudioBassBoostToggle, AudioBassBoostUp, AudioBassUp,
  AudioFaderFront, AudioFaderRear, AudioSurroundModeNext, AudioTrebleDown,
  AudioTrebleUp, AudioVolumeDown, AUdioVolumeMute, AudioVolumeUp, MicrophoneToggle,
  MicrophoneVolumeDown, MicrophoneVolumeMute, MicrophoneVolumeUp, TV, TV3DMode,
  TVAntennaCable, TVAudioDescription, TVAudioDescriptionMixDown,
  TVAudioDescriptionMixUp, TVContentsMenu, TVDataService, TVInput,
  TVInputComponent1, TVInputComponent2, TVInputComposite1, TVInputComposite2,
  TVInputHDMI1, TVInputHDMI2, TVInputHDMI3, TVInputHDMI4, TVInputVGA1,
  TVMediaContext, TVNetwork, TVNumberEntry, TVPower, TVRadioService, TVSatellite,
  TVSatelliteBS, TVSatelliteCS, TVSatelliteToggle, TVTerrestrialAnalog,
  TVTerrestrialDigital, TVTimer, AVRInput, AVRPower, ColorF0Red, ColorF1Green,
  ColorF2Yellow, ColorF3Blue, ColorF4Grey, ColorF5Brown, ClosedCaptionToggle, Dimmer,
  DisplaySwap, DVR, Exit, FavoriteClear0, FavoriteClear1, FavoriteClear2,
  FavoriteClear3, FavoriteRecall0, FavoriteRecall1, FavoriteRecall2,
  FavoriteRecall3, FavoriteStore0, FavoriteStore1, FavoriteStore2, FavoriteStore3,
  Guide, GuideNextDay, GuidePreviousDay, Info, InstantReplay, Link, ListProgram,
  LiveContent, Lock, MediaApps, MediaAudioTrack, MediaLast, MediaSkipBackward,
  MediaSkipForward, MediaStepBackward, MediaStepForward, MediaTopMenu, NavigateIn,
  NavigateNext, NavigateOut, NavigatePrevious, NextFavoriteChannel, NextUserProfile,
  OnDemand, Pairing, PinPDown, PinPMove, PinPUp, PlaySpeedDown, PlaySpeedReset,
  PlaySpeedUp, RandomToggle, RcLowBattery, RecordSpeedNext, RfBypass,
  ScanChannelsToggle, ScreenModeNext, Settings, SplitScreenToggle, STBInput,
  STBPower, Subtitle, Teletext, VideoModeNext, Wink, ZoomToggle, SpeechCorrectionList,
  SpeechInputToggle, Close, New, Open, Print, Save, SpellCheck, MailForward, MailReply,
  MailSend, LaunchCalculator, LaunchCalendar, LaunchContacts, LaunchMail,
  LaunchMediaPlayer, LaunchMusicPlayer, LaunchMyComputer, LaunchPhone,
  LaunchScreenSaver, LaunchSpreadsheet, LaunchWebBrowser, LaunchWebCam,
  LaunchWordProcessor, LaunchApplication1, LaunchApplication2, LaunchApplication3,
  LaunchApplication4, LaunchApplication5, LaunchApplication6, LaunchApplication7,
  LaunchApplication8, LaunchApplication9, LaunchApplication10, LaunchApplication11,
  LaunchApplication12, LaunchApplication13, LaunchApplication14,
  LaunchApplication15, LaunchApplication16, BrowserBack, BrowserFavorites,
  BrowserForward, BrowserHome, BrowserRefresh, BrowserSearch, BrowserStop, Key11,
  Key12, Separator

MouseButtons = enum
  NoButton = 0, PrimaryButton = 1, SecondaryButton = 2, AuxilaryButton = 4,
  FourthButton = 8, FifthButton = 16

MouseEvent = ref MouseEventObj

DataTransferItemKind {...}{.pure.} = enum
  File = "file", String = "string"

DataTransferItem = ref DataTransferItemObj

DataTransfer = ref DataTransferObj

DataTransferDropEffect {...}{.pure.} = enum
  None = "none", Copy = "copy", Link = "link", Move = "move"

DataTransferEffectAllowed {...}{.pure.} = enum
  None = "none", Copy = "copy", CopyLink = "copyLink", CopyMove = "copyMove", Link = "link",
  LinkMove = "linkMove", Move = "move", All = "all", Uninitialized = "uninitialized"

DragEventTypes = enum
  Drag = "drag", DragEnd = "dragend", DragEnter = "dragenter", DragExit = "dragexit",
  DragLeave = "dragleave", DragOver = "dragover", DragStart = "dragstart", Drop = "drop"

DragEvent {...}{.importc.} = object of MouseEvent
  dataTransfer*: DataTransfer

TouchList {...}{.importc.} = ref object of RootObj
  length*: int

Touch = ref TouchObj

TouchEvent = ref TouchEventObj

Location = ref LocationObj

History = ref HistoryObj

Navigator = ref NavigatorObj

Plugin {...}{.importc.} = object of RootObj
  description*: cstring
  filename*: cstring
  name*: cstring

MimeType {...}{.importc.} = object of RootObj
  description*: cstring
  enabledPlugin*: ref Plugin
  suffixes*: seq[cstring]
  `type`*: cstring

LocationBar {...}{.importc.} = object of RootObj
  visible*: bool

MenuBar = LocationBar

PersonalBar = LocationBar

ScrollBars = LocationBar

ToolBar = LocationBar

StatusBar = LocationBar

TimeOut {...}{.importc.} = ref object of RootObj

Interval {...}{.importc.} = object of RootObj

AddEventListenerOptions = object
  capture*: bool
  once*: bool
  passive*: bool

BoundingRect {...}{.importc.} = object
  top*, bottom*, left*, right*, x*, y*, width*, height*: float

window: Window

navigator: Navigator

screen: Screen

document: Document

DomApiVersion = 3

proc id(n: Node): cstring {...}{.importcpp: "#.id", nodecl.}

proc id=(n: Node; x: cstring) {...}{.importcpp: "#.id = #", nodecl.}

proc class(n: Node): cstring {...}{.importcpp: "#.className", nodecl.}

proc class=(n: Node; v: cstring) {...}{.importcpp: "#.className = #", nodecl.}

proc value(n: Node): cstring {...}{.importcpp: "#.value", nodecl.}

proc value=(n: Node; v: cstring) {...}{.importcpp: "#.value = #", nodecl.}

proc disabled=(n: Node; v: bool) {...}{.importcpp: "#.disabled = #", nodecl.}

proc len(x: Node): int {...}{.importcpp: "#.childNodes.length".}

proc `[]`(x: Node; idx: int): Element {...}{.importcpp: "#.childNodes[#]".}

proc getElementById(id: cstring): Element {...}{.importc: "document.getElementById", nodecl.}

proc appendChild(n, child: Node) {...}{.importcpp.}

proc removeChild(n, child: Node) {...}{.importcpp.}

proc replaceChild(n, newNode, oldNode: Node) {...}{.importcpp.}

proc insertBefore(n, newNode, before: Node) {...}{.importcpp.}

proc getElementById(d: Document; id: cstring): Element {...}{.importcpp.}

proc createElement(d: Document; identifier: cstring): Element {...}{.importcpp.}

proc createTextNode(d: Document; identifier: cstring): Node {...}{.importcpp.}

proc setTimeout(action: proc (); ms: int): TimeOut {...}{.importc, nodecl.}

proc clearTimeout(t: TimeOut) {...}{.importc, nodecl.}

proc addEventListener(et: EventTarget; ev: cstring; cb: proc (ev: Event);
                     useCapture: bool = false) {...}{.importcpp.}

proc addEventListener(et: EventTarget; ev: cstring; cb: proc (ev: Event);
                     options: AddEventListenerOptions) {...}{.importcpp.}

proc dispatchEvent(et: EventTarget; ev: Event) {...}{.importcpp.}

proc removeEventListener(et: EventTarget; ev: cstring; cb: proc (ev: Event)) {...}{.importcpp.}

proc alert(w: Window; msg: cstring) {...}{.importcpp.}

proc back(w: Window) {...}{.importcpp.}

proc blur(w: Window) {...}{.importcpp.}

proc captureEvents(w: Window; eventMask: int) {...}{.deprecated, importcpp.}

proc clearInterval(w: Window; interval: ref Interval) {...}{.importcpp.}

proc clearTimeout(w: Window; timeout: ref TimeOut) {...}{.importcpp.}

proc close(w: Window) {...}{.importcpp.}

proc confirm(w: Window; msg: cstring): bool {...}{.importcpp.}

proc disableExternalCapture(w: Window) {...}{.importcpp.}

proc enableExternalCapture(w: Window) {...}{.importcpp.}

proc find(w: Window; text: cstring; caseSensitive = false; backwards = false) {...}{.importcpp.}

proc focus(w: Window) {...}{.importcpp.}

proc forward(w: Window) {...}{.importcpp.}

proc getComputedStyle(w: Window; e: Node; pe: Node = nil): Style {...}{.importcpp.}

proc handleEvent(w: Window; e: Event) {...}{.importcpp.}

proc home(w: Window) {...}{.importcpp.}

proc moveBy(w: Window; x, y: int) {...}{.importcpp.}

proc moveTo(w: Window; x, y: int) {...}{.importcpp.}

proc open(w: Window; uri, windowname: cstring; properties: cstring = nil): Window {...}{.
    importcpp.}

proc print(w: Window) {...}{.importcpp.}

proc prompt(w: Window; text, default: cstring): cstring {...}{.importcpp.}

proc releaseEvents(w: Window; eventMask: int) {...}{.deprecated, importcpp.}

proc resizeBy(w: Window; x, y: int) {...}{.importcpp.}

proc resizeTo(w: Window; x, y: int) {...}{.importcpp.}

proc routeEvent(w: Window; event: Event) {...}{.importcpp.}

proc scrollBy(w: Window; x, y: int) {...}{.importcpp.}

proc scrollTo(w: Window; x, y: int) {...}{.importcpp.}

proc setInterval(w: Window; code: cstring; pause: int): ref Interval {...}{.importcpp.}

proc setInterval(w: Window; function: proc (); pause: int): ref Interval {...}{.importcpp.}

proc setTimeout(w: Window; code: cstring; pause: int): ref TimeOut {...}{.importcpp.}

proc setTimeout(w: Window; function: proc (); pause: int): ref Interval {...}{.importcpp.}

proc stop(w: Window) {...}{.importcpp.}

proc requestAnimationFrame(w: Window; function: proc (time: float)): int {...}{.importcpp.}

proc cancelAnimationFrame(w: Window; id: int) {...}{.importcpp.}

proc appendData(n: Node; data: cstring) {...}{.importcpp.}

proc cloneNode(n: Node; copyContent: bool): Node {...}{.importcpp.}

proc deleteData(n: Node; start, len: int) {...}{.importcpp.}

proc focus(e: Node) {...}{.importcpp.}

proc getAttribute(n: Node; attr: cstring): cstring {...}{.importcpp.}

proc getAttributeNode(n: Node; attr: cstring): Node {...}{.importcpp.}

proc hasChildNodes(n: Node): bool {...}{.importcpp.}

proc insertData(n: Node; position: int; data: cstring) {...}{.importcpp.}

proc removeAttribute(n: Node; attr: cstring) {...}{.importcpp.}

proc removeAttributeNode(n, attr: Node) {...}{.importcpp.}

proc replaceData(n: Node; start, len: int; text: cstring) {...}{.importcpp.}

proc scrollIntoView(n: Node) {...}{.importcpp.}

proc setAttribute(n: Node; name, value: cstring) {...}{.importcpp.}

proc setAttributeNode(n: Node; attr: Node) {...}{.importcpp.}

proc captureEvents(d: Document; eventMask: int) {...}{.deprecated, importcpp.}

proc createAttribute(d: Document; identifier: cstring): Node {...}{.importcpp.}

proc getElementsByName(d: Document; name: cstring): seq[Element] {...}{.importcpp.}

proc getElementsByTagName(d: Document; name: cstring): seq[Element] {...}{.importcpp.}

proc getElementsByClassName(d: Document; name: cstring): seq[Element] {...}{.importcpp.}

proc getSelection(d: Document): cstring {...}{.importcpp.}

proc handleEvent(d: Document; event: Event) {...}{.importcpp.}

proc open(d: Document) {...}{.importcpp.}

proc releaseEvents(d: Document; eventMask: int) {...}{.deprecated, importcpp.}

proc routeEvent(d: Document; event: Event) {...}{.importcpp.}

proc write(d: Document; text: cstring) {...}{.importcpp.}

proc writeln(d: Document; text: cstring) {...}{.importcpp.}

proc querySelector(d: Document; selectors: cstring): Element {...}{.importcpp.}

proc querySelectorAll(d: Document; selectors: cstring): seq[Element] {...}{.importcpp.}

proc blur(e: Element) {...}{.importcpp.}

proc click(e: Element) {...}{.importcpp.}

proc focus(e: Element) {...}{.importcpp.}

proc handleEvent(e: Element; event: Event) {...}{.importcpp.}

proc select(e: Element) {...}{.importcpp.}

proc getElementsByTagName(e: Element; name: cstring): seq[Element] {...}{.importcpp.}

proc getElementsByClassName(e: Element; name: cstring): seq[Element] {...}{.importcpp.}

proc reset(f: FormElement) {...}{.importcpp.}

proc submit(f: FormElement) {...}{.importcpp.}

proc checkValidity(e: FormElement): bool {...}{.importcpp.}

proc reportValidity(e: FormElement): bool {...}{.importcpp.}

proc play(e: EmbedElement) {...}{.importcpp.}

proc stop(e: EmbedElement) {...}{.importcpp.}

proc reload(loc: Location) {...}{.importcpp.}

proc replace(loc: Location; s: cstring) {...}{.importcpp.}

proc back(h: History) {...}{.importcpp.}

proc forward(h: History) {...}{.importcpp.}

proc go(h: History; pagesToJump: int) {...}{.importcpp.}

proc pushState[T](h: History; stateObject: T; title, url: cstring) {...}{.importcpp.}

proc javaEnabled(h: Navigator): bool {...}{.importcpp.}

proc add(c: ClassList; class: cstring) {...}{.importcpp.}

proc remove(c: ClassList; class: cstring) {...}{.importcpp.}

proc contains(c: ClassList; class: cstring): bool {...}{.importcpp.}

proc toggle(c: ClassList; class: cstring) {...}{.importcpp.}

proc getPropertyValue(s: Style; property: cstring): cstring {...}{.importcpp.}

proc removeProperty(s: Style; property: cstring) {...}{.importcpp.}

proc setProperty(s: Style; property, value: cstring; priority = "") {...}{.importcpp.}

proc getPropertyPriority(s: Style; property: cstring): cstring {...}{.importcpp.}

proc preventDefault(ev: Event) {...}{.importcpp.}

proc stopImmediatePropagation(ev: Event) {...}{.importcpp.}

proc stopPropagation(ev: Event) {...}{.importcpp.}

proc getModifierState(ev: KeyboardEvent; keyArg: cstring): bool {...}{.importcpp.}

proc getModifierState(ev: MouseEvent; keyArg: cstring): bool {...}{.importcpp.}

proc identifiedTouch(list: TouchList): Touch {...}{.importcpp.}

proc item(list: TouchList; i: int): Touch {...}{.importcpp.}

proc clearData(dt: DataTransfer; format: cstring) {...}{.importcpp.}

proc getData(dt: DataTransfer; format: cstring): cstring {...}{.importcpp.}

proc setData(dt: DataTransfer; format: cstring; data: cstring) {...}{.importcpp.}

proc setDragImage(dt: DataTransfer; img: Element; xOffset: int64; yOffset: int64) {...}{.
    importcpp.}

proc getAsFile(dti: DataTransferItem): File {...}{.importcpp.}

proc setSelectionRange(e: InputElement; selectionStart: int; selectionEnd: int;
                      selectionDirection: cstring = "none") {...}{.importcpp.}

proc setRangeText(e: InputElement; replacement: cstring; startindex: int = 0;
                 endindex: int = 0; selectionMode: cstring = "preserve") {...}{.importcpp.}

proc setCustomValidity(e: InputElement; error: cstring) {...}{.importcpp.}

proc checkValidity(e: InputElement): bool {...}{.importcpp.}

proc slice(e: Blob; startindex: int = 0; endindex: int = e.size; contentType: cstring = "") {...}{.
    importcpp.}

proc now(p: Performance): float {...}{.importcpp.}

proc getItem(ls: LocalStorage; key: cstring): cstring {...}{.importcpp.}

proc setItem(ls: LocalStorage; key, value: cstring) {...}{.importcpp.}

proc hasItem(ls: LocalStorage; key: cstring): bool {...}{.importcpp.}

proc clear(ls: LocalStorage) {...}{.importcpp.}

proc removeItem(ls: LocalStorage; key: cstring) {...}{.importcpp.}

proc setAttr(n: Node; key, val: cstring) {...}{.importcpp: "#.setAttribute(@)".}

proc decodeURI(uri: cstring): cstring {...}{.importc, nodecl.}

proc encodeURI(uri: cstring): cstring {...}{.importc, nodecl.}

proc escape(uri: cstring): cstring {...}{.importc, nodecl.}

proc unescape(uri: cstring): cstring {...}{.importc, nodecl.}

proc decodeURIComponent(uri: cstring): cstring {...}{.importc, nodecl.}

proc encodeURIComponent(uri: cstring): cstring {...}{.importc, nodecl.}

proc isFinite(x: BiggestFloat): bool {...}{.importc, nodecl.}

proc isNaN(x: BiggestFloat): bool {...}{.importc, nodecl.}

proc newEvent(name: cstring): Event {...}{.importcpp: "new Event(@)", constructor.}

proc getElementsByClass(n: Node; name: cstring): seq[Node] {...}{.
    importcpp: "#.getElementsByClassName(#)", nodecl.}

proc getBoundingClientRect(e: Node): BoundingRect {...}{.
    importcpp: "getBoundingClientRect", nodecl.}

proc clientHeight(): int {...}{.importcpp: "(window.innerHeight || document.documentElement.clientHeight)@",
                        nodecl.}

proc clientWidth(): int {...}{.importcpp: "(window.innerWidth || document.documentElement.clientWidth)@",
                       nodecl.}

proc inViewport(el: Node): bool {...}{.raises: [], tags: [].}

proc scrollTop(e: Node): int {...}{.importcpp: "#.scrollTop", nodecl.}

proc scrollTop=(e: Node; value: int) {...}{.importcpp: "#.scrollTop = #", nodecl.}

proc scrollLeft(e: Node): int {...}{.importcpp: "#.scrollLeft", nodecl.}

proc scrollHeight(e: Node): int {...}{.importcpp: "#.scrollHeight", nodecl.}

proc scrollWidth(e: Node): int {...}{.importcpp: "#.scrollWidth", nodecl.}

proc offsetHeight(e: Node): int {...}{.importcpp: "#.offsetHeight", nodecl.}

proc offsetWidth(e: Node): int {...}{.importcpp: "#.offsetWidth", nodecl.}

proc offsetTop(e: Node): int {...}{.importcpp: "#.offsetTop", nodecl.}

proc offsetLeft(e: Node): int {...}{.importcpp: "#.offsetLeft", nodecl.}