@pixui-dev/pxw 0.1.16

package/lib/h5es-types/v1.9.2/h5es.d.ts

@@ -0,0 +1,1698 @@
+/// <reference no-default-lib="true"/>
+/// <reference lib="es2020" />
+
+/*pix
+  gen: readArg
+*/
+interface EventListener {
+	(evt: Event): void;
+}
+
+/*pix
+  gen: binding
+*/
+/** EventTarget is a DOM interface implemented by objects that can receive events and may have listeners for them. */
+interface EventTarget {
+	/**
+	 * Appends an event listener for events whose type attribute value is type. The callback argument sets the callback that will be invoked when the event is dispatched.
+	 *
+	 * The event listener is appended to target's event listener list and is not appended if it has the same type, callback, and capture.
+	 */
+	addEventListener(type: string, listener: EventListener): void;
+
+	/**
+	 * Dispatches a synthetic event event to target and returns true if either event's cancelable attribute value is false or its preventDefault() method was not invoked, and false otherwise.
+	 */
+	dispatchEvent(event: Event): void;
+
+	/**
+	 * Removes the event listener in target's event listener list with the same type, callback, and options.
+	 */
+	removeEventListener(type: string, callback: EventListener): void;
+}
+
+/*pix
+  gen: binding
+  cpp-class: ElementEvent
+*/
+/** An event which takes place in the DOM. */
+interface Event {
+	/**
+	 * Returns the object to which event is dispatched (its target).
+	 */
+	readonly target: EventTarget | null;
+	/**
+	 * Returns the object whose event listener's callback is currently being invoked.
+	 */
+	readonly currentTarget: EventTarget | null;
+	/**
+	 * Returns the type of event, e.g. "click", "hashchange", or "submit".
+	 */
+	readonly type: string;
+	/** 和stopPropagation()效果一样，只是兼容老代码 */
+	cancelBubble: boolean;
+
+	/**
+	 * When dispatched in a tree, invoking this method prevents event from reaching any objects other than the current object.
+	 */
+	stopPropagation(): void;
+
+	/**
+	 * Returns true if stopPropagation() was invoked successfully, and false otherwise.
+	 */
+	isPropagationStopped(): boolean;
+
+	/**
+	 * If invoked when the cancelable attribute value is true, and while executing a listener for the event with passive set to false, signals to the operation that caused event to be dispatched that it needs to be canceled.
+	 */
+	preventDefault(): void;
+
+	initEvent(type: string, bubbles?: boolean, cancelable?: boolean): void;
+	/**
+	 * MouseEvent: Take the target element as the origin
+	 */
+	readonly offsetX: number;
+	readonly offsetY: number;
+	/**
+	 * MouseEvent: Take the upper left corner of the view as the origin
+	 */
+	readonly clientX: number;
+	readonly clientY: number;
+	readonly screenX: number;
+	readonly screenY: number;
+}
+
+/*pix
+  gen: binding
+*/
+/** Events providing information related to animations. */
+interface AnimationEvent extends Event {
+	readonly name: string;
+}
+
+/*pix
+  gen: binding
+*/
+/** Events providing information related to transitions. */
+interface TransitionEvent extends Event {
+	readonly name: string;
+}
+
+/*pix
+  gen: binding
+*/
+/** KeyboardEvent objects describe a user interaction with the keyboard; each event describes a single interaction between the user and a key (or combination of a key with modifier keys) on the keyboard. */
+interface KeyboardEvent extends Event {
+	readonly key: number;
+    readonly isDown: boolean;
+	readonly altKey: boolean;
+	readonly metaKey: boolean;
+	readonly ctrlKey: boolean;
+	readonly shiftKey: boolean;
+    readonly code: number;
+	hasHandled: boolean;
+}
+
+declare let KeyboardEvent: {
+	prototype: KeyboardEvent;
+};
+
+/*pix
+  gen: binding
+*/
+/** GamepadEvent objects describe a user interaction with the gamepad; each event describes a single interaction between the user and a key (or combination of a key with modifier keys) on the gamepad. */
+interface GamepadEvent extends Event {
+	readonly key: number;
+	readonly index: number;
+	readonly axis: number;
+	readonly isDown: boolean;
+	hasHandled: boolean;
+}
+
+declare let GamepadEvent: {
+	prototype: GamepadEvent;
+};
+
+/*pix
+  gen: binding
+*/
+/** Events providing information related to errors in scripts or in files. */
+interface MouseMoveEvent extends Event {}
+
+/*pix
+	gen: binding
+ */
+interface MouseUpEvent extends Event {
+	readonly button: number;
+}
+
+/*pix
+	gen: binding
+ */
+interface MouseDownEvent extends Event {
+	readonly button: number;
+}
+
+/*pix
+	gen: binding
+ */
+interface MouseClickEvent extends Event {
+	readonly button: number;
+}
+
+/*pix
+	gen: binding
+ */
+interface MouseDragEvent extends MouseMoveEvent {
+	readonly dragged: Node;
+}
+
+interface DataEvent extends Event {
+	data: any;
+	count: number;
+	readonly index: number;
+}
+
+/*pix
+  gen: binding
+*/
+interface WheelEvent extends Event {
+	readonly deltaX: number;
+	readonly deltaY: number;
+	readonly deltaZ: number;
+}
+
+/*pix
+	gen: binding
+ */
+interface TextAreaStateEvent extends Event {
+	readonly state: string;
+	readonly startX: number;
+	readonly startY: number;
+	readonly endX: number;
+	readonly endY: number;
+}
+
+/*pix
+	gen: binding
+ */
+interface ScrollEvent extends Event {}
+
+/*pix
+	gen: binding
+ */
+interface TemplateLoadEvent extends Event {
+	readonly data: any;
+}
+
+/*pix
+	gen: binding
+ */
+interface MessageEvent extends Event {
+	readonly data: string;
+	readonly source: EventTarget;
+}
+
+/*pix
+	gen: binding
+ */
+interface MessageEvent extends Event {
+	readonly data: string;
+	readonly source: EventTarget;
+}
+
+/*pix
+  gen: binding
+*/
+/** Events providing information related to errors in scripts or in files. */
+interface ErrorEvent extends Event {
+	readonly message: string;
+}
+
+/*pix
+  gen: binding
+*/
+interface InputEvent extends UIEvent {
+    readonly value: string | null;
+	readonly data: string | null;
+}
+
+/*pix
+  gen: binding
+*/
+/** A single contact point on a touch-sensitive device. The contact point is commonly a finger or stylus and the device may be a touchscreen or trackpad. */
+interface Touch {
+	readonly clientX: number;
+	readonly clientY: number;
+	readonly identifier: number;
+	readonly target: EventTarget;
+}
+
+/*pix
+  gen: binding
+*/
+/** An event sent when the state of contacts with a touch-sensitive surface changes. This surface can be a touch screen or trackpad, for example. The event can describe one or more points of contact with the screen and includes support for detecting movement, addition and removal of contact points, and so forth. */
+interface TouchEvent extends UIEvent {
+	readonly targetTouches: Touch[];
+	readonly touches: Touch[];
+}
+
+/*pix
+  gen: binding
+  cpp-precompile: BUILD_WITH_RLOTTIE
+*/
+interface LottieEvent<T extends EventTarget = EventTarget> extends Event {
+	readonly currentFrame: number;
+}
+
+/*pix
+  gen: binding
+*/
+interface SlotAttachmentScriptBinding {
+	readonly src: string;
+	readonly handle: number;
+}
+
+/*pix
+  gen: binding
+*/
+interface FileScriptBinding {
+	readonly fullPath: string;
+	readonly name: string;
+	readonly type: string;
+	readonly size: number;
+	readonly lastModified: number;
+}
+
+/*pix
+  gen: binding
+  cpp-class: WebsocketCloseEvent
+*/
+/** A CloseEvent is sent to clients using WebSockets when the connection is closed. This is delivered to the listener indicated by the WebSocket object's onclose attribute. */
+interface CloseEvent extends Event {
+	/**
+	 * Returns the WebSocket connection close code provided by the server.
+	 */
+	readonly code: any;
+	/**
+	 * Returns the WebSocket connection close reason provided by the server.
+	 */
+	readonly reason: any;
+	/**
+	 * Returns true if the connection closed cleanly; false otherwise.
+	 */
+	readonly wasClean: any;
+}
+
+/*pix
+  gen: binding
+  cpp-class: WebsocketMsgEvent
+ */
+interface MsgEvent extends Event {
+	readonly data: any;
+}
+
+type instantEchoType = boolean;
+
+interface WebSocketEventMap {
+	close: CloseEvent;
+	error: Event;
+	message: MsgEvent;
+	open: Event;
+}
+
+/*pix
+  gen: binding
+*/
+/** Provides the API for creating and managing a WebSocket connection to a server, as well as for sending and receiving data on the connection. */
+interface WebSocket extends EventTarget {
+	instantEcho: instantEchoType;
+	/**
+	 * Returns the state of the WebSocket object's connection. It can have the values described below.
+	 */
+	readonly readyState: number;
+	readonly CLOSED: number;
+	readonly CLOSING: number;
+	readonly CONNECTING: number;
+	readonly OPEN: number;
+
+	onclose: ((this: WebSocket, ev: CloseEvent) => any) | null;
+	onerror: ((this: WebSocket, ev: Event) => any) | null;
+	onmessage: ((this: WebSocket, ev: MsgEvent) => any) | null;
+	onopen: ((this: WebSocket, ev: Event) => any) | null;
+
+	/**
+	 * Closes the WebSocket connection, optionally using code as the the WebSocket connection close code and reason as the the WebSocket connection close reason.
+	 */
+	close(code?: number, reason?: string): void;
+	/**
+	 * Transmits data using the WebSocket connection. data can be a string, a Blob, an ArrayBuffer, or an ArrayBufferView.
+	 */
+	send(data: string | ArrayBufferLike | ArrayBufferView): void;
+	zip(data: any): void;
+
+	unzip(data: any): void;
+
+	addEventListener<K extends keyof WebSocketEventMap>(type: K, listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any): void;
+
+	removeEventListener<K extends keyof WebSocketEventMap>(type: K, listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any): void;
+}
+
+declare let WebSocket: {
+	prototype: WebSocket;
+	new (url: string, protocols?: string | string[]): WebSocket;
+	readonly CLOSED: number;
+	readonly CLOSING: number;
+	readonly CONNECTING: number;
+	readonly OPEN: number;
+};
+
+///////////////////////////////////////////////////////////
+
+interface XMLHttpRequestEventMap extends XMLHttpRequestEventTargetEventMap {
+	readystatechange: Event;
+}
+
+type BufferSource = ArrayBufferView | ArrayBuffer;
+type BodyInit = BufferSource | string;
+type XMLHttpRequestResponseType = '' | 'arraybuffer' | 'blob' | 'document' | 'json' | 'text';
+
+/*pix
+  gen: struct
+  convertor: toJS
+*/
+interface NetDebugMsg {
+	total_time?: number /* defaultValue:0.0 */;
+	namelookup_time?: number /* defaultValue:0.0 */;
+	connect_time?: number /* defaultValue:0.0 */;
+	appconnect_time?: number /* defaultValue:0.0 */;
+	pretransfer_time?: number /* defaultValue:0.0 */;
+	redirect_time?: number /* defaultValue:0.0 */;
+	start_transfer_time?: number /* defaultValue:0.0 */;
+	download_size?: number /* defaultValue:0.0 */;
+	upload_size?: number /* defaultValue:0.0 */;
+	req_size?: number /* defaultValue:0.0 */;
+	header_size?: number /* defaultValue:0.0 */;
+	speed_download?: number /* defaultValue:0.0 */;
+	speed_upload?: number /* defaultValue:0.0 */;
+}
+
+/*pix
+  gen: binding
+*/
+/** Use XMLHttpRequest (XHR) objects to interact with servers. You can retrieve data from a URL without having to do a full page refresh. This enables a Web page to update just part of a page without disrupting what the user is doing. */
+interface XMLHttpRequest extends EventTarget {
+	readonly DONE: number /* value:4 */;
+	readonly LOADING: number /* value:3 */;
+	readonly HEADERS_RECEIVED: number /* value:2 */;
+	readonly OPENED: number /* value:1 */;
+	readonly UNSENT: number /* value:0 */;
+	/**
+	 * Returns the associated XMLHttpRequestUpload object. It can be used to gather transmission information when data is transferred to a server.
+	 */
+	readonly upload: XMLHttpRequestUpload;
+
+	readonly status: number;
+	/**
+	 * Returns the response's body.
+	 */
+	readonly response: any;
+
+	readonly statusText: string;
+	/**
+	 * Returns client's state.
+	 */
+	readonly readyState: number;
+	/**
+	 * Returns the text response.
+	 *
+	 * Throws an "InvalidStateError" DOMException if responseType is not the empty string or "text".
+	 */
+	readonly responseText: string;
+
+	readonly responseURL: string;
+	/**
+	 * Can be set to a time in milliseconds. When set to a non-zero value will cause fetching to terminate after the given time has passed. When the time has passed, the request has not yet completed, and the synchronous flag is unset, a timeout event will then be dispatched, or a "TimeoutError" DOMException will be thrown otherwise (for the send() method).
+	 *
+	 * When set: throws an "InvalidAccessError" DOMException if the synchronous flag is set and current global object is a Window object.
+	 */
+	timeout: number;
+	/**
+	 * Returns the response type.
+	 *
+	 * Can be set to change the response type. Values are: the empty string (default), "arraybuffer", "blob", "document", "json", and "text".
+	 *
+	 * When set: setting to "document" is ignored if current global object is not a Window object.
+	 *
+	 * When set: throws an "InvalidStateError" DOMException if state is loading or done.
+	 *
+	 * When set: throws an "InvalidAccessError" DOMException if the synchronous flag is set and current global object is a Window object.
+	 */
+	responseType: XMLHttpRequestResponseType;
+
+	onabort: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
+	onerror: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
+	onload: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
+	onloadend: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
+	onloadstart: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
+	onprogress: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
+	ontimeout: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
+	onreadystatechange: ((this: XMLHttpRequest, ev: Event) => any) | null;
+
+	/**
+	 * Cancels any network activity.
+	 */
+	abort(): void;
+
+	getResponseHeader(name: string): string | null;
+
+	getAllResponseHeaders(): string;
+
+	/**
+	 * Sets the request method, request URL, and synchronous flag.
+	 *
+	 * Throws a "SyntaxError" DOMException if either method is not a valid HTTP method or url cannot be parsed.
+	 *
+	 * Throws a "SecurityError" DOMException if method is a case-insensitive match for `CONNECT`, `TRACE`, or `TRACK`.
+	 *
+	 * Throws an "InvalidAccessError" DOMException if async is false, current global object is a Window object, and the timeout attribute is not zero or the responseType attribute is not the empty string.
+	 */
+	open(method: string, url: string, async: boolean, username?: string | null, password?: string | null): void;
+
+	/**
+	 * Initiates the request. The body argument provides the request body, if any, and is ignored if the request method is GET or HEAD.
+	 *
+	 * Throws an "InvalidStateError" DOMException if either state is not opened or the send() flag is set.
+	 */
+	send(body?: BodyInit | null): void;
+
+	/**
+	 * Combines a header in author request headers.
+	 *
+	 * Throws an "InvalidStateError" DOMException if either state is not opened or the send() flag is set.
+	 *
+	 * Throws a "SyntaxError" DOMException if name is not a header name or if value is not a header value.
+	 */
+	setRequestHeader(name: string, value: string): void;
+
+	/**
+	 * Set xhr request to net debug mode
+	 * Net stat will be saved after req finished
+	 */
+	setDebugMode(isDebug: boolean): void;
+
+	/**
+	 * Return net stat to js
+	 */
+	getDebugMsg(): NetDebugMsg;
+
+	setCurlEasyOpt(opt: number, val: number): void;
+	setCurlHostAddress(hostAddress: string): void;
+    setProxy(url: string, port: number): void;
+
+	addEventListener<K extends keyof XMLHttpRequestEventMap>(type: K, listener: (this: XMLHttpRequest, ev: XMLHttpRequestEventMap[K]) => any): void;
+
+	removeEventListener<K extends keyof XMLHttpRequestEventMap>(type: K, listener: (this: XMLHttpRequest, ev: XMLHttpRequestEventMap[K]) => any): void;
+}
+
+declare let XMLHttpRequest: {
+	prototype: XMLHttpRequest;
+	new (): XMLHttpRequest;
+	readonly DONE: number;
+	readonly HEADERS_RECEIVED: number;
+	readonly LOADING: number;
+	readonly OPENED: number;
+	readonly UNSENT: number;
+};
+
+/*pix
+  gen: binding
+  cpp-class: XmlHttpRequestProgressEvent
+*/
+interface ProgressEvent<T extends EventTarget = EventTarget> extends Event {
+	readonly lengthComputable: boolean;
+	readonly loaded: number;
+	readonly total: number;
+}
+
+interface PopStateEvent<T extends EventTarget = EventTarget> extends Event {
+	readonly target: T | null;
+	readonly state: any;
+}
+
+interface XMLHttpRequestEventTargetEventMap {
+	abort: ProgressEvent<XMLHttpRequestEventTarget>;
+	error: ProgressEvent<XMLHttpRequestEventTarget>;
+	load: ProgressEvent<XMLHttpRequestEventTarget>;
+	loadend: ProgressEvent<XMLHttpRequestEventTarget>;
+	loadstart: ProgressEvent<XMLHttpRequestEventTarget>;
+	progress: ProgressEvent<XMLHttpRequestEventTarget>;
+	timeout: ProgressEvent<XMLHttpRequestEventTarget>;
+}
+
+interface XMLHttpRequestEventTarget extends EventTarget {
+	onabort: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
+	onerror: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
+	onload: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
+	onloadend: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
+	onloadstart: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
+	onprogress: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
+	ontimeout: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
+
+	addEventListener<K extends keyof XMLHttpRequestEventTargetEventMap>(type: K, listener: (this: XMLHttpRequestEventTarget, ev: XMLHttpRequestEventTargetEventMap[K]) => any): void;
+
+	removeEventListener<K extends keyof XMLHttpRequestEventTargetEventMap>(type: K, listener: (this: XMLHttpRequestEventTarget, ev: XMLHttpRequestEventTargetEventMap[K]) => any): void;
+}
+
+/*pix
+  gen: binding
+*/
+interface XMLHttpRequestUpload extends EventTarget {
+	onabort: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
+	onerror: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
+	onload: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
+	onloadend: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
+	onloadstart: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
+	onprogress: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
+	ontimeout: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
+	addEventListener<K extends keyof XMLHttpRequestEventTargetEventMap>(type: K, listener: (this: XMLHttpRequestUpload, ev: XMLHttpRequestEventTargetEventMap[K]) => any): void;
+
+	removeEventListener<K extends keyof XMLHttpRequestEventTargetEventMap>(type: K, listener: (this: XMLHttpRequestUpload, ev: XMLHttpRequestEventTargetEventMap[K]) => any): void;
+}
+
+/*pix
+  gen: binding
+ */
+interface XmlHttpRequestEvent {}
+
+/*pix
+  gen: binding
+ */
+interface XmlHttpRequestErrorEvent {
+	message: string;
+}
+
+/*pix
+  gen: binding
+  cpp-class: DomRect
+*/
+interface DOMRect {
+	readonly height: number;
+	readonly width: number;
+	readonly x: number;
+	readonly y: number;
+	readonly left: number;
+	readonly top: number;
+	readonly right: number;
+	readonly bottom: number;
+}
+
+declare let DOMRect: {
+	prototype: DOMRect;
+	new (element: HTMLElement): DOMRect;
+};
+
+interface EventHandlersEventMap {
+	click: MouseClickEvent;
+	load: Event;
+	mousedown: MouseDownEvent;
+	mousemove: MouseMoveEvent;
+	mouseout: MouseMoveEvent;
+	mouseover: MouseMoveEvent;
+	mouseup: MouseUpEvent;
+	mouseleave: Event;
+	mouseenter: Event;
+	wheel: WheelEvent;
+	animationstart: AnimationEvent;
+	animationend: AnimationEvent;
+	animationiteration: AnimationEvent;
+	transitionstart: TransitionEvent;
+	transitionend: TransitionEvent;
+	drag: MouseDragEvent;
+	dragstart: MouseDragEvent;
+	dragend: MouseDragEvent;
+	dragenter: MouseDragEvent;
+	dragleave: MouseDragEvent;
+	dragover: MouseDragEvent;
+	drop: MouseDragEvent;
+	scroll: Event;
+	touchcancel: TouchEvent;
+	touchend: TouchEvent;
+	touchmove: TouchEvent;
+	touchstart: TouchEvent;
+	change: InputEvent;
+	input: InputEvent;
+	keydown: KeyboardEvent;
+	keypress: KeyboardEvent;
+	keyup: KeyboardEvent;
+}
+
+interface EventHandlers {
+	onclick: ((this: EventHandlers, ev: MouseClickEvent) => any) | null;
+	onload: ((this: EventHandlers, ev: Event) => any) | null;
+	onerror: ((this: EventHandlers, ev: ErrorEvent) => any) | null;
+	onmousedown: ((this: EventHandlers, ev: MouseDownEvent) => any) | null;
+	onmousemove: ((this: EventHandlers, ev: MouseMoveEvent) => any) | null;
+	onmouseout: ((this: EventHandlers, ev: MouseMoveEvent) => any) | null;
+	onmouseover: ((this: EventHandlers, ev: MouseMoveEvent) => any) | null;
+	onmouseup: ((this: EventHandlers, ev: MouseUpEvent) => any) | null;
+	onmouseleave: ((this: EventHandlers, ev: Event) => any) | null;
+	onmouseenter: ((this: EventHandlers, ev: Event) => any) | null;
+	onwheel: ((this: EventHandlers, ev: WheelEvent) => any) | null;
+
+	onanimationstart: ((this: EventHandlers, ev: AnimationEvent) => any) | null;
+	onanimationend: ((this: EventHandlers, ev: AnimationEvent) => any) | null;
+	onanimationiteration: ((this: EventHandlers, ev: AnimationEvent) => any) | null;
+	ontransitionstart: ((this: EventHandlers, ev: TransitionEvent) => any) | null;
+	ontransitionend: ((this: EventHandlers, ev: TransitionEvent) => any) | null;
+
+	ondrag: ((this: EventHandlers, ev: MouseDragEvent) => any) | null;
+	ondragstart: ((this: EventHandlers, ev: MouseDragEvent) => any) | null;
+	ondragend: ((this: EventHandlers, ev: MouseDragEvent) => any) | null;
+	ondragenter: ((this: EventHandlers, ev: MouseDragEvent) => any) | null;
+	ondragleave: ((this: EventHandlers, ev: MouseDragEvent) => any) | null;
+	ondragover: ((this: EventHandlers, ev: MouseDragEvent) => any) | null;
+	ondrop: ((this: EventHandlers, ev: MouseDragEvent) => any) | null;
+
+	onscroll: ((this: EventHandlers, ev: Event) => any) | null;
+
+	ontouchcancel?: ((this: EventHandlers, ev: TouchEvent) => any) | null;
+	ontouchend?: ((this: EventHandlers, ev: TouchEvent) => any) | null;
+	ontouchmove?: ((this: EventHandlers, ev: TouchEvent) => any) | null;
+	ontouchstart?: ((this: EventHandlers, ev: TouchEvent) => any) | null;
+
+	onchange: ((this: EventHandlers, ev: InputEvent) => any) | null;
+	oninput: ((this: EventHandlers, ev: InputEvent) => any) | null;
+	onkeydown: ((this: EventHandlers, ev: KeyboardEvent) => any) | null;
+	onkeypress: ((this: EventHandlers, ev: KeyboardEvent) => any) | null;
+	onkeyup: ((this: EventHandlers, ev: KeyboardEvent) => any) | null;
+}
+
+/*pix
+  gen: struct
+  convertor: toJS
+*/
+interface Attr {
+	name: string;
+	value: string;
+}
+
+/*pix
+  gen: binding
+  cpp-class: H5Element
+*/
+interface Node extends EventTarget {
+	id: string;
+	readonly localName: string;
+	readonly tagName: string;
+	readonly nodeType: number;
+	readonly nodeName: string;
+	readonly ownerDocument: Document;
+	readonly parentNode?: HTMLElement;
+	readonly nextSibling?: NodeOrHTMLElement;
+	/**
+	 * Returns element's first attribute whose qualified name is qualifiedName, and null if there is no such attribute otherwise.
+	 */
+	getAttribute(qualifiedName: string): string | null;
+
+	/**
+	 * Returns true if element has an attribute whose qualified name is qualifiedName, and false otherwise.
+	 */
+	hasAttribute(qualifiedName: string): boolean;
+
+	/**
+	 * Removes element's first attribute whose qualified name is qualifiedName.
+	 */
+	removeAttribute(qualifiedName: string): void;
+
+	/**
+	 * Sets the value of element's first attribute whose qualified name is qualifiedName to value.
+	 */
+	setAttribute(qualifiedName: string, value: string): void;
+
+	className: string;
+	readonly attributes: Attr[];
+	textContent: string | null;
+	focus(): void;
+	blur(): void;
+}
+
+/*pix
+  gen: binding
+  cpp-class: H5ElementText
+*/
+/** The textual content of Element or Attr. If an element has no markup within its content, it has a single child implementing Text that contains the element's text. However, if the element contains markup, it is parsed into information items and Text nodes that form its children. */
+interface Text extends Node {
+	data: string;
+	nodeValue: string;
+}
+
+/*pix
+  gen: binding
+  cpp-class: MediaError
+*/
+interface MediaError {
+	readonly message: string;
+	readonly code: number;
+}
+
+/*pix
+  gen: binding
+  cpp-class: H5ElementAudio
+  with-handlers: AudioEventHandlers
+*/
+interface HTMLAudioElement extends HTMLElement {
+	src: string;
+	loop: boolean;
+	currentTime: number;
+	muted: boolean;
+	readonly duration: number;
+	playbackRate: number;
+	autoPlay: boolean;
+	volume: number;
+	autoPauseOnBacked: boolean;
+	readonly error: MediaError;
+	preload: boolean;
+
+	play(): void;
+
+	pause(): void;
+
+	resume(): void;
+
+	seek(second: number): void;
+
+	stop(): void;
+
+	load(): void;
+
+	canPlayType(format: string): string;
+
+	addEventListener<K extends keyof AudioEventHandlersEventMap>(type: K, listener: (this: HTMLAudioElement, ev: AudioEventHandlersEventMap[K]) => any): void;
+
+	removeEventListener<K extends keyof AudioEventHandlersEventMap>(type: K, listener: (this: HTMLAudioElement, ev: AudioEventHandlersEventMap[K]) => any): void;
+}
+
+/*pix
+  gen: binding
+  cpp-class: H5ElementVideo
+  with-handlers: VideoEventHandlers
+*/
+interface HTMLVideoElement extends HTMLElement {
+    autoPlay: boolean;
+    src: string;
+	loop: boolean;
+    poster: string;
+	currentTime: number;
+	muted: boolean;
+	readonly duration: number;
+    volume: number;
+    readonly error: MediaError;
+	autoPauseOnBacked: boolean;
+	preload: boolean;
+    playbackRate: number;
+    enableCache: boolean;
+    cacheFolder: string;
+    asynStop: boolean;
+
+    play(): void;
+
+	pause(): void;
+
+	resume(): void;
+
+	seek(second: number): void;
+
+	stop(): void;
+
+	load(): void;
+
+    canPlayType(format: string): string;
+
+    clearCacheFolder(folder: string): void;
+
+	addEventListener<K extends keyof VideoEventHandlersEventMap>(type: K, listener: (this: HTMLVideoElement, ev: VideoEventHandlersEventMap[K]) => any): void;
+
+	removeEventListener<K extends keyof VideoEventHandlersEventMap>(type: K, listener: (this: HTMLVideoElement, ev: VideoEventHandlersEventMap[K]) => any): void;
+}
+
+/*pix
+  gen: binding
+  cpp-class: PxLibCustomValue
+*/
+interface PxLibCustomValue extends EventTarget {
+	isNull(): boolean;
+
+	libName(): string;
+}
+
+/*pix
+  gen: binding
+  cpp-class: RenderingContext
+*/
+interface CanvasRenderingContext2D extends HTMLElement {
+	lineWidth: number;
+	fillStyle: string;
+	strokeStyle: string;
+	font: string;
+	lineCap: string;
+	lineJoin: string;
+	textAlign: string;
+	textBaseline: string;
+	globalAlpha: number;
+	globalCompositeOperation: string;
+	canvas: HTMLCanvasElement;
+
+	beginPath(): void;
+
+	closePath(): void;
+
+	moveTo(x: number, y: number): void;
+
+	lineTo(x: number, y: number): void;
+
+	stroke(): void;
+
+	fill(): void;
+
+	arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, anticlockwise: number): void;
+
+	arcTo(fromX: number, fromY: number, toX: number, toY: number, radius: number): void;
+
+	strokeRect(x: number, y: number, w: number, h: number): void;
+
+	fillRect(x: number, y: number, w: number, h: number): void;
+
+	clearRect(x: number, y: number, w: number, h: number): void;
+
+	drawImage(ele: HTMLElement, a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number): void;
+
+	fillText(text: string, x: number, y: number): void;
+
+	strokeText(text: string, x: number, y: number): void;
+
+	save(): void;
+
+	restore(): void;
+
+	rect(x: number, y: number, w: number, h: number): void;
+
+	bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number): void;
+
+	quadraticCurveTo(cpx: number, cpy: number, x: number, y: number): void;
+
+	scale(x: number, y: number): void;
+
+	translate(x: number, y: number): void;
+
+	rotate(angle: number): void;
+
+	measureText(text: string): TexMetrics;
+
+	setTransform(a: number, b: number, c: number, d: number, e: number, f: number): void;
+
+	createLinearGradient(x0: number, y0: number, x1: number, y1: number): CanvasGradient;
+
+	createRadialGradient(x0: number, y0: number, r0: number, x1: number, y1: number, r1: number): CanvasGradient;
+
+	createConicGradient(angle: number, x: number, y: string): CanvasGradient;
+}
+
+/*pix
+      gen: binding
+      cpp-class: TexMetr
+    */
+interface TexMetrics extends EventTarget {
+	readonly width: number;
+}
+
+interface CanvasGradient {
+	addColorStop(offset: number, color: string): void;
+}
+
+/*pix
+  gen: binding
+  cpp-class: H5ElementCanvas
+*/
+interface HTMLCanvasElement extends HTMLElement {
+	width: number;
+	height: number;
+
+	getContext(type: string): CanvasRenderingContext2D;
+
+	toDataURL(type: string): string;
+}
+
+type NodeOrHTMLElement = Node | HTMLElement;
+
+/*pix
+  gen: binding
+  cpp-class: H5ElementTag
+  with-handlers: EventHandlers
+*/
+/** HTMLElement is the most general base class from which all objects in a Document inherit. It only has methods and properties common to all kinds of elements. More specific classes inherit from HTMLElement. */
+interface HTMLElement extends Node, EventHandlers {
+	click(): void;
+
+	appendChild(newChild: NodeOrHTMLElement): NodeOrHTMLElement;
+
+	insertBefore(newChild: NodeOrHTMLElement, refChild?: NodeOrHTMLElement): NodeOrHTMLElement;
+
+	removeChild(oldChild: NodeOrHTMLElement): NodeOrHTMLElement;
+
+	cloneNode(deep: boolean): NodeOrHTMLElement;
+
+	clearRecurise(): void;
+
+	dispatchEvent(event: Event): void;
+
+	getBoundingClientRect(): DOMRect;
+
+	/**
+	 * Returns a HTMLCollection of the elements in the object on which the method was invoked (a document or an element) that have all the classes given by classNames. The classNames argument is interpreted as a space-separated list of classes.
+	 */
+	getElementsByClassName(classNames: string): HTMLElement[];
+
+	/**
+	 * Retrieves a collection of objects based on the specified element name.
+	 * @param name Specifies the name of an element.
+	 */
+	getElementsByTagName(qualifiedName: string): HTMLElement[];
+
+	querySelectorAll(selectors: string): HTMLElement[];
+
+	querySelector(selectors: string): HTMLElement;
+
+	addEventListener<K extends keyof EventHandlersEventMap>(type: K, listener: (this: EventHandlers, ev: EventHandlersEventMap[K]) => any): void;
+
+	removeEventListener<K extends keyof EventHandlersEventMap>(type: K, listener: (this: EventHandlers, ev: EventHandlersEventMap[K]) => any): void;
+
+	readonly childNodes: NodeOrHTMLElement[];
+	readonly children: HTMLElement[];
+	id: string;
+	draggable: boolean;
+	style: CSSStyleDeclaration;
+	innerText: string;
+	innerHTML: string;
+	outerHTML: string;
+	scrollLeft: number;
+	scrollTop: number;
+	firstChild: NodeOrHTMLElement;
+	firstElementChild: NodeOrHTMLElement;
+	lastChild: NodeOrHTMLElement;
+	readonly clientHeight: number;
+	readonly clientWidth: number;
+	readonly scrollHeight: number;
+	readonly scrollWidth: number;
+	className: string;
+	src: string;
+	readonly parentNode?: HTMLElement;
+	readonly attributes: Attr[];
+}
+
+/*pix
+  gen: binding
+  cpp-class: H5ElementDiv
+*/
+interface HTMLDivElement extends HTMLElement {}
+
+/*pix
+  gen: binding
+  cpp-class: H5ElementScript
+*/
+interface HTMLScriptElement extends HTMLElement {
+	async: boolean;
+	/**
+	 * Retrieves the URL to an external file that contains the source code or data.
+	 */
+	src: string;
+	/**
+	 * Retrieves or sets the text of the object as a string.
+	 */
+	text: string;
+	content: string;
+}
+
+/*pix
+  gen: binding
+  cpp-class: H5ElementComment
+*/
+/** Textual notations within markup; although it is generally not visually shown, such comments are available to be read in the source view. */
+interface Comment extends Node {}
+
+/*pix
+  gen: binding
+  cpp-class: H5ElementImage
+*/
+/** Provides special properties and methods for manipulating <img> elements. */
+interface HTMLImageElement extends HTMLElement {
+	src: string;
+	height: number;
+	width: number;
+}
+
+/*pix
+  gen: binding
+  cpp-class: H5ElementLottie
+  with-handlers: LottieEventHandlers
+  cpp-precompile: BUILD_WITH_RLOTTIE
+*/
+interface HTMLLottieElement extends HTMLImageElement, LottieEventHandlers {
+	play(): void;
+
+	stop(): void;
+
+	pause(): void;
+
+	autoPlay: boolean;
+	loop: boolean;
+
+	setDirection(dr: number): void;
+
+	getDuration(inFrames: boolean): number;
+
+	setSpeed(sp: number): void;
+
+	setProperty(...args: any[]): number;
+
+	gotoAndPlay(v: number, isFrame: boolean): void;
+
+	gotoAndStop(v: number, isFrame: boolean): void;
+
+	enableSimd(enable: boolean): void;
+
+	addEventListener<K extends keyof LottieEventHandlersEventMap>(type: K, listener: (this: HTMLLottieElement, ev: LottieEventHandlersEventMap[K]) => any): void;
+
+	removeEventListener<K extends keyof LottieEventHandlersEventMap>(type: K, listener: (this: HTMLLottieElement, ev: LottieEventHandlersEventMap[K]) => any): void;
+}
+
+/*pix
+  gen: binding
+  cpp-class: H5ElementInput
+  with-handlers: InputEventHandlers
+*/
+interface H5ElementInput extends HTMLElement, InputEventHandlers {
+	placeholder: string;
+	value: string;
+	accept: string;
+	multiple: boolean;
+	readonly files: File[];
+
+	addEventListener<K extends keyof InputEventHandlersEventMap>(type: K, listener: (this: H5ElementInput, ev: InputEventHandlersEventMap[K]) => any): void;
+
+	removeEventListener<K extends keyof InputEventHandlersEventMap>(type: K, listener: (this: H5ElementInput, ev: InputEventHandlersEventMap[K]) => any): void;
+}
+
+/*pix
+  gen: binding
+  cpp-class: H5ElementTextArea
+  with-handlers: InputEventHandlers
+*/
+interface HTMLTextAreaElement extends HTMLElement, InputEventHandlers {
+	placeholder: string;
+	value: string;
+
+	updateCursorPosition(x: number, y: number): void;
+	updateSelectionHead(x: number, y: number): void;
+	updateSelectionTail(x: number, y: number): void;
+
+	copy(): void;
+
+	paste(): void;
+
+	cut(): void;
+
+	addEventListener<K extends keyof InputEventHandlersEventMap>(type: K, listener: (this: HTMLTextAreaElement, ev: InputEventHandlersEventMap[K]) => any): void;
+
+	removeEventListener<K extends keyof InputEventHandlersEventMap>(type: K, listener: (this: HTMLTextAreaElement, ev: InputEventHandlersEventMap[K]) => any): void;
+}
+
+/*pix
+  gen: binding
+  cpp-class: H5ElementFragment
+*/
+interface HTMLElementFragment extends HTMLElement {}
+
+/*pix
+  gen: binding
+  cpp-class: H5ElementLink
+*/
+interface HTMLLinkElement extends HTMLElement {}
+
+/*pix
+  gen: binding
+  cpp-class: H5ElementSlot
+*/
+interface HTMLSlotElement extends HTMLElement {
+	src: string;
+	attachment: number;
+	placeholder: string;
+}
+
+/*pix
+  gen: binding
+  cpp-class: H5ElementTextField
+*/
+interface HTMLTextFieldElement extends HTMLDivElement {
+	calcHeight: number;
+}
+
+/*pix
+  gen: binding
+  cpp-class: H5Document
+*/
+interface Document extends Node {
+	readonly nodeType: number /* value:9 */;
+	body: HTMLElement;
+	head: HTMLElement;
+	readonly defaultView: Window;
+	readonly documentElement: HTMLElement;
+	readonly activeElement: HTMLElement;
+	hidden: boolean;
+	visibilityState: string;
+	styleSheets: CSSStyleSheet[];
+
+	createEvent(type: string): Event;
+
+	createElement(tagName: string): HTMLElement;
+
+	createDocumentFragment(): HTMLElementFragment;
+
+	/**
+	 * Creates a text string from the specified value.
+	 * @param data String that specifies the nodeValue property of the text node.
+	 */
+	createTextNode(data: string): Text;
+
+	/**
+	 * Returns a reference to the first object with the specified value of the ID attribute.
+	 * @param elementId String that specifies the ID value.
+	 */
+	getElementById(elementId: string): HTMLElement | null;
+
+	/**
+	 * Returns a HTMLCollection of the elements in the object on which the method was invoked (a document or an element) that have all the classes given by classNames. The classNames argument is interpreted as a space-separated list of classes.
+	 */
+	getElementsByClassName(classNames: string): HTMLElement[];
+
+	/**
+	 * Retrieves a collection of objects based on the specified element name.
+	 * @param name Specifies the name of an element.
+	 */
+	getElementsByTagName(qualifiedName: string): HTMLElement[];
+
+	/**
+	 * Returns the first element that is a descendant of node that matches selectors.
+	 */
+	querySelector<E extends HTMLElement = HTMLElement>(selectors: string): E | null;
+
+	/**
+	 * Returns all element descendants of node that match selectors.
+	 */
+	querySelectorAll<E extends HTMLElement = HTMLElement>(selectors: string): Array<E>;
+}
+
+/*pix
+  gen: binding
+ */
+/** An object that is a CSS declaration block, and exposes style information and various style-related methods and properties. */
+interface CSSStyleDeclaration extends EventTarget {
+	/// begin-style-key
+	font: string /*pix {'no-gen':1} */;
+	fontSize: string /*pix {'no-gen':1} */;
+	fontWeight: string /*pix {'no-gen':1} */;
+	fontStyle: string /*pix {'no-gen':1} */;
+	textDecoration: string /*pix {'no-gen':1} */;
+	fontFamily: string /*pix {'no-gen':1} */;
+	display: string /*pix {'no-gen':1} */;
+	visibility: string /*pix {'no-gen':1} */;
+	opacity: string /*pix {'no-gen':1} */;
+	color: string /*pix {'no-gen':1} */;
+	textShadow: string /*pix {'no-gen':1} */;
+	whiteSpace: string /*pix {'no-gen':1} */;
+	zIndex: string /*pix {'no-gen':1} */;
+	transformOrigin: string /*pix {'no-gen':1} */;
+	transform: string /*pix {'no-gen':1} */;
+	pointerEvents: string /*pix {'no-gen':1} */;
+	PixuiRenderLayer: string /*pix {'no-gen':1} */;
+	background: string /*pix {'no-gen':1} */;
+	backgroundColor: string /*pix {'no-gen':1} */;
+	backgroundImage: string /*pix {'no-gen':1} */;
+	backgroundPosition: string /*pix {'no-gen':1} */;
+	backgroundSize: string /*pix {'no-gen':1} */;
+	backgroundOrigin: string /*pix {'no-gen':1} */;
+	backgroundClip: string /*pix {'no-gen':1} */;
+	backgroundAttachment: string /*pix {'no-gen':1} */;
+	backgroundRepeat: string /*pix {'no-gen':1} */;
+	maskImage: string /*pix {'no-gen':1} */;
+	cursor: string /*pix {'no-gen':1} */;
+	overflow: string /*pix {'no-gen':1} */;
+	overflowStyle: string /*pix {'no-gen':1} */;
+	width: string /*pix {'no-gen':1} */;
+	height: string /*pix {'no-gen':1} */;
+	left: string /*pix {'no-gen':1} */;
+	right: string /*pix {'no-gen':1} */;
+	top: string /*pix {'no-gen':1} */;
+	bottom: string /*pix {'no-gen':1} */;
+	minWidth: string /*pix {'no-gen':1} */;
+	minHeight: string /*pix {'no-gen':1} */;
+	maxWidth: string /*pix {'no-gen':1} */;
+	maxHeight: string /*pix {'no-gen':1} */;
+	margin: string /*pix {'no-gen':1} */;
+	marginLeft: string /*pix {'no-gen':1} */;
+	marginRight: string /*pix {'no-gen':1} */;
+	marginTop: string /*pix {'no-gen':1} */;
+	marginBottom: string /*pix {'no-gen':1} */;
+	padding: string /*pix {'no-gen':1} */;
+	paddingLeft: string /*pix {'no-gen':1} */;
+	paddingRight: string /*pix {'no-gen':1} */;
+	paddingTop: string /*pix {'no-gen':1} */;
+	paddingBottom: string /*pix {'no-gen':1} */;
+	alignContent: string /*pix {'no-gen':1} */;
+	alignItems: string /*pix {'no-gen':1} */;
+	alignSelf: string /*pix {'no-gen':1} */;
+	flexWrap: string /*pix {'no-gen':1} */;
+	justifyContent: string /*pix {'no-gen':1} */;
+	flexGrow: string /*pix {'no-gen':1} */;
+	flexShrink: string /*pix {'no-gen':1} */;
+	aspectRatio: string /*pix {'no-gen':1} */;
+	flexDirection: string /*pix {'no-gen':1} */;
+	position: string /*pix {'no-gen':1} */;
+	flexBasis: string /*pix {'no-gen':1} */;
+	border: string /*pix {'no-gen':1} */;
+	borderImage: string /*pix {'no-gen':1} */;
+	borderImageSource: string /*pix {'no-gen':1} */;
+	borderImageSlice: string /*pix {'no-gen':1} */;
+	borderImageModel: string /*pix {'no-gen':1} */;
+	borderImageRepeat: string /*pix {'no-gen':1} */;
+	borderImagePosition: string /*pix {'no-gen':1} */;
+	borderBottom: string /*pix {'no-gen':1} */;
+	borderTop: string /*pix {'no-gen':1} */;
+	borderLeft: string /*pix {'no-gen':1} */;
+	borderRight: string /*pix {'no-gen':1} */;
+	borderWidth: string /*pix {'no-gen':1} */;
+	borderTopWidth: string /*pix {'no-gen':1} */;
+	borderRightWidth: string /*pix {'no-gen':1} */;
+	borderBottomWidth: string /*pix {'no-gen':1} */;
+	borderLeftWidth: string /*pix {'no-gen':1} */;
+	borderColor: string /*pix {'no-gen':1} */;
+	borderTopColor: string /*pix {'no-gen':1} */;
+	borderRightColor: string /*pix {'no-gen':1} */;
+	borderBottomColor: string /*pix {'no-gen':1} */;
+	borderLeftColor: string /*pix {'no-gen':1} */;
+	borderStyle: string /*pix {'no-gen':1} */;
+	borderTopStyle: string /*pix {'no-gen':1} */;
+	borderRightStyle: string /*pix {'no-gen':1} */;
+	borderBottomStyle: string /*pix {'no-gen':1} */;
+	borderLeftStyle: string /*pix {'no-gen':1} */;
+	borderRadius: string /*pix {'no-gen':1} */;
+	borderRadiusX: string /*pix {'no-gen':1} */;
+	borderRadiusY: string /*pix {'no-gen':1} */;
+	borderTopLeftRadius: string /*pix {'no-gen':1} */;
+	borderTopRightRadius: string /*pix {'no-gen':1} */;
+	borderBottomLeftRadius: string /*pix {'no-gen':1} */;
+	borderBottomRightRadius: string /*pix {'no-gen':1} */;
+	borderTopLeftRadiusX: string /*pix {'no-gen':1} */;
+	borderTopRightRadiusX: string /*pix {'no-gen':1} */;
+	borderBottomRightRadiusX: string /*pix {'no-gen':1} */;
+	borderBottomLeftRadiusX: string /*pix {'no-gen':1} */;
+	borderTopLeftRadiusY: string /*pix {'no-gen':1} */;
+	borderTopRightRadiusY: string /*pix {'no-gen':1} */;
+	borderBottomRightRadiusY: string /*pix {'no-gen':1} */;
+	borderBottomLeftRadiusY: string /*pix {'no-gen':1} */;
+	outline: string /*pix {'no-gen':1} */;
+	outlineWidth: string /*pix {'no-gen':1} */;
+	outlineColor: string /*pix {'no-gen':1} */;
+	outlineStyle: string /*pix {'no-gen':1} */;
+	animation: string /*pix {'no-gen':1} */;
+	animationName: string /*pix {'no-gen':1} */;
+	animationDuration: string /*pix {'no-gen':1} */;
+	animationTimingFunction: string /*pix {'no-gen':1} */;
+	animationIterationCount: string /*pix {'no-gen':1} */;
+	animationDelay: string /*pix {'no-gen':1} */;
+	animationDirection: string /*pix {'no-gen':1} */;
+	animationPlayState: string /*pix {'no-gen':1} */;
+	animationFillMode: string /*pix {'no-gen':1} */;
+	transition: string /*pix {'no-gen':1} */;
+	textStroke: string /*pix {'no-gen':1} */;
+	textStrokeColor: string /*pix {'no-gen':1} */;
+	textStrokeWidth: string /*pix {'no-gen':1} */;
+	lineClamp: string /*pix {'no-gen':1} */;
+	/// end-style-key
+	cssText: string;
+	setProperty(property: string, value: string): void;
+
+	getPropertyValue(property: string): string;
+}
+
+declare let CSSStyleDeclaration: {
+	prototype: CSSStyleDeclaration;
+	new (element: HTMLElement, pseudoElt: HTMLElement): CSSStyleDeclaration;
+};
+
+interface FrameRequestCallback {
+	(time: number): void;
+}
+
+/*pix
+  gen: binding
+  cpp-class: H5BrowserLocation
+*/
+interface Location {
+	/**
+	 * Returns the Location object's URL's fragment (includes leading "#" if non-empty).
+	 *
+	 * Can be set, to navigate to the same URL with a changed fragment (ignores leading "#").
+	 */
+	hash: string;
+	/**
+	 * Returns the Location object's URL's host and port (if different from the default port for the scheme).
+	 *
+	 * Can be set, to navigate to the same URL with a changed host and port.
+	 */
+	host: string;
+	/**
+	 * Returns the Location object's URL.
+	 *
+	 * Can be set, to navigate to the given URL.
+	 */
+	href: string;
+	/**
+	 * Returns the Location object's URL's path.
+	 *
+	 * Can be set, to navigate to the same URL with a changed path.
+	 */
+	pathname: string;
+	/**
+	 * Returns the Location object's URL's port.
+	 *
+	 * Can be set, to navigate to the same URL with a changed port.
+	 */
+	port: string;
+	/**
+	 * Returns the Location object's URL's scheme.
+	 *
+	 * Can be set, to navigate to the same URL with a changed scheme.
+	 */
+	protocol: string;
+	/**
+	 * Returns the Location object's URL's query (includes leading "?" if non-empty).
+	 *
+	 * Can be set, to navigate to the same URL with a changed query (ignores leading "?").
+	 */
+	search: string;
+
+	/**
+	 * Navigates to the given URL.
+	 */
+	assign(url: string): void;
+
+	/**
+	 * Reloads the current page.
+	 */
+	reload(): void;
+
+	/**
+	 * Removes the current page from the session history and navigates to the given URL.
+	 */
+	replace(url: string): void;
+
+	back(): void;
+
+	forward(): void;
+
+	go(step: number): void;
+
+	pushState(state: any, title: string, url: string): void;
+
+	now(): any;
+}
+
+/*pix
+  gen: binding
+  cpp-class: H5DebugConsole
+  end-def: WithName
+*/
+interface console {
+	enable_trace(b: boolean): void;
+
+	info(msg: string, ...arguments: any[]): number;
+	debug(msg: string, ...arguments: any[]): number;
+
+	log(msg: string, ...arguments: any[]): number;
+
+	warn(msg: string, ...arguments: any[]): number;
+
+	error(msg: string, ...arguments: any[]): number;
+
+	assert(msg: string, ...arguments: any[]): number;
+}
+
+interface WindowEventHandlers {
+	// onDOMContentLoaded只能用addEventListener添加
+	// onDOMContentLoaded: ((this: WindowEventHandlers, ev: Event) => any) | null;
+
+	onload: ((this: WindowEventHandlers, ev: Event) => any) | null;
+	onunload: ((this: WindowEventHandlers, ev: Event) => any) | null;
+	onbeforeunload: ((this: WindowEventHandlers, ev: Event) => any) | null;
+	onclose: ((this: WindowEventHandlers, ev: CloseEvent) => any) | null;
+	onclick: ((this: WindowEventHandlers, ev: MouseClickEvent) => any) | null;
+	onmessage: ((this: WindowEventHandlers, ev: MessageEvent) => any) | null;
+	// onpopstate: ((this: WindowEventHandlers, ev: PopStateEvent) => any) | null;
+	onerror: ((this: WindowEventHandlers, ev: ErrorEvent) => any) | null;
+	onresize: ((this: WindowEventHandlers, ev: Event) => any) | null;
+	onscreenresize: ((this: WindowEventHandlers, ev: Event) => any) | null;
+}
+
+interface WindowEventHandlersEventMap {
+	DOMContentLoaded: Event;
+	load: Event;
+	unload: Event;
+	beforeunload: Event;
+	close: CloseEvent;
+	click: Event;
+	message: MessageEvent;
+	error: ErrorEvent;
+	resize: Event;
+	screenresize: Event;
+}
+
+interface AudioEventHandlers extends EventHandlers {
+	onplay: ((this: AudioEventHandlers, ev: Event) => any) | null;
+	onplaying: ((this: AudioEventHandlers, ev: Event) => any) | null;
+	onended: ((this: AudioEventHandlers, ev: Event) => any) | null;
+	onpause: ((this: AudioEventHandlers, ev: Event) => any) | null;
+	onseeking: ((this: AudioEventHandlers, ev: Event) => any) | null;
+	onseeked: ((this: AudioEventHandlers, ev: Event) => any) | null;
+	onerror: ((this: AudioEventHandlers, ev: ErrorEvent) => any) | null;
+	onwaiting: ((this: AudioEventHandlers, ev: Event) => any) | null;
+	oncanplay: ((this: AudioEventHandlers, ev: Event) => any) | null;
+	onloadstart: ((this: AudioEventHandlers, ev: Event) => any) | null;
+	onloadeddata: ((this: AudioEventHandlers, ev: Event) => any) | null;
+	onfirstframe: ((this: AudioEventHandlers, ev: Event) => any) | null;
+}
+
+interface AudioEventHandlersEventMap extends EventHandlersEventMap {
+	seeking: Event;
+	pause: Event;
+	play: Event;
+    loadeddata: Event;
+    loadstart:Event;
+    canplay: Event;
+    waiting: Event;
+    error: Event;
+	playing: Event;
+	ended: Event;
+	seeked: Event;
+}
+
+interface VideoEventHandlers extends EventHandlers {
+	onplay: ((this: VideoEventHandlers, ev: Event) => any) | null;
+	onplaying: ((this: VideoEventHandlers, ev: Event) => any) | null;
+	onended: ((this: VideoEventHandlers, ev: Event) => any) | null;
+	onpause: ((this: VideoEventHandlers, ev: Event) => any) | null;
+	onseeking: ((this: VideoEventHandlers, ev: Event) => any) | null;
+	onseeked: ((this: VideoEventHandlers, ev: Event) => any) | null;
+	onerror: ((this: VideoEventHandlers, ev: ErrorEvent) => any) | null;
+	onwaiting: ((this: VideoEventHandlers, ev: Event) => any) | null;
+	oncanplay: ((this: VideoEventHandlers, ev: Event) => any) | null;
+	onloadstart: ((this: VideoEventHandlers, ev: Event) => any) | null;
+	onloadeddata: ((this: VideoEventHandlers, ev: Event) => any) | null;
+	onfirstframe: ((this: VideoEventHandlers, ev: Event) => any) | null;
+    onopencache: ((this: VideoEventHandlers, ev: Event) => any) | null;
+}
+
+interface VideoEventHandlersEventMap extends EventHandlersEventMap {
+	seeking: Event;
+	pause: Event;
+	play: Event;
+    loadeddata: Event;
+    loadstart:Event;
+    canplay: Event;
+    waiting: Event;
+    error: Event;
+	playing: Event;
+	ended: Event;
+	seeked: Event;
+	firstframe: Event;
+    opencache: Event;
+}
+
+interface LottieEventHandlers extends EventHandlers {
+	oncomplete: ((this: LottieEventHandlers, ev: Event) => any) | null;
+	onenterframe: ((this: LottieEventHandlers, ev: LottieEvent) => any) | null;
+}
+
+interface LottieEventHandlersEventMap extends EventHandlersEventMap {
+	complete: Event;
+	enterframe: LottieEvent;
+}
+
+interface InputEventHandlers extends EventHandlers {
+	onchange: ((this: InputEventHandlers, ev: Event) => any) | null;
+	oninput: ((this: InputEventHandlers, ev: Event) => any) | null;
+}
+
+interface InputEventHandlersEventMap extends EventHandlersEventMap {
+	change: Event;
+	input: Event;
+}
+
+interface ScriptExternalEventHandlers {
+	onmessage: ((this: ScriptExternalEventHandlers, ev: MessageEvent) => any) | null;
+}
+
+interface ScriptExternalEventHandlersEventMap {
+	message: MessageEvent;
+}
+
+/*pix
+  gen: binding
+  cpp-class: H5Screen
+ */
+interface Screen {
+	readonly height: number;
+	readonly width: number;
+}
+
+/*pix
+  gen: binding
+  cpp-class: H5Window
+  with-handlers: WindowEventHandlers
+*/
+interface Window extends EventTarget, WindowEventHandlers {
+	readonly innerHeight: number;
+	readonly innerWidth: number;
+	// readonly document: Document;
+	id: number;
+	location: Location;
+	history: Location;
+	performance: Location;
+	opener: number;
+	readonly scrollX: number;
+	readonly scrollY: number;
+	readonly screen: Screen;
+	readonly screenX: number;
+	readonly screenY: number;
+	httpVersion: number;
+	netEncodingMode: string;
+	netThreadMode: string;
+	netTimeout: number;
+	targetApi: number;
+
+	open(url?: string, target?: string, features?: string, replace?: boolean): number;
+
+	postMessage(message: any, id?: number | null): void;
+
+	close(): void;
+
+	alert(message: string): void;
+
+	blur(): void;
+
+	confirm(message: string): boolean;
+
+	prompt(message: string, defaultValue?: string): string | null;
+
+	focus(): void;
+
+	getComputedStyle(elt: HTMLElement, pseudoElt?: string | null): CSSStyleDeclaration;
+
+	cancelAnimationFrame(handle: number): void;
+
+	requestAnimationFrame(callback: FrameRequestCallback): number;
+
+	clearInterval(handle?: number): void;
+
+	clearTimeout(handle?: number): void;
+
+	setInterval(handler: Function, timeout?: number, ...arguments: any[]): number;
+
+	setTimeout(handler: Function, timeout?: number, ...arguments: any[]): number;
+
+	moveBy(x: number, y: number): void;
+
+	moveTo(x: number, y: number): void;
+
+	resizeBy(x: number, y: number): void;
+
+	resizeTo(width: number, height: number): void;
+
+	scrollBy(x: number, y: number): void;
+
+	scrollTo(x: number, y: number): void;
+
+	atob(strToDecode: string): string;
+
+	btoa(strToEncode: string): string;
+
+	addEventListener<K extends keyof WindowEventHandlersEventMap>(type: K, listener: (this: Window, ev: WindowEventHandlersEventMap[K]) => any): void;
+
+	removeEventListener<K extends keyof WindowEventHandlersEventMap>(type: K, listener: (this: Window, ev: WindowEventHandlersEventMap[K]) => any): void;
+
+	setNetReferer(referer: string): void;
+}
+
+/*pix
+  gen: binding
+  cpp-class: H5Storage
+ */
+interface Storage {
+	key(index: number): string;
+	getItem(keyName: string): string;
+	setItem(keyName: string, value: string): void;
+	removeItem(keyName: string): void;
+	clear(): void;
+	length: number;
+}
+
+/*pix
+  gen: binding
+  cpp-class: H5CSSStyleRule
+ */
+interface CSSRule {
+	readonly cssText: string;
+	readonly selectorText: string;
+}
+
+/*pix
+  gen: binding
+  cpp-class: H5CSSStyleSheet
+ */
+interface CSSStyleSheet {
+	cssRules: CSSRule[];
+}
+
+declare var document: Document;
+declare var window: Window;
+declare var console: console;
+
+declare function clearInterval(id: number | undefined): void;
+declare function clearTimeout(id: number | undefined): void;
+declare function setInterval(handler: TimerHandler, timeout?: number, ...arguments: any[]): number;
+declare function setTimeout(handler: TimerHandler, timeout?: number, ...arguments: any[]): number;
+
+declare var event: Event | undefined;
+declare var external: External;
+declare var location: Location;
+declare var navigator: Navigator;