@startuml
namespace __global {
    interface Window {
        +applicationCache: ApplicationCache
        +clientInformation: Navigator
        +closed: boolean
        +customElements: CustomElementRegistry
        +defaultStatus: string
        +devicePixelRatio: number
        +doNotTrack: string
        +document: Document
        +event: Event
        +external: External
        +frameElement: Element
        +frames: Window
        +history: History
        +innerHeight: number
        +innerWidth: number
        +isSecureContext: boolean
        +length: number
        +location: Location
        +locationbar: BarProp
        +menubar: BarProp
        +msContentScript: ExtensionScriptApis
        +name: string
        +navigator: Navigator
        +offscreenBuffering: string | boolean
        +oncompassneedscalibration: (this: Window, ev: Event) => any
        +ondevicelight: (this: Window, ev: DeviceLightEvent) => any
        +ondevicemotion: (this: Window, ev: DeviceMotionEvent) => any
        +ondeviceorientation: (this: Window, ev: DeviceOrientationEvent) => any
        +ondeviceorientationabsolute: (this: Window, ev: DeviceOrientationEvent) => any
        +onmousewheel: (this: Window, ev: Event) => any
        +onmsgesturechange: (this: Window, ev: Event) => any
        +onmsgesturedoubletap: (this: Window, ev: Event) => any
        +onmsgestureend: (this: Window, ev: Event) => any
        +onmsgesturehold: (this: Window, ev: Event) => any
        +onmsgesturestart: (this: Window, ev: Event) => any
        +onmsgesturetap: (this: Window, ev: Event) => any
        +onmsinertiastart: (this: Window, ev: Event) => any
        +onmspointercancel: (this: Window, ev: Event) => any
        +onmspointerdown: (this: Window, ev: Event) => any
        +onmspointerenter: (this: Window, ev: Event) => any
        +onmspointerleave: (this: Window, ev: Event) => any
        +onmspointermove: (this: Window, ev: Event) => any
        +onmspointerout: (this: Window, ev: Event) => any
        +onmspointerover: (this: Window, ev: Event) => any
        +onmspointerup: (this: Window, ev: Event) => any
        +onorientationchange: (this: Window, ev: Event) => any
        +onreadystatechange: (this: Window, ev: ProgressEvent<Window>) => any
        +onvrdisplayactivate: (this: Window, ev: Event) => any
        +onvrdisplayblur: (this: Window, ev: Event) => any
        +onvrdisplayconnect: (this: Window, ev: Event) => any
        +onvrdisplaydeactivate: (this: Window, ev: Event) => any
        +onvrdisplaydisconnect: (this: Window, ev: Event) => any
        +onvrdisplayfocus: (this: Window, ev: Event) => any
        +onvrdisplaypointerrestricted: (this: Window, ev: Event) => any
        +onvrdisplaypointerunrestricted: (this: Window, ev: Event) => any
        +onvrdisplaypresentchange: (this: Window, ev: Event) => any
        +opener: any
        +orientation: string | number
        +outerHeight: number
        +outerWidth: number
        +pageXOffset: number
        +pageYOffset: number
        +parent: Window
        +personalbar: BarProp
        +screen: Screen
        +screenLeft: number
        +screenTop: number
        +screenX: number
        +screenY: number
        +scrollX: number
        +scrollY: number
        +scrollbars: BarProp
        +self: Window & typeof globalThis
        +speechSynthesis: SpeechSynthesis
        +status: string
        +statusbar: BarProp
        +styleMedia: StyleMedia
        +toolbar: BarProp
        +top: Window
        +window: Window & typeof globalThis
        +alert(message?: any): void
        +blur(): void
        +captureEvents(): void
        +close(): void
        +confirm(message?: string): boolean
        +departFocus(navigationReason: NavigationReason, origin: FocusNavigationOrigin): void
        +focus(): void
        +getComputedStyle(elt: Element, pseudoElt?: string): CSSStyleDeclaration
        +getMatchedCSSRules(elt: Element, pseudoElt?: string): CSSRuleList
        +getSelection(): Selection
        +matchMedia(query: string): MediaQueryList
        +moveBy(x: number, y: number): void
        +moveTo(x: number, y: number): void
        +msWriteProfilerMark(profilerMarkName: string): void
        +open(url?: string, target?: string, features?: string, replace?: boolean): Window
        +postMessage(message: any, targetOrigin: string, transfer?: Transferable[]): void
        +print(): void
        +prompt(message?: string, _default?: string): string
        +releaseEvents(): void
        +resizeBy(x: number, y: number): void
        +resizeTo(x: number, y: number): void
        +scroll(options?: ScrollToOptions): void
        +scroll(x: number, y: number): void
        +scrollBy(options?: ScrollToOptions): void
        +scrollBy(x: number, y: number): void
        +scrollTo(options?: ScrollToOptions): void
        +scrollTo(x: number, y: number): void
        +stop(): void
        +webkitCancelAnimationFrame(handle: number): void
        +webkitConvertPointFromNodeToPage(node: Node, pt: WebKitPoint): WebKitPoint
        +webkitConvertPointFromPageToNode(node: Node, pt: WebKitPoint): WebKitPoint
        +webkitRequestAnimationFrame(callback: FrameRequestCallback): number
        +addEventListener(type: K, listener: (this: Window, ev: WindowEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void
        +addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void
        +removeEventListener(type: K, listener: (this: Window, ev: WindowEventMap[K]) => any, options?: boolean | EventListenerOptions): void
        +removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void
        +CDN_VERSION: string
        +Laya3D: any
    }
}
enum SkillMap {
    TrackFish
    Freezing
    Bomb
    Auto
}
class Const {
    +{static} NOT_ACTIVE: number
    +{static} ACTIVE_INHIERARCHY: number
    +{static} AWAKED: number
    +{static} NOT_READY: number
    +{static} DISPLAY: number
    +{static} HAS_ZORDER: number
    +{static} HAS_MOUSE: number
    +{static} DISPLAYED_INSTAGE: number
    +{static} DRAWCALL_OPTIMIZE: number
}
class Handler {
    +caller: Object
    +method: Function
    +args: any[]
    +once: boolean
    #_id: number
    +setTo(caller: any, method: Function, args: any[], once?: boolean): Handler
    +run(): any
    +runWith(data: any): any
    +clear(): Handler
    +recover(): void
    #{static} _pool: Handler[]
    -{static} _gid: number
    +{static} create(caller: any, method: Function, args?: any[], once?: boolean): Handler
}
class EventDispatcher {
    -_events: any
    +hasListener(type: string): boolean
    +event(type: string, data?: any): boolean
    +on(type: string, caller: any, listener: Function, args?: any[]): EventDispatcher
    +once(type: string, caller: any, listener: Function, args?: any[]): EventDispatcher
    +_createListener(type: string, caller: any, listener: Function, args: any[], once: boolean, offBefore?: boolean): EventDispatcher
    +off(type: string, caller: any, listener: Function, onceOnly?: boolean): EventDispatcher
    +offAll(type?: string): EventDispatcher
    +offAllCaller(caller: any): EventDispatcher
    -_recoverHandlers(arr: any): void
    +isMouseEvent(type: string): boolean
    +{static} MOUSE_EVENTS: any
}
class EventHandler extends Handler {
    +recover(): void
    #{static} _pool: any[]
    +{static} create(caller: any, method: Function, args?: any[], once?: boolean): Handler
}
class URL {
    -_url: string
    -_path: string
    +url: string
    +path: string
    +{static} version: any
    +{static} exportSceneToJson: boolean
    +{static} _basePath: string
    +{static} rootPath: string
    +{static} basePath: string
    +{static} basePath: string
    +{static} customFormat: Function
    +{static} formatURL(url: string): string
    +{static} _formatRelativePath(value: string): string
    +{static} getPath(url: string): string
    +{static} getFileName(url: string): string
    -{static} _adpteTypeList: any[]
    +{static} getAdptedFilePath(url: string): string
}
interface ICreateResource {
    +_setCreateURL(url: string): void
}
interface IDestroy {
    +destroyed: boolean
    +destroy(): void
}
class Resource extends EventDispatcher implements ICreateResource, IDestroy {
    #_id: number
    -_url: string
    -_cpuMemory: number
    -_gpuMemory: number
    -_destroyed: boolean
    #_referenceCount: number
    +lock: boolean
    +name: string
    +id: number
    +url: string
    +cpuMemory: number
    +gpuMemory: number
    +destroyed: boolean
    +referenceCount: number
    +_setCPUMemory(value: number): void
    +_setGPUMemory(value: number): void
    +_setCreateURL(url: string): void
    +_addReference(count?: number): void
    +_removeReference(count?: number): void
    +_clearReference(): void
    #_recoverResource(): void
    #_disposeResource(): void
    #_activeResource(): void
    +destroy(): void
    -{static} _uniqueIDCounter: number
    -{static} _idResourcesMap: any
    -{static} _urlResourcesMap: any
    -{static} _cpuMemory: number
    -{static} _gpuMemory: number
    +{static} cpuMemory: number
    +{static} gpuMemory: number
    +{static} _addCPUMemory(size: number): void
    +{static} _addGPUMemory(size: number): void
    +{static} _addMemory(cpuSize: number, gpuSize: number): void
    +{static} getResourceByID(id: number): Resource
    +{static} getResourceByURL(url: string, index?: number): Resource
    +{static} destroyUnusedResources(): void
}
class Bitmap extends Resource {
    #_width: number
    #_height: number
    +width: number
    +width: number
    +height: number
    +height: number
    +_getSource(): any
}
class VertexArrayObject
enum TextureFormat {
    R8G8B8
    R8G8B8A8
    R5G6B5
    Alpha8
    DXT1
    DXT5
    ETC1RGB
    PVRTCRGB_2BPPV
    PVRTCRGBA_2BPPV
    PVRTCRGB_4BPPV
    PVRTCRGBA_4BPPV
    R32G32B32A32
}
enum RenderTextureFormat {
    R8G8B8
    R8G8B8A8
    Alpha8
    R16G16B16A16
}
enum RenderTextureDepthFormat {
    DEPTH_16
    STENCIL_8
    DEPTHSTENCIL_16_8
    DEPTHSTENCIL_NONE
}
class SystemUtils {
    +{static} _maxTextureCount: number
    +{static} _maxTextureSize: number
    +{static} _shaderCapailityLevel: number
    +{static} maxTextureCount: number
    +{static} maxTextureSize: number
    +{static} shaderCapailityLevel: number
    +{static} supportTextureFormat(format: number): boolean
    +{static} supportRenderTextureFormat(format: number): boolean
}
class LayaGPU {
    -_gl: any
    -_vaoExt: any
    -_angleInstancedArrays: any
    +_isWebGL2: boolean
    +_oesTextureHalfFloat: any
    +_oes_element_index_uint: any
    +_oesTextureHalfFloatLinear: any
    +_oesTextureFloat: any
    +_extShaderTextureLod: any
    +_extTextureFilterAnisotropic: any
    +_compressedTextureS3tc: any
    +_compressedTexturePvrtc: any
    +_compressedTextureEtc1: any
    -_getExtension(name: string): any
    +createVertexArray(): any
    +bindVertexArray(vertexArray: any): void
    +deleteVertexArray(vertexArray: any): void
    +isVertexArray(vertexArray: any): void
    +drawElementsInstanced(mode: number, count: number, type: number, offset: number, instanceCount: number): void
    +drawArraysInstanced(mode: number, first: number, count: number, instanceCount: number): void
    +vertexAttribDivisor(index: number, divisor: number): void
    +supportInstance(): boolean
    +supportElementIndexUint32(): boolean
    -{static} _extentionVendorPrefixes: any[]
}
class LayaGL {
    +{static} ARRAY_BUFFER_TYPE_DATA: number
    +{static} ARRAY_BUFFER_TYPE_CMD: number
    +{static} ARRAY_BUFFER_REF_REFERENCE: number
    +{static} ARRAY_BUFFER_REF_COPY: number
    +{static} UPLOAD_SHADER_UNIFORM_TYPE_ID: number
    +{static} UPLOAD_SHADER_UNIFORM_TYPE_DATA: number
    +{static} instance: WebGLRenderingContext
    +{static} layaGPUInstance: LayaGPU
}
class WebGLContext {
    -{static} _activeTextures: any[]
    -{static} _useProgram: any
    -{static} _depthTest: boolean
    -{static} _depthMask: boolean
    -{static} _depthFunc: number
    -{static} _blend: boolean
    -{static} _blendEquation: number
    -{static} _blendEquationRGB: number
    -{static} _blendEquationAlpha: number
    -{static} __sFactor: number
    -{static} __dFactor: number
    -{static} _sFactorRGB: number
    -{static} _dFactorRGB: number
    -{static} _sFactorAlpha: number
    -{static} _dFactorAlpha: number
    -{static} _cullFace: boolean
    -{static} _frontFace: number
    -{static} _activedTextureID: number
    +{static} _glTextureIDs: any[]
    +{static} mainContext: WebGLRenderingContext
    +{static} __init__(): void
    +{static} _sFactor: number
    +{static} _sFactor: number
    +{static} _dFactor: number
    +{static} _dFactor: number
    +{static} useProgram(gl: WebGLRenderingContext, program: any): boolean
    +{static} setDepthTest(gl: WebGLRenderingContext, value: boolean): void
    +{static} setDepthMask(gl: WebGLRenderingContext, value: boolean): void
    +{static} setDepthFunc(gl: WebGLRenderingContext, value: number): void
    +{static} setBlend(gl: WebGLRenderingContext, value: boolean): void
    +{static} setBlendEquation(gl: WebGLRenderingContext, blendEquation: number): void
    +{static} setBlendEquationSeparate(gl: WebGLRenderingContext, blendEquationRGB: number, blendEquationAlpha: number): void
    +{static} setBlendFunc(gl: WebGLRenderingContext, sFactor: number, dFactor: number): void
    +{static} setBlendFuncSeperate(gl: WebGLRenderingContext, srcRGB: number, dstRGB: number, srcAlpha: number, dstAlpha: number): void
    +{static} setCullFace(gl: WebGLRenderingContext, value: boolean): void
    +{static} setFrontFace(gl: WebGLRenderingContext, value: number): void
    +{static} activeTexture(gl: WebGLRenderingContext, textureID: number): void
    +{static} bindTexture(gl: WebGLRenderingContext, target: any, texture: any): void
    +{static} __init_native(): void
    +{static} useProgramForNative(gl: WebGLRenderingContext, program: any): boolean
    +{static} setDepthTestForNative(gl: WebGLRenderingContext, value: boolean): void
    +{static} setDepthMaskForNative(gl: WebGLRenderingContext, value: boolean): void
    +{static} setDepthFuncForNative(gl: WebGLRenderingContext, value: number): void
    +{static} setBlendForNative(gl: WebGLRenderingContext, value: boolean): void
    +{static} setBlendFuncForNative(gl: WebGLRenderingContext, sFactor: number, dFactor: number): void
    +{static} setCullFaceForNative(gl: WebGLRenderingContext, value: boolean): void
    +{static} setFrontFaceForNative(gl: WebGLRenderingContext, value: number): void
    +{static} activeTextureForNative(gl: WebGLRenderingContext, textureID: number): void
    +{static} bindTextureForNative(gl: WebGLRenderingContext, target: any, texture: any): void
    +{static} bindVertexArrayForNative(gl: WebGLContext, vertexArray: any): void
}
enum FilterMode {
    Point
    Bilinear
    Trilinear
}
enum WarpMode {
    Repeat
    Clamp
}
class BaseTexture extends Bitmap {
    #_readyed: boolean
    #_glTextureType: number
    #_glTexture: any
    #_format: number
    #_mipmap: boolean
    #_wrapModeU: WarpMode
    #_wrapModeV: WarpMode
    #_filterMode: FilterMode
    #_anisoLevel: number
    #_mipmapCount: number
    +mipmap: boolean
    +format: number
    +wrapModeU: number
    +wrapModeU: number
    +wrapModeV: number
    +wrapModeV: number
    +filterMode: FilterMode
    +filterMode: FilterMode
    +anisoLevel: number
    +anisoLevel: number
    +mipmapCount: number
    +defaulteTexture: BaseTexture
    +_getFormatByteCount(): number
    #_isPot(size: number): boolean
    #_getGLFormat(): number
    #_setFilterMode(value: FilterMode): void
    #_setWarpMode(orientation: number, mode: number): void
    #_setAnisotropy(value: number): void
    #_disposeResource(): void
    +_getSource(): any
    +generateMipmap(): void
    +{static} _rgbmRange: number
    +{static} FORMAT_R8G8B8: number
    +{static} FORMAT_R8G8B8A8: number
    +{static} FORMAT_ALPHA8: number
    +{static} FORMAT_DXT1: number
    +{static} FORMAT_DXT5: number
    +{static} FORMAT_ETC1RGB: number
    +{static} FORMAT_PVRTCRGB_2BPPV: number
    +{static} FORMAT_PVRTCRGBA_2BPPV: number
    +{static} FORMAT_PVRTCRGB_4BPPV: number
    +{static} FORMAT_PVRTCRGBA_4BPPV: number
    +{static} RENDERTEXTURE_FORMAT_RGBA_HALF_FLOAT: number
    +{static} FORMAT_R32G32B32A32: number
    +{static} FORMAT_DEPTH_16: number
    +{static} FORMAT_STENCIL_8: number
    +{static} FORMAT_DEPTHSTENCIL_16_8: number
    +{static} FORMAT_DEPTHSTENCIL_NONE: number
    +{static} FILTERMODE_POINT: number
    +{static} FILTERMODE_BILINEAR: number
    +{static} FILTERMODE_TRILINEAR: number
    +{static} WARPMODE_REPEAT: number
    +{static} WARPMODE_CLAMP: number
}
class Texture2D extends BaseTexture {
    -_canRead: boolean
    -_pixels: Uint8Array | Uint16Array | Float32Array
    +defaulteTexture: BaseTexture
    -_gpuCompressFormat(): boolean
    -_setPixels(pixels: Uint8Array | Uint16Array | Float32Array, miplevel: number, width: number, height: number): void
    -_calcualatesCompressedDataSize(format: number, width: number, height: number): number
    -_pharseDDS(arrayBuffer: ArrayBuffer): void
    -_pharseKTX(arrayBuffer: ArrayBuffer): void
    -_pharsePVR(arrayBuffer: ArrayBuffer): void
    +_upLoadCompressedTexImage2D(data: ArrayBuffer, width: number, height: number, miplevelCount: number, dataOffset: number, imageSizeOffset: number): void
    +loadImageSource(source: any, premultiplyAlpha?: boolean): void
    +setPixels(pixels: Uint8Array | Uint16Array | Float32Array, miplevel?: number): void
    +setSubPixels(x: number, y: number, width: number, height: number, pixels: Uint8Array | Uint16Array | Float32Array, miplevel?: number): void
    +setCompressData(data: ArrayBuffer): void
    #_recoverResource(): void
    +getPixels(): Uint8Array | Uint16Array | Float32Array
    +{static} TEXTURE2D: string
    +{static} grayTexture: Texture2D
    +{static} whiteTexture: Texture2D
    +{static} blackTexture: Texture2D
    +{static} __init__(): void
    +{static} _parse(data: any, propertyParams?: any, constructParams?: any[]): Texture2D
    +{static} load(url: string, complete: Handler): void
}
class Pool {
    -{static} _CLSID: number
    -{static} POOLSIGN: string
    -{static} _poolDic: any
    +{static} getPoolBySign(sign: string): any[]
    +{static} clearBySign(sign: string): void
    +{static} recover(sign: string, item: any): void
    +{static} recoverByClass(instance: any): void
    -{static} _getClassSign(cla: new () => any): string
    +{static} createByClass(cls: new () => any): any
    +{static} getItemByClass(sign: string, cls: new () => any): any
    +{static} getItemByCreateFun(sign: string, createFun: Function, caller?: any): any
    +{static} getItem(sign: string): any
}
class Point {
    +x: number
    +y: number
    +setTo(x: number, y: number): Point
    +reset(): Point
    +recover(): void
    +distance(x: number, y: number): number
    +toString(): string
    +normalize(): void
    +copy(point: Point): Point
    +{static} TEMP: Point
    +{static} EMPTY: Point
    +{static} create(): Point
}
class Rectangle {
    +x: number
    +y: number
    +width: number
    +height: number
    +right: number
    +bottom: number
    +setTo(x: number, y: number, width: number, height: number): Rectangle
    +reset(): Rectangle
    +recover(): void
    +copyFrom(source: Rectangle): Rectangle
    +contains(x: number, y: number): boolean
    +intersects(rect: Rectangle): boolean
    +intersection(rect: Rectangle, out?: Rectangle): Rectangle
    +union(source: Rectangle, out?: Rectangle): Rectangle
    +clone(out?: Rectangle): Rectangle
    +toString(): string
    +equals(rect: Rectangle): boolean
    +addPoint(x: number, y: number): Rectangle
    +_getBoundPoints(): number[]
    +isEmpty(): boolean
    +{static} EMPTY: Rectangle
    +{static} TEMP: Rectangle
    -{static} _temB: number[]
    -{static} _temA: number[]
    +{static} create(): Rectangle
    +{static} _getBoundPointS(x: number, y: number, width: number, height: number): any[]
    +{static} _getWrapRec(pointList: ArrayLike<number>, rst?: Rectangle): Rectangle
}
class Config {
    +{static} animationInterval: number
    +{static} isAntialias: boolean
    +{static} isAlpha: boolean
    +{static} premultipliedAlpha: boolean
    +{static} isStencil: boolean
    +{static} preserveDrawingBuffer: boolean
    +{static} webGL2D_MeshAllocMaxMem: boolean
    +{static} is2DPixelArtGame: boolean
    +{static} useWebGL2: boolean
    +{static} useRetinalCanvas: boolean
}
class Matrix {
    +a: number
    +b: number
    +c: number
    +d: number
    +tx: number
    +ty: number
    +_bTransform: boolean
    +identity(): Matrix
    +_checkTransform(): boolean
    +setTranslate(x: number, y: number): Matrix
    +translate(x: number, y: number): Matrix
    +scale(x: number, y: number): Matrix
    +rotate(angle: number): Matrix
    +skew(x: number, y: number): Matrix
    +invertTransformPoint(out: Point): Point
    +transformPoint(out: Point): Point
    +transformPointN(out: Point): Point
    +getScaleX(): number
    +getScaleY(): number
    +invert(): Matrix
    +setTo(a: number, b: number, c: number, d: number, tx: number, ty: number): Matrix
    +concat(matrix: Matrix): Matrix
    +scaleEx(x: number, y: number): void
    +rotateEx(angle: number): void
    +clone(): Matrix
    +copyTo(dec: Matrix): Matrix
    +toString(): string
    +destroy(): void
    +recover(): void
    +{static} EMPTY: Matrix
    +{static} TEMP: Matrix
    +{static} _createFun: Function
    +{static} mul(m1: Matrix, m2: Matrix, out: Matrix): Matrix
    +{static} mul16(m1: Matrix, m2: Matrix, out: any[]): any[]
    +{static} create(): Matrix
}
interface IFilter {
    +type: number
}
class CacheStyle {
    +cacheAs: string
    +enableCanvasRender: boolean
    +userSetCache: string
    +cacheForFilters: boolean
    +staticCache: boolean
    +reCache: boolean
    +mask: Sprite
    +maskParent: Sprite
    +filters: any[]
    +cacheRect: Rectangle
    +canvas: HTMLCanvas
    +filterCache: any
    +hasGlowFilter: boolean
    +needBitmapCache(): boolean
    +needEnableCanvasRender(): boolean
    +releaseContext(): void
    +createContext(): void
    +releaseFilterCache(): void
    +recover(): void
    +reset(): CacheStyle
    +_calculateCacheRect(sprite: Sprite, tCacheType: string, x: number, y: number): Point
    +{static} EMPTY: CacheStyle
    +{static} create(): CacheStyle
    -{static} _scaleInfo: Point
    +{static} CANVAS_EXTEND_EDGE: number
}
class SpriteStyle {
    +scaleX: number
    +scaleY: number
    +skewX: number
    +skewY: number
    +pivotX: number
    +pivotY: number
    +rotation: number
    +alpha: number
    +scrollRect: Rectangle
    +viewport: Rectangle
    +hitArea: any
    +dragging: Dragging
    +blendMode: string
    +reset(): SpriteStyle
    +recover(): void
    +{static} EMPTY: SpriteStyle
    +{static} create(): SpriteStyle
}
class TextStyle extends SpriteStyle {
    +italic: boolean
    +align: string
    +wordWrap: boolean
    +leading: number
    +padding: any[]
    +bgColor: string
    +borderColor: string
    +asPassword: boolean
    +stroke: number
    +strokeColor: string
    +bold: boolean
    +underline: boolean
    +underlineColor: string
    +currBitmapFont: BitmapFont
    +reset(): SpriteStyle
    +recover(): void
    +render(sprite: Sprite, context: Context, x: number, y: number): void
    +{static} EMPTY: TextStyle
    +{static} create(): TextStyle
}
class SpriteConst {
    +{static} ALPHA: number
    +{static} TRANSFORM: number
    +{static} BLEND: number
    +{static} CANVAS: number
    +{static} FILTERS: number
    +{static} MASK: number
    +{static} CLIP: number
    +{static} STYLE: number
    +{static} TEXTURE: number
    +{static} GRAPHICS: number
    +{static} LAYAGL3D: number
    +{static} CUSTOM: number
    +{static} ONECHILD: number
    +{static} CHILDS: number
    +{static} REPAINT_NONE: number
    +{static} REPAINT_NODE: number
    +{static} REPAINT_CACHE: number
    +{static} REPAINT_ALL: number
}
class BaseShader extends Resource {
    +{static} activeShader: BaseShader
    +{static} bindShader: BaseShader
}
class ShaderDefinesBase {
    +_value: number
    -_name2int: { [id: string]: number; }
    -_int2name: any[]
    -_int2nameMap: any[]
    +add(value: any): number
    +addInt(value: number): number
    +remove(value: any): number
    +isDefine(def: number): boolean
    +getValue(): number
    +setValue(value: number): void
    +toNameDic(): any
    +{static} _reg(name: string, value: number, _name2int: any, _int2name: any[]): void
    +{static} _toText(value: number, _int2name: any[], _int2nameMap: any): any
    +{static} _toInt(names: string, _name2int: any): number
}
class ShaderDefines2D extends ShaderDefinesBase {
    +{static} TEXTURE2D: number
    +{static} PRIMITIVE: number
    +{static} FILTERGLOW: number
    +{static} FILTERBLUR: number
    +{static} FILTERCOLOR: number
    +{static} COLORADD: number
    +{static} WORLDMAT: number
    +{static} FILLTEXTURE: number
    +{static} SKINMESH: number
    +{static} MVP3D: number
    +{static} NOOPTMASK: number
    -{static} __name2int: any
    -{static} __int2name: any[]
    -{static} __int2nameMap: any[]
    +{static} __init__(): void
    +{static} reg(name: string, value: number): void
    +{static} toText(value: number, int2name: any[], int2nameMap: any): any
    +{static} toInt(names: string): number
}
class RenderState2D {
    +{static} _MAXSIZE: number
    +{static} EMPTYMAT4_ARRAY: any[]
    +{static} TEMPMAT4_ARRAY: any[]
    +{static} worldMatrix4: any[]
    +{static} worldMatrix: Matrix
    +{static} matWVP: any
    +{static} worldAlpha: number
    +{static} worldScissorTest: boolean
    +{static} worldShaderDefines: ShaderDefines2D
    +{static} worldFilters: any[]
    +{static} width: number
    +{static} height: number
    +{static} mat2MatArray(mat: Matrix, matArray: any[]): any[]
    +{static} restoreTempArray(): void
    +{static} clear(): void
}
class RenderTexture2D extends BaseTexture {
    -_lastRT: RenderTexture2D
    -_lastWidth: number
    -_lastHeight: number
    -_frameBuffer: any
    -_depthStencilBuffer: any
    -_depthStencilFormat: number
    +_mgrKey: number
    +depthStencilFormat: number
    +defaulteTexture: BaseTexture
    +getIsReady(): boolean
    +sourceWidth: number
    +sourceHeight: number
    +offsetX: number
    +offsetY: number
    -_create(width: number, height: number): void
    +generateMipmap(): void
    +start(): void
    +end(): void
    +restore(): void
    +clear(r?: number, g?: number, b?: number, a?: number): void
    +getData(x: number, y: number, width: number, height: number): Uint8Array
    +getDataAsync(x: number, y: number, width: number, height: number, callBack: Function): void
    +recycle(): void
    +_disposeResource(): void
    -{static} _currentActive: RenderTexture2D
    -{static} rtStack: any[]
    +{static} defuv: any[]
    +{static} flipyuv: any[]
    +{static} currentActive: RenderTexture2D
    +{static} pushRT(): void
    +{static} popRT(): void
}
class WebGLRTMgr {
    -{static} dict: any
    +{static} getRT(w: number, h: number): RenderTexture2D
    +{static} releaseRT(rt: RenderTexture2D): void
}
class IStatRender {
    +show(x?: number, y?: number): void
    +enable(): void
    +hide(): void
    +set_onclick(fn: Function): void
    +isCanvasRender(): boolean
    +renderNotCanvas(ctx: any, x: number, y: number): void
}
class Stat {
    +{static} FPS: number
    +{static} loopCount: number
    +{static} shaderCall: number
    +{static} renderBatches: number
    +{static} savedRenderBatches: number
    +{static} trianglesFaces: number
    +{static} spriteCount: number
    +{static} spriteRenderUseCacheCount: number
    +{static} frustumCulling: number
    +{static} octreeNodeCulling: number
    +{static} canvasNormal: number
    +{static} canvasBitmap: number
    +{static} canvasReCache: number
    +{static} renderSlow: boolean
    +{static} gpuMemory: number
    +{static} cpuMemory: number
    +{static} _fpsStr: string
    +{static} _canvasStr: string
    +{static} _spriteStr: string
    +{static} _fpsData: any[]
    +{static} _timer: number
    +{static} _count: number
    +{static} _StatRender: IStatRender
    +{static} show(x?: number, y?: number): void
    +{static} enable(): void
    +{static} hide(): void
    +{static} clear(): void
    +{static} onclick: Function
}
class BlendMode {
    +{static} activeBlendFunction: Function
    +{static} NAMES: any[]
    +{static} TOINT: any
    +{static} NORMAL: string
    +{static} ADD: string
    +{static} MULTIPLY: string
    +{static} SCREEN: string
    +{static} OVERLAY: string
    +{static} LIGHT: string
    +{static} MASK: string
    +{static} DESTINATIONOUT: string
    +{static} LIGHTER: string
    +{static} fns: any[]
    +{static} targetFns: any[]
    +{static} _init_(gl: WebGLContext): void
    +{static} BlendNormal(gl: WebGLRenderingContext): void
    +{static} BlendAdd(gl: WebGLRenderingContext): void
    +{static} BlendMultiply(gl: WebGLRenderingContext): void
    +{static} BlendScreen(gl: WebGLRenderingContext): void
    +{static} BlendOverlay(gl: WebGLRenderingContext): void
    +{static} BlendLight(gl: WebGLRenderingContext): void
    +{static} BlendNormalTarget(gl: WebGLRenderingContext): void
    +{static} BlendAddTarget(gl: WebGLRenderingContext): void
    +{static} BlendMultiplyTarget(gl: WebGLRenderingContext): void
    +{static} BlendScreenTarget(gl: WebGLRenderingContext): void
    +{static} BlendOverlayTarget(gl: WebGLRenderingContext): void
    +{static} BlendLightTarget(gl: WebGLRenderingContext): void
    +{static} BlendMask(gl: WebGLRenderingContext): void
    +{static} BlendDestinationOut(gl: WebGLRenderingContext): void
}
class StringKey {
    -_strsToID: any
    -_idToStrs: any[]
    -_length: number
    +add(str: string): number
    +getID(str: string): number
    +getName(id: number): string
}
class InlcudeFile {
    +script: string
    +codes: any
    +funs: any
    +curUseID: number
    +funnames: string
    +getWith(name?: string): string
    +getFunsScript(funsdef: string): string
}
class ShaderNode {
    +childs: any[]
    +text: string
    +parent: ShaderNode
    +name: string
    +noCompile: boolean
    +includefiles: any[]
    +condition: any
    +conditionType: number
    +useFuns: string
    +z: number
    +src: string
    +setParent(parent: ShaderNode): void
    +setCondition(condition: string, type: number): void
    +toscript(def: any, out: any[]): any[]
    -_toscript(def: any, out: any[], id: number): any[]
    -{static} __id: number
}
class ShaderCompile {
    -_nameMap: any
    #_VS: ShaderNode
    #_PS: ShaderNode
    +defs: Object
    #_compileToTree(parent: ShaderNode, lines: any[], start: number, includefiles: any[], defs: any): void
    +createShader(define: any, shaderName: any, createShader: Function, bindAttrib: any[]): Shader
    +{static} IFDEF_NO: number
    +{static} IFDEF_YES: number
    +{static} IFDEF_ELSE: number
    +{static} IFDEF_PARENT: number
    +{static} _removeAnnotation: RegExp
    +{static} _reg: RegExp
    +{static} _splitToWordExps: RegExp
    +{static} includes: any
    +{static} shaderParamsMap: any
    +{static} __init__(): void
    -{static} _parseOne(attributes: any[], uniforms: any[], words: any[], i: number, word: string, b: boolean): number
    +{static} addInclude(fileName: string, txt: string): void
    +{static} preGetParams(vs: string, ps: string): any
    +{static} splitToWords(str: string, block: ShaderNode): any[]
    +{static} _clearCR: RegExp
    +{static} _splitToWordExps3: RegExp
}
class ShaderValue
class Shader extends BaseShader {
    -_attribInfo: any[]
    -customCompile: boolean
    -_nameMap: any
    -_vs: string
    -_ps: string
    -_curActTexIndex: number
    -_reCompile: boolean
    +tag: any
    +_vshader: any
    +_pshader: any
    +_program: any
    +_params: any[]
    +_paramsMap: any
    #recreateResource(): void
    #_disposeResource(): void
    -_compile(): void
    +getUniform(name: string): any
    -_uniform1f(one: any, value: any): number
    -_uniform1fv(one: any, value: any): number
    -_uniform_vec2(one: any, value: any): number
    -_uniform_vec2v(one: any, value: any): number
    -_uniform_vec3(one: any, value: any): number
    -_uniform_vec3v(one: any, value: any): number
    -_uniform_vec4(one: any, value: any): number
    -_uniform_vec4v(one: any, value: any): number
    -_uniformMatrix2fv(one: any, value: any): number
    -_uniformMatrix3fv(one: any, value: any): number
    -_uniformMatrix4fv(one: any, value: any): number
    -_uniform1i(one: any, value: any): number
    -_uniform1iv(one: any, value: any): number
    -_uniform_ivec2(one: any, value: any): number
    -_uniform_ivec2v(one: any, value: any): number
    -_uniform_vec3i(one: any, value: any): number
    -_uniform_vec3vi(one: any, value: any): number
    -_uniform_vec4i(one: any, value: any): number
    -_uniform_vec4vi(one: any, value: any): number
    -_uniform_sampler2D(one: any, value: any): number
    -_uniform_samplerCube(one: any, value: any): number
    -_noSetValue(one: any): void
    +uploadOne(name: string, value: any): void
    +uploadTexture2D(value: any): void
    +upload(shaderValue: ShaderValue, params?: any[]): void
    +uploadArray(shaderValue: any[], length: number, _bufferUsage: any): void
    +getParams(): any[]
    +setAttributesLocation(attribDesc: any[]): void
    -{static} _count: number
    +{static} _preCompileShader: any
    +{static} SHADERNAME2ID: number
    +{static} nameKey: StringKey
    +{static} sharders: any[]
    +{static} getShader(name: any): Shader
    +{static} create(vs: string, ps: string, saveName?: any, nameMap?: any, bindAttrib?: any[]): Shader
    +{static} withCompile(nameID: number, define: any, shaderName: any, createShader: Function): Shader
    +{static} withCompile2D(nameID: number, mainID: number, define: any, shaderName: any, createShader: Function, bindAttrib?: any[]): Shader
    +{static} addInclude(fileName: string, txt: string): void
    +{static} preCompile(nameID: number, vs: string, ps: string, nameMap: any): void
    +{static} preCompile2D(nameID: number, mainID: number, vs: string, ps: string, nameMap: any): void
    -{static} _createShader(gl: WebGLRenderingContext, str: string, type: any): any
}
class ColorUtils {
    +arrColor: any[]
    +strColor: string
    +numColor: number
    +_drawStyle: any
    +{static} _SAVE: any
    +{static} _SAVE_SIZE: number
    -{static} _COLOR_MAP: any
    -{static} _DEFAULT: any
    -{static} _COLODID: number
    +{static} _initDefault(): any
    +{static} _initSaveMap(): void
    +{static} create(value: any): ColorUtils
}
class DrawStyle {
    +_color: ColorUtils
    +setValue(value: any): void
    +reset(): void
    +toInt(): number
    +equal(value: any): boolean
    +toColorStr(): string
    +{static} DEFAULT: DrawStyle
    +{static} create(value: any): DrawStyle
}
class Shader2D {
    +ALPHA: number
    +shader: Shader
    +filters: any[]
    +defines: ShaderDefines2D
    +shaderType: number
    +colorAdd: any[]
    +fillStyle: DrawStyle
    +strokeStyle: DrawStyle
    +destroy(): void
    +{static} __init__(): void
}
class Shader2X extends Shader {
    +_params2dQuick2: any[]
    +_shaderValueWidth: number
    +_shaderValueHeight: number
    #_disposeResource(): void
    +upload2dQuick2(shaderValue: ShaderValue): void
    +_make2dQuick2(): any[]
    +{static} create(vs: string, ps: string, saveName?: any, nameMap?: any, bindAttrib?: any[]): Shader
}
class Value2D {
    +defines: ShaderDefines2D
    +size: any[]
    +alpha: number
    +mmat: any[]
    +u_MvpMatrix: any[]
    +texture: any
    +ALPHA: number
    +shader: Shader
    +mainID: number
    +subID: number
    +filters: any[]
    +textureHost: Texture
    +color: any[]
    +colorAdd: any[]
    +u_mmat2: any[]
    +ref: number
    #_attribLocation: any[]
    -_inClassCache: any
    -_cacheID: number
    +clipMatDir: any[]
    +clipMatPos: any[]
    +clipOff: any[]
    +setValue(value: Shader2D): void
    -_ShaderWithCompile(): Shader2X
    +upload(): void
    +setFilters(value: any[]): void
    +clear(): void
    +release(): void
    #{static} _cache: any[]
    #{static} _typeClass: any
    +{static} TEMPMAT4_ARRAY: any[]
    +{static} _initone(type: number, classT: any): void
    +{static} __init__(): void
    +{static} create(mainType: number, subType: number): Value2D
}
class CONST3D2D {
    +{static} BYTES_PE: number
    +{static} BYTES_PIDX: number
    +{static} defaultMatrix4: any[]
    +{static} defaultMinusYMatrix4: any[]
    +{static} uniformMatrix3: any[]
    +{static} _TMPARRAY: any[]
    +{static} _OFFSETX: number
    +{static} _OFFSETY: number
}
class Buffer {
    #_glBuffer: any
    #_buffer: any
    #_bufferType: number
    #_bufferUsage: number
    +_byteLength: number
    +bufferUsage: number
    +_bindForVAO(): void
    +bind(): boolean
    +destroy(): void
    +{static} _bindedVertexBuffer: any
    +{static} _bindedIndexBuffer: any
}
class BufferStateBase {
    -_nativeVertexArrayObject: any
    +_bindedIndexBuffer: Buffer
    +bind(): void
    +unBind(): void
    +destroy(): void
    +bindForNative(): void
    +unBindForNative(): void
    +{static} _curBindedBufferState: BufferStateBase
}
class BufferState2D extends BufferStateBase
class RenderInfo {
    +{static} loopStTm: number
    +{static} loopCount: number
}
class Buffer2D extends Buffer {
    #_maxsize: number
    +_upload: boolean
    #_uploadSize: number
    #_bufferSize: number
    #_u8Array: Uint8Array
    +bufferLength: number
    +byteLength: number
    +setByteLength(value: number): void
    +needSize(sz: number): number
    #_bufferData(): void
    #_bufferSubData(offset?: number, dataStart?: number, dataLength?: number): void
    #_checkArrayUse(): void
    +_bind_uploadForVAO(): boolean
    +_bind_upload(): boolean
    +_bind_subUpload(offset?: number, dataStart?: number, dataLength?: number): boolean
    +_resizeBuffer(nsz: number, copy: boolean): Buffer2D
    +append(data: any): void
    +appendU16Array(data: Uint16Array, len: number): void
    +appendEx(data: any, type: new (buf: any, len: any) => any): void
    +appendEx2(data: any, type: new (buff: any, len: any) => any, dataLen: number, perDataLen?: number): void
    +getBuffer(): ArrayBuffer
    +setNeedUpload(): void
    +getNeedUpload(): boolean
    +upload(): boolean
    +subUpload(offset?: number, dataStart?: number, dataLength?: number): boolean
    #_disposeResource(): void
    +clear(): void
    +{static} FLOAT32: number
    +{static} SHORT: number
    +{static} __int__(gl: WebGLContext): void
}
class IndexBuffer2D extends Buffer2D {
    #_uint16Array: Uint16Array
    #_checkArrayUse(): void
    +getUint16Array(): Uint16Array
    +_bindForVAO(): void
    +bind(): boolean
    +destory(): void
    +disposeResource(): void
    +{static} create: Function
}
class VertexBuffer2D extends Buffer2D {
    +_floatArray32: Float32Array
    +_uint32Array: Uint32Array
    -_vertexStride: number
    +vertexStride: number
    +getFloat32Array(): Float32Array
    +appendArray(data: any[]): void
    #_checkArrayUse(): void
    +deleteBuffer(): void
    +_bindForVAO(): void
    +bind(): boolean
    +destroy(): void
    +{static} create: Function
}
class Mesh2D {
    +_stride: number
    +vertNum: number
    +indexNum: number
    #_applied: boolean
    +_vb: VertexBuffer2D
    +_ib: IndexBuffer2D
    -_vao: BufferState2D
    -_attribInfo: any[]
    #_quadNum: number
    +canReuse: boolean
    +cloneWithNewVB(): Mesh2D
    +cloneWithNewVBIB(): Mesh2D
    +getVBW(): VertexBuffer2D
    +getVBR(): VertexBuffer2D
    +getIBR(): IndexBuffer2D
    +getIBW(): IndexBuffer2D
    +createQuadIB(QuadNum: number): void
    +setAttributes(attribs: any[]): void
    -configVAO(gl: WebGLRenderingContext): void
    +useMesh(gl: WebGLRenderingContext): void
    +getEleNum(): number
    +releaseMesh(): void
    +destroy(): void
    +clearVB(): void
    -{static} _gvaoid: number
}
interface ISubmit {
    +renderSubmit(): number
    +getRenderType(): number
    +releaseRender(): void
}
class SubmitKey {
    +blendShader: number
    +submitType: number
    +other: number
    +clear(): void
    +copyFrom(src: SubmitKey): void
    +copyFrom2(src: SubmitKey, submitType: number, other: number): void
    +equal3_2(next: SubmitKey, submitType: number, other: number): boolean
    +equal4_2(next: SubmitKey, submitType: number, other: number): boolean
    +equal_3(next: SubmitKey): boolean
    +equal(next: SubmitKey): boolean
}
class SubmitBase implements ISubmit {
    +clipInfoID: number
    +_mesh: Mesh2D
    +_blendFn: Function
    #_id: number
    +_renderType: number
    +_parent: ISubmit
    +_key: SubmitKey
    +_startIdx: number
    +_numEle: number
    +_ref: number
    +shaderValue: Value2D
    +getID(): number
    +getRenderType(): number
    +toString(): string
    +renderSubmit(): number
    +releaseRender(): void
    +{static} TYPE_2D: number
    +{static} TYPE_CANVAS: number
    +{static} TYPE_CMDSETRT: number
    +{static} TYPE_CUSTOM: number
    +{static} TYPE_BLURRT: number
    +{static} TYPE_CMDDESTORYPRERT: number
    +{static} TYPE_DISABLESTENCIL: number
    +{static} TYPE_OTHERIBVB: number
    +{static} TYPE_PRIMITIVE: number
    +{static} TYPE_RT: number
    +{static} TYPE_BLUR_RT: number
    +{static} TYPE_TARGET: number
    +{static} TYPE_CHANGE_VALUE: number
    +{static} TYPE_SHAPE: number
    +{static} TYPE_TEXTURE: number
    +{static} TYPE_FILLTEXTURE: number
    +{static} KEY_ONCE: number
    +{static} KEY_FILLRECT: number
    +{static} KEY_DRAWTEXTURE: number
    +{static} KEY_VG: number
    +{static} KEY_TRIANGLES: number
    +{static} RENDERBASE: SubmitBase
    +{static} ID: number
    +{static} preRender: ISubmit
    +{static} __init__(): void
}
class Submit extends SubmitBase {
    +renderSubmit(): number
    +releaseRender(): void
    #{static} _poolSize: number
    #{static} POOL: any[]
    +{static} create(context: Context, mesh: Mesh2D, sv: Value2D): Submit
    +{static} createShape(ctx: Context, mesh: Mesh2D, numEle: number, sv: Value2D): Submit
}
class MeshQuadTexture extends Mesh2D {
    +releaseMesh(): void
    +destroy(): void
    +addQuad(pos: any[], uv: ArrayLike<number>, color: number, useTex: boolean): void
    +{static} const_stride: number
    -{static} _fixib: IndexBuffer2D
    -{static} _maxIB: number
    -{static} _fixattriInfo: any[]
    -{static} _POOL: any[]
    +{static} __int__(): void
    +{static} getAMesh(mainctx: boolean): MeshQuadTexture
}
class MeshTexture extends Mesh2D {
    +addData(vertices: Float32Array, uvs: Float32Array, idx: Uint16Array, matrix: Matrix, rgba: number): void
    +releaseMesh(): void
    +destroy(): void
    +{static} const_stride: number
    -{static} _fixattriInfo: any[]
    -{static} _POOL: any[]
    +{static} __init__(): void
    +{static} getAMesh(mainctx: boolean): MeshTexture
}
class MeshVG extends Mesh2D {
    +addVertAndIBToMesh(ctx: Context, points: any[], rgba: number, ib: any[]): void
    +releaseMesh(): void
    +destroy(): void
    +{static} const_stride: number
    -{static} _fixattriInfo: any[]
    -{static} _POOL: any[]
    +{static} __init__(): void
    +{static} getAMesh(mainctx: boolean): MeshVG
}
class WebGLCacheAsNormalCanvas {
    +submitStartPos: number
    +submitEndPos: number
    +context: Context
    +touches: any[]
    +submits: any[]
    +sprite: Sprite
    +_mesh: MeshQuadTexture
    -_pathMesh: MeshVG
    -_triangleMesh: MeshTexture
    +meshlist: any[]
    -_oldMesh: MeshQuadTexture
    -_oldPathMesh: MeshVG
    -_oldTriMesh: MeshTexture
    -_oldMeshList: any[]
    -cachedClipInfo: Matrix
    -oldTx: number
    -oldTy: number
    +invMat: Matrix
    +startRec(): void
    +endRec(): void
    +isCacheValid(): boolean
    +flushsubmit(): void
    +releaseMem(): void
    -{static} matI: Matrix
}
class SubmitCMD implements ISubmit {
    +fun: Function
    +_this: any
    +args: any[]
    +_ref: number
    +_key: SubmitKey
    +renderSubmit(): number
    +getRenderType(): number
    +releaseRender(): void
    +{static} POOL: any
    +{static} create(args: any[], fun: Function, thisobj: any): SubmitCMD
}
class LayaGLQuickRunner {
    +{static} map: any
    -{static} curMat: Matrix
    +{static} __init__(): void
    +{static} transform_drawTexture(sprite: Sprite, context: Context, x: number, y: number): void
    +{static} alpha_drawTexture(sprite: Sprite, context: Context, x: number, y: number): void
    +{static} alpha_transform_drawTexture(sprite: Sprite, context: Context, x: number, y: number): void
    +{static} alpha_transform_drawLayaGL(sprite: Sprite, context: Context, x: number, y: number): void
    +{static} alpha_drawLayaGL(sprite: Sprite, context: Context, x: number, y: number): void
    +{static} transform_drawLayaGL(sprite: Sprite, context: Context, x: number, y: number): void
    +{static} transform_drawNodes(sprite: Sprite, context: Context, x: number, y: number): void
    +{static} drawLayaGL_drawNodes(sprite: Sprite, context: Context, x: number, y: number): void
}
class RenderSprite {
    +_next: RenderSprite
    +_fun: Function
    #onCreate(type: number): void
    +_style(sprite: Sprite, context: Context, x: number, y: number): void
    +_no(sprite: Sprite, context: Context, x: number, y: number): void
    +_custom(sprite: Sprite, context: Context, x: number, y: number): void
    +_clip(sprite: Sprite, context: Context, x: number, y: number): void
    +_texture(sprite: Sprite, context: Context, x: number, y: number): void
    +_graphics(sprite: Sprite, context: Context, x: number, y: number): void
    +_image(sprite: Sprite, context: Context, x: number, y: number): void
    +_image2(sprite: Sprite, context: Context, x: number, y: number): void
    +_alpha(sprite: Sprite, context: Context, x: number, y: number): void
    +_transform(sprite: Sprite, context: Context, x: number, y: number): void
    +_children(sprite: Sprite, context: Context, x: number, y: number): void
    +_canvas(sprite: Sprite, context: Context, x: number, y: number): void
    +_canvas_repaint(sprite: Sprite, context: Context, x: number, y: number): void
    +_canvas_webgl_normal_repaint(sprite: Sprite, context: Context): void
    +_blend(sprite: Sprite, context: Context, x: number, y: number): void
    +_mask(sprite: Sprite, context: Context, x: number, y: number): void
    +{static} INIT: number
    +{static} renders: any[]
    #{static} NORENDER: RenderSprite
    +{static} __init__(): void
    -{static} _initRenderFun(sprite: Sprite, context: Context, x: number, y: number): void
    -{static} _getTypeRender(type: number): RenderSprite
    +{static} tempUV: any[]
    +{static} tmpTarget(ctx: Context, rt: RenderTexture2D, w: number, h: number): void
    +{static} recycleTarget(rt: RenderTexture2D): void
    +{static} setBlendMode(blendMode: string): void
}
class Filter implements IFilter {
    +_glRender: any
    +type: number
    +{static} BLUR: number
    +{static} COLOR: number
    +{static} GLOW: number
    +{static} _filter: (sprite: Sprite, context: Context, x: number, y: number) => void
}
class ColorFilter extends Filter implements IFilter {
    +_mat: Float32Array
    +_alpha: Float32Array
    -_matrix: any[]
    +gray(): ColorFilter
    +color(red?: number, green?: number, blue?: number, alpha?: number): ColorFilter
    +setColor(color: string): ColorFilter
    +setByMatrix(matrix: any[]): ColorFilter
    +type: number
    +adjustColor(brightness: number, contrast: number, saturation: number, hue: number): ColorFilter
    +adjustBrightness(brightness: number): ColorFilter
    +adjustContrast(contrast: number): ColorFilter
    +adjustSaturation(saturation: number): ColorFilter
    +adjustHue(hue: number): ColorFilter
    +reset(): ColorFilter
    -_multiplyMatrix(matrix: any[]): ColorFilter
    -_clampValue(val: number, limit: number): number
    -_fixMatrix(matrix?: any[]): any[]
    -_copyMatrix(matrix: any[]): any[]
    -{static} DELTA_INDEX: any[]
    -{static} GRAY_MATRIX: any[]
    -{static} IDENTITY_MATRIX: any[]
    -{static} LENGTH: number
}
class Bezier {
    -_controlPoints: any[]
    -_calFun: Function
    -_switchPoint(x: number, y: number): void
    +getPoint2(t: number, rst: any[]): void
    +getPoint3(t: number, rst: any[]): void
    +insertPoints(count: number, rst: any[]): void
    +getBezierPoints(pList: any[], inSertCount?: number, count?: number): any[]
    +{static} I: Bezier
}
class FontInfo {
    +_id: number
    +_font: string
    +_family: string
    +_size: number
    +_italic: boolean
    +_bold: boolean
    +setFont(value: string): void
    +{static} EMPTY: FontInfo
    -{static} _cache: any
    -{static} _gfontID: number
    -{static} _lastFont: string
    -{static} _lastFontInfo: FontInfo
    +{static} Parse(font: string): FontInfo
}
class HTMLChar {
    +x: number
    +y: number
    +width: number
    +height: number
    +isWord: boolean
    +char: string
    +charNum: number
    +style: any
    +setData(char: string, w: number, h: number, style: any): HTMLChar
    +reset(): HTMLChar
    +recover(): void
    +_isChar(): boolean
    +_getCSSStyle(): any
    -{static} _isWordRegExp: RegExp
    +{static} create(): HTMLChar
}
class WordText {
    +id: number
    +save: any[]
    +toUpperCase: string
    +changed: boolean
    +_text: string
    +width: number
    +pageChars: any[]
    +startID: number
    +startIDStroke: number
    +lastGCCnt: number
    +splitRender: boolean
    +scalex: number
    +scaley: number
    +setText(txt: string): void
    +toString(): string
    +length: number
    +charCodeAt(i: number): number
    +charAt(i: number): string
    +cleanCache(): void
}
class Path {
    +_lastOriX: number
    +_lastOriY: number
    +paths: any[]
    -_curPath: renderPath
    +beginPath(convex: boolean): void
    +closePath(): void
    +newPath(): void
    +addPoint(pointX: number, pointY: number): void
    +push(points: any[], convex: boolean): void
    +reset(): void
}
class renderPath {
    +path: any[]
    +loop: boolean
    +convex: boolean
}
interface ISaveData {
    +isSaveMark(): boolean
    +restore(context: Context): void
}
class SaveBase implements ISaveData {
    -_valueName: string
    -_value: any
    -_dataObj: any
    -_newSubmit: boolean
    +isSaveMark(): boolean
    +restore(context: Context): void
    +{static} TYPE_ALPHA: number
    +{static} TYPE_FILESTYLE: number
    +{static} TYPE_FONT: number
    +{static} TYPE_LINEWIDTH: number
    +{static} TYPE_STROKESTYLE: number
    +{static} TYPE_MARK: number
    +{static} TYPE_TRANSFORM: number
    +{static} TYPE_TRANSLATE: number
    +{static} TYPE_ENABLEMERGE: number
    +{static} TYPE_TEXTBASELINE: number
    +{static} TYPE_TEXTALIGN: number
    +{static} TYPE_GLOBALCOMPOSITEOPERATION: number
    +{static} TYPE_CLIPRECT: number
    +{static} TYPE_CLIPRECT_STENCIL: number
    +{static} TYPE_IBVB: number
    +{static} TYPE_SHADER: number
    +{static} TYPE_FILTERS: number
    +{static} TYPE_FILTERS_TYPE: number
    +{static} TYPE_COLORFILTER: number
    -{static} POOL: any
    -{static} _namemap: any
    +{static} _createArray(): any[]
    +{static} _init(): any
    +{static} save(context: Context, type: number, dataObj: any, newSubmit: boolean): void
}
class SaveClipRect implements ISaveData {
    -_globalClipMatrix: Matrix
    -_clipInfoID: number
    +_clipRect: Rectangle
    +incache: boolean
    +isSaveMark(): boolean
    +restore(context: Context): void
    -{static} POOL: any
    +{static} save(context: Context): void
}
class SaveMark implements ISaveData {
    +_saveuse: number
    +_preSaveMark: SaveMark
    +isSaveMark(): boolean
    +restore(context: Context): void
    -{static} POOL: any
    +{static} Create(context: Context): SaveMark
}
class SaveTransform implements ISaveData {
    +_savematrix: Matrix
    +_matrix: Matrix
    +isSaveMark(): boolean
    +restore(context: Context): void
    -{static} POOL: any
    +{static} save(context: Context): void
}
class SaveTranslate implements ISaveData {
    +_mat: Matrix
    +isSaveMark(): boolean
    +restore(context: Context): void
    -{static} POOL: any
    +{static} save(context: Context): void
}
class SkinMeshBuffer {
    +ib: IndexBuffer2D
    +vb: VertexBuffer2D
    +addSkinMesh(skinMesh: any): void
    +reset(): void
    +{static} instance: SkinMeshBuffer
    +{static} getInstance(): SkinMeshBuffer
}
class BasePoly {
    -{static} tempData: any[]
    +{static} createLine2(p: any[], indices: any[], lineWidth: number, indexBase: number, outVertex: any[], loop: boolean): any[]
    +{static} createLineTriangle(path: any[], color: number, width: number, loop: boolean, outvb: Float32Array, vbstride: number, outib: Uint16Array): void
}
class EarcutNode {
    +i: any
    +x: any
    +y: any
    +prev: any
    +next: any
    +z: any
    +prevZ: any
    +nextZ: any
    +steiner: any
}
class Earcut {
    +{static} earcut(data: any, holeIndices: any, dim: any): any
    +{static} linkedList(data: any, start: any, end: any, dim: any, clockwise: any): any
    +{static} filterPoints(start: any, end: any): any
    +{static} earcutLinked(ear: any, triangles: any, dim: any, minX: any, minY: any, invSize: any, pass?: any): any
    +{static} isEar(ear: any): any
    +{static} isEarHashed(ear: any, minX: any, minY: any, invSize: any): boolean
    +{static} cureLocalIntersections(start: any, triangles: any, dim: any): any
    +{static} splitEarcut(start: any, triangles: any, dim: any, minX: any, minY: any, invSize: any): void
    +{static} eliminateHoles(data: any, holeIndices: any, outerNode: any, dim: any): any
    +{static} compareX(a: any, b: any): any
    +{static} eliminateHole(hole: any, outerNode: any): void
    +{static} findHoleBridge(hole: any, outerNode: any): any
    +{static} indexCurve(start: any, minX: any, minY: any, invSize: any): void
    +{static} sortLinked(list: any): any
    +{static} zOrder(x: any, y: any, minX: any, minY: any, invSize: any): any
    +{static} getLeftmost(start: any): any
    +{static} pointInTriangle(ax: any, ay: any, bx: any, by: any, cx: any, cy: any, px: any, py: any): boolean
    +{static} isValidDiagonal(a: any, b: any): boolean
    +{static} area(p: any, q: any, r: any): any
    +{static} equals(p1: any, p2: any): boolean
    +{static} intersects(p1: any, q1: any, p2: any, q2: any): boolean
    +{static} intersectsPolygon(a: any, b: any): boolean
    +{static} locallyInside(a: any, b: any): boolean
    +{static} middleInside(a: any, b: any): boolean
    +{static} splitPolygon(a: any, b: any): any
    +{static} insertNode(i: any, x: any, y: any, last: any): any
    +{static} removeNode(p: any): void
    +{static} signedArea(data: any, start: any, end: any, dim: any): any
}
class SubmitCanvas extends SubmitBase {
    +_matrix: Matrix
    +canv: Context
    +_matrix4: any[]
    +renderSubmit(): number
    +releaseRender(): void
    +getRenderType(): number
    +{static} create(canvas: any, alpha: number, filters: any[]): SubmitCanvas
    +{static} POOL: any
}
class WebGL {
    +{static} _isWebGL2: boolean
    +{static} isNativeRender_enable: boolean
    -{static} _uint8ArraySlice(): Uint8Array
    -{static} _float32ArraySlice(): Float32Array
    -{static} _uint16ArraySlice(arg: any[]): Uint16Array
    +{static} _nativeRender_enable(): void
    +{static} enable(): boolean
    +{static} inner_enable(): boolean
    +{static} onStageResize(width: number, height: number): void
}
class TextureSV extends Value2D {
    +u_colorMatrix: any[]
    +strength: number
    +blurInfo: any[]
    +colorMat: Float32Array
    +colorAlpha: Float32Array
    +clear(): void
}
class SubmitTarget implements ISubmit {
    +_mesh: Mesh2D
    +_startIdx: number
    +_numEle: number
    +shaderValue: Value2D
    +blendType: number
    +_ref: number
    +_key: SubmitKey
    +srcRT: RenderTexture2D
    +renderSubmit(): number
    +blend(): void
    +getRenderType(): number
    +releaseRender(): void
    +{static} POOL: any
    +{static} create(context: Context, mesh: Mesh2D, sv: Value2D, rt: RenderTexture2D): SubmitTarget
}
class SubmitTexture extends SubmitBase {
    +releaseRender(): void
    +renderSubmit(): number
    -{static} _poolSize: number
    -{static} POOL: any[]
    +{static} create(context: Context, mesh: Mesh2D, sv: Value2D): SubmitTexture
}
class CharRenderInfo {
    +char: string
    +tex: any
    +deleted: boolean
    +uv: any[]
    +pos: number
    +width: number
    +height: number
    +bmpWidth: number
    +bmpHeight: number
    +orix: number
    +oriy: number
    +touchTick: number
    +isSpace: boolean
    +touch(): void
}
class CharSubmitCache {
    -_data: any[]
    -_ndata: number
    -_tex: Texture
    -_imgId: number
    -_clipid: number
    -_clipMatrix: Matrix
    +_enable: boolean
    +_colorFiler: ColorFilter
    +clear(): void
    +destroy(): void
    +add(ctx: Context, tex: Texture, imgid: number, pos: any[], uv: ArrayLike<number>, color: number): void
    +getPos(): any[]
    +enable(value: boolean, ctx: Context): void
    +submit(ctx: Context): void
    -{static} __posPool: any[]
    -{static} __nPosPool: number
}
class AtlasGrid {
    +atlasID: number
    -_width: number
    -_height: number
    -_texCount: number
    -_rowInfo: Uint8Array
    -_cells: Uint8Array
    +_used: number
    +addRect(type: number, width: number, height: number, pt: Point): boolean
    -_release(): void
    -_init(width: number, height: number): boolean
    -_get(width: number, height: number, pt: Point): boolean
    -_fill(x: number, y: number, w: number, h: number, type: number): void
    -_check(ret: boolean): void
    -_clear(): void
}
class TextTexture extends Resource {
    +_source: any
    +_texW: number
    +_texH: number
    +__destroyed: boolean
    +_discardTm: number
    +genID: number
    +bitmap: any
    +curUsedCovRate: number
    +curUsedCovRateAtlas: number
    +lastTouchTm: number
    +ri: CharRenderInfo
    +recreateResource(): void
    +addChar(data: ImageData, x: number, y: number, uv?: any[]): any[]
    +addCharCanvas(canv: any, x: number, y: number, uv?: any[]): any[]
    +fillWhite(): void
    +discard(): void
    +destroy(): void
    +touchRect(ri: CharRenderInfo, curloop: number): void
    +texture: any
    +_getSource(): any
    +drawOnScreen(x: number, y: number): void
    +{static} gTextRender: ITextRender
    -{static} pool: any[]
    -{static} poolLen: number
    -{static} cleanTm: number
    +{static} getTextTexture(w: number, h: number): TextTexture
    +{static} clean(): void
}
interface ITextRender {
    +atlasWidth: number
    +checkCleanTextureDt: number
    +debugUV: boolean
    +isWan1Wan: boolean
    +destroyUnusedTextureDt: number
}
class TextAtlas {
    +texWidth: number
    +texHeight: number
    -atlasgrid: AtlasGrid
    +texture: TextTexture
    +charMaps: any
    +setProtecteDist(d: number): void
    +getAEmpty(w: number, h: number, pt: Point): boolean
    +usedRate: number
    +destroy(): void
    +printDebugInfo(): void
    +{static} atlasGridW: number
}
class ICharRender {
    +fontsz: number
    +getWidth(font: string, str: string): number
    +scale(sx: number, sy: number): void
    +canvasWidth: number
    +canvasWidth: number
    +getCharBmp(char: string, font: string, lineWidth: number, colStr: string, strokeColStr: string, size: CharRenderInfo, margin_left: number, margin_top: number, margin_right: number, margin_bottom: number, rect?: any[]): ImageData
}
class CharRender_Canvas extends ICharRender {
    -ctx: any
    -lastScaleX: number
    -lastScaleY: number
    -maxTexW: number
    -maxTexH: number
    -scaleFontSize: boolean
    -showDbgInfo: boolean
    -supportImageData: boolean
    +canvasWidth: number
    +canvasWidth: number
    +getWidth(font: string, str: string): number
    +scale(sx: number, sy: number): void
    +getCharBmp(char: string, font: string, lineWidth: number, colStr: string, strokeColStr: string, cri: CharRenderInfo, margin_left: number, margin_top: number, margin_right: number, margin_bottom: number, rect?: any[]): ImageData
    +getCharCanvas(char: string, font: string, lineWidth: number, colStr: string, strokeColStr: string, cri: CharRenderInfo, margin_left: number, margin_top: number, margin_right: number, margin_bottom: number): ImageData
    -{static} canvas: any
}
class CharRender_Native extends ICharRender {
    -lastFont: string
    -lastScaleX: number
    -lastScaleY: number
    +getWidth(font: string, str: string): number
    +scale(sx: number, sy: number): void
    +getCharBmp(char: string, font: string, lineWidth: number, colStr: string, strokeColStr: string, size: CharRenderInfo, margin_left: number, margin_top: number, margin_right: number, margin_bottom: number, rect?: any[]): ImageData
}
class TextRender {
    -fontSizeInfo: any
    -charRender: ICharRender
    -mapFont: any
    -fontID: number
    -mapColor: any[]
    -colorID: number
    -fontScaleX: number
    -fontScaleY: number
    -_curStrPos: number
    +textAtlases: TextAtlas[]
    -isoTextures: TextTexture[]
    -bmpData32: Uint32Array
    -lastFont: FontInfo
    -fontSizeW: number
    -fontSizeH: number
    -fontSizeOffX: number
    -fontSizeOffY: number
    -renderPerChar: boolean
    -tmpAtlasPos: Point
    -textureMem: number
    -fontStr: string
    +setFont(font: FontInfo): void
    +getNextChar(str: string): string
    +filltext(ctx: Context, data: string | WordText, x: number, y: number, fontStr: string, color: string, strokeColor: string, lineWidth: number, textAlign: string, underLine?: number): void
    +fillWords(ctx: Context, data: HTMLChar[], x: number, y: number, fontStr: string | FontInfo, color: string, strokeColor: string, lineWidth: number): void
    +_fast_filltext(ctx: Context, data: string | WordText, htmlchars: HTMLChar[], x: number, y: number, font: FontInfo, color: string, strokeColor: string, lineWidth: number, textAlign: number, underLine?: number): void
    #_drawResortedWords(ctx: Context, startx: number, starty: number, samePagesData: any[]): void
    +hasFreedText(txts: any[]): boolean
    +getCharRenderInfo(str: string, font: FontInfo, color: string, strokeColor: string, lineWidth: number, isoTexture?: boolean): CharRenderInfo
    +addBmpData(data: ImageData, ri: CharRenderInfo): TextAtlas
    +GC(): void
    +cleanAtlases(): void
    +getCharBmp(c: string): any
    -checkBmpLine(data: ImageData, l: number, sx: number, ex: number): boolean
    -updateBbx(data: ImageData, curbbx: any[], onlyH?: boolean): void
    +getFontSizeInfo(font: string): number
    +printDbgInfo(): void
    +showAtlas(n: number, bgcolor: string, x: number, y: number, w: number, h: number): Sprite
    +filltext_native(ctx: Context, data: string | WordText, htmlchars: HTMLChar[], x: number, y: number, fontStr: string, color: string, strokeColor: string, lineWidth: number, textAlign: string, underLine?: number): void
    +{static} useOldCharBook: boolean
    +{static} atlasWidth: number
    +{static} noAtlas: boolean
    +{static} forceSplitRender: boolean
    +{static} forceWholeRender: boolean
    +{static} scaleFontWithCtx: boolean
    +{static} standardFontSize: number
    +{static} destroyAtlasDt: number
    +{static} checkCleanTextureDt: number
    +{static} destroyUnusedTextureDt: number
    +{static} cleanMem: number
    +{static} isWan1Wan: boolean
    +{static} showLog: boolean
    +{static} debugUV: boolean
    +{static} atlasWidth2: number
    -{static} tmpRI: CharRenderInfo
    -{static} pixelBBX: any[]
    +{static} textRenderInst: TextRender
    -{static} imgdtRect: any[]
    +{static} simClean: boolean
}
class Context {
    +_canvas: HTMLCanvas
    +_tmpMatrix: Matrix
    -_drawTexToDrawTri_Vert: Float32Array
    -_drawTexToDrawTri_Index: Uint16Array
    -_tempUV: Float32Array
    -_drawTriUseAbsMatrix: boolean
    +drawImage(args: any[]): void
    +getImageData(args: any[]): any
    +measureText(text: string): any
    +setTransform(args: any[]): void
    +$transform(a: number, b: number, c: number, d: number, tx: number, ty: number): void
    +lineJoin: string
    +lineJoin: string
    +lineCap: string
    +lineCap: string
    +miterLimit: string
    +miterLimit: string
    +clearRect(x: number, y: number, width: number, height: number): void
    +_drawRect(x: number, y: number, width: number, height: number, style: any): void
    +drawTexture2(x: number, y: number, pivotX: number, pivotY: number, m: Matrix, args2: any[]): void
    +transformByMatrix(matrix: Matrix, tx: number, ty: number): void
    +saveTransform(matrix: Matrix): void
    +restoreTransform(matrix: Matrix): void
    +drawRect(x: number, y: number, width: number, height: number, fillColor: any, lineColor: any, lineWidth: number): void
    +alpha(value: number): void
    +_transform(mat: Matrix, pivotX: number, pivotY: number): void
    +_rotate(angle: number, pivotX: number, pivotY: number): void
    +_scale(scaleX: number, scaleY: number, pivotX: number, pivotY: number): void
    +_drawLine(x: number, y: number, fromX: number, fromY: number, toX: number, toY: number, lineColor: string, lineWidth: number, vid: number): void
    +_drawLines(x: number, y: number, points: any[], lineColor: any, lineWidth: number, vid: number): void
    +drawCurves(x: number, y: number, points: any[], lineColor: any, lineWidth: number): void
    -_fillAndStroke(fillColor: string, strokeColor: string, lineWidth: number, isConvexPolygon?: boolean): void
    +_drawCircle(x: number, y: number, radius: number, fillColor: any, lineColor: any, lineWidth: number, vid: number): void
    +_drawPie(x: number, y: number, radius: number, startAngle: number, endAngle: number, fillColor: any, lineColor: any, lineWidth: number, vid: number): void
    +_drawPoly(x: number, y: number, points: any[], fillColor: any, lineColor: any, lineWidth: number, isConvexPolygon: boolean, vid: number): void
    +_drawPath(x: number, y: number, paths: any[], brush: any, pen: any): void
    +_id: number
    -_other: ContextParams
    -_renderNextSubmitIndex: number
    -_path: Path
    +_drawCount: number
    -_width: number
    -_height: number
    -_renderCount: number
    +_submits: any
    +_curSubmit: any
    +_submitKey: SubmitKey
    +_mesh: MeshQuadTexture
    +_pathMesh: MeshVG
    +_triangleMesh: MeshTexture
    +meshlist: any[]
    -_transedPoints: any[]
    -_temp4Points: any[]
    +_clipRect: Rectangle
    +_globalClipMatrix: Matrix
    +_clipInCache: boolean
    +_clipInfoID: number
    -_clipID_Gen: number
    +_curMat: Matrix
    +_lastMatScaleX: number
    +_lastMatScaleY: number
    -_lastMat_a: number
    -_lastMat_b: number
    -_lastMat_c: number
    -_lastMat_d: number
    +_nBlendType: number
    +_save: any
    +_targets: RenderTexture2D
    +_charSubmitCache: CharSubmitCache
    +_saveMark: SaveMark
    +_shader2D: Shader2D
    +sprite: Sprite
    +_italicDeg: number
    +_lastTex: Texture
    -_fillColor: number
    -_flushCnt: number
    -defTexture: Texture
    +_colorFiler: ColorFilter
    +drawTexAlign: boolean
    +_incache: boolean
    +isMain: boolean
    +clearBG(r: number, g: number, b: number, a: number): void
    +_getSubmits(): any[]
    -_releaseMem(keepRT?: boolean): void
    +destroy(keepRT?: boolean): void
    +clear(): void
    +size(w: number, h: number): void
    +asBitmap: boolean
    +getMatScaleX(): number
    +getMatScaleY(): number
    +setFillColor(color: number): void
    +getFillColor(): number
    +fillStyle: any
    +fillStyle: any
    +globalAlpha: number
    +globalAlpha: number
    +textAlign: string
    +textAlign: string
    +textBaseline: string
    +textBaseline: string
    +globalCompositeOperation: string
    +globalCompositeOperation: string
    +strokeStyle: any
    +strokeStyle: any
    +translate(x: number, y: number): void
    +lineWidth: number
    +lineWidth: number
    +save(): void
    +restore(): void
    +font: string
    +fillText(txt: string | WordText, x: number, y: number, fontStr: string, color: string, align: string, lineWidth?: number, borderColor?: string): void
    +drawText(text: string | WordText, x: number, y: number, font: string, color: string, textAlign: string): void
    +fillWords(words: HTMLChar[], x: number, y: number, fontStr: string, color: string): void
    +strokeWord(text: string | WordText, x: number, y: number, font: string, color: string, lineWidth: number, textAlign: string): void
    +fillBorderText(txt: string | WordText, x: number, y: number, font: string, color: string, borderColor: string, lineWidth: number, textAlign: string): void
    +fillBorderWords(words: HTMLChar[], x: number, y: number, font: string, color: string, borderColor: string, lineWidth: number): void
    +_fast_filltext(data: string | WordText, x: number, y: number, fontObj: any, color: string, strokeColor: string, lineWidth: number, textAlign: number, underLine?: number): void
    -_fillRect(x: number, y: number, width: number, height: number, rgba: number): void
    +fillRect(x: number, y: number, width: number, height: number, fillStyle: any): void
    +fillTexture(texture: Texture, x: number, y: number, width: number, height: number, type: string, offset: Point, other: any): void
    +_fillTexture(texture: Texture, texw: number, texh: number, texuvRect: any[], x: number, y: number, width: number, height: number, type: string, offsetx: number, offsety: number): void
    +setColorFilter(filter: ColorFilter): void
    +drawTexture(tex: Texture, x: number, y: number, width: number, height: number): void
    +drawTextures(tex: Texture, pos: any[], tx: number, ty: number): void
    -_drawTextureAddSubmit(imgid: number, tex: Texture): void
    +_drawTextureM(tex: Texture, x: number, y: number, width: number, height: number, m: Matrix, alpha: number, uv: any[]): boolean
    +_drawRenderTexture(tex: RenderTexture2D, x: number, y: number, width: number, height: number, m: Matrix, alpha: number, uv: any[]): boolean
    +submitDebugger(): void
    +_copyClipInfo(submit: SubmitBase, clipInfo: Matrix): void
    -isSameClipInfo(submit: SubmitBase): boolean
    +_useNewTex2DSubmit(tex: Texture, minVertNum: number): void
    +_drawTexRect(x: number, y: number, w: number, h: number, uv: any[]): void
    +drawCallOptimize(enable: boolean): boolean
    +_inner_drawTexture(tex: Texture, imgid: number, x: number, y: number, width: number, height: number, m: Matrix, uv: ArrayLike<number>, alpha: number, lastRender: boolean): boolean
    +transform4Points(a: any[], m: Matrix, out: any[]): void
    +clipedOff(pt: any[]): boolean
    +transformQuad(x: number, y: number, w: number, h: number, italicDeg: number, m: Matrix, out: any[]): void
    +pushRT(): void
    +popRT(): void
    +useRT(rt: RenderTexture2D): void
    +RTRestore(rt: RenderTexture2D): void
    +breakNextMerge(): void
    -_repaintSprite(): void
    +drawTextureWithTransform(tex: Texture, x: number, y: number, width: number, height: number, transform: Matrix, tx: number, ty: number, alpha: number, blendMode: string, colorfilter?: ColorFilter, uv?: number[]): void
    -_flushToTarget(context: Context, target: RenderTexture2D): void
    +drawCanvas(canvas: HTMLCanvas, x: number, y: number, width: number, height: number): void
    +drawTarget(rt: RenderTexture2D, x: number, y: number, width: number, height: number, m: Matrix, shaderValue: Value2D, uv?: ArrayLike<number>, blend?: number): boolean
    +drawTriangles(tex: Texture, x: number, y: number, vertices: Float32Array, uvs: Float32Array, indices: Uint16Array, matrix: Matrix, alpha: number, color: ColorFilter, blendMode: string, colorNum?: number): void
    +transform(a: number, b: number, c: number, d: number, tx: number, ty: number): void
    +_transformByMatrix(matrix: Matrix, tx: number, ty: number): void
    +setTransformByMatrix(value: Matrix): void
    +rotate(angle: number): void
    +scale(scaleX: number, scaleY: number): void
    +clipRect(x: number, y: number, width: number, height: number): void
    +drawMesh(x: number, y: number, ib: IndexBuffer2D, vb: VertexBuffer2D, numElement: number, mat: Matrix, shader: Shader, shaderValues: Value2D, startIndex?: number): void
    +addRenderObject(o: ISubmit): void
    +submitElement(start: number, end: number): number
    +flush(): number
    +beginPath(convex?: boolean): void
    +closePath(): void
    +addPath(points: any[], close: boolean, convex: boolean, dx: number, dy: number): void
    +fill(): void
    -addVGSubmit(mesh: Mesh2D): Submit
    +stroke(): void
    +moveTo(x: number, y: number): void
    +lineTo(x: number, y: number): void
    +arcTo(x1: number, y1: number, x2: number, y2: number, r: number): void
    +arc(cx: number, cy: number, r: number, startAngle: number, endAngle: number, counterclockwise?: boolean, b?: boolean): void
    +quadraticCurveTo(cpx: number, cpy: number, x: number, y: number): void
    +mixRGBandAlpha(color: number): number
    +_mixRGBandAlpha(color: number, alpha: number): number
    +strokeRect(x: number, y: number, width: number, height: number, parameterLineWidth: number): void
    +clip(): void
    +drawParticle(x: number, y: number, pt: any): void
    -_getPath(): Path
    +canvas: HTMLCanvas
    -_fillTexture_h(tex: Texture, imgid: number, uv: ArrayLike<number>, oriw: number, orih: number, x: number, y: number, w: number): void
    -_fillTexture_v(tex: Texture, imgid: number, uv: ArrayLike<number>, oriw: number, orih: number, x: number, y: number, h: number): void
    +drawTextureWithSizeGrid(tex: Texture, tx: number, ty: number, width: number, height: number, sizeGrid: any[], gx: number, gy: number): void
    +{static} ENUM_TEXTALIGN_DEFAULT: number
    +{static} ENUM_TEXTALIGN_CENTER: number
    +{static} ENUM_TEXTALIGN_RIGHT: number
    +{static} _SUBMITVBSIZE: number
    +{static} _MAXSIZE: number
    -{static} _MAXVERTNUM: number
    +{static} MAXCLIPRECT: Rectangle
    +{static} _COUNT: number
    -{static} SEGNUM: number
    -{static} _contextcount: number
    +{static} __init__(): void
    +{static} PI2: number
    +{static} set2DRenderConfig(): void
    +{static} _textRender: TextRender
    -{static} tmpuv1: any[]
    -{static} tmpUV: any[]
    -{static} tmpUVRect: any[]
}
class ContextParams {
    +lineWidth: number
    +textAlign: string
    +textBaseline: string
    +clear(): void
    +make(): ContextParams
    +{static} DEFAULT: ContextParams
}
class AlphaCmd {
    +alpha: number
    +recover(): void
    +run(context: Context, gx: number, gy: number): void
    +cmdID: string
    +{static} ID: string
    +{static} create(alpha: number): AlphaCmd
}
class DrawCircleCmd {
    +x: number
    +y: number
    +radius: number
    +fillColor: any
    +lineColor: any
    +lineWidth: number
    +vid: number
    +recover(): void
    +run(context: Context, gx: number, gy: number): void
    +cmdID: string
    +{static} ID: string
    +{static} create(x: number, y: number, radius: number, fillColor: any, lineColor: any, lineWidth: number, vid: number): DrawCircleCmd
}
class DrawCurvesCmd {
    +x: number
    +y: number
    +points: number[]
    +lineColor: any
    +lineWidth: number
    +recover(): void
    +run(context: Context, gx: number, gy: number): void
    +cmdID: string
    +{static} ID: string
    +{static} create(x: number, y: number, points: any[], lineColor: any, lineWidth: number): DrawCurvesCmd
}
class DrawImageCmd {
    +texture: Texture
    +x: number
    +y: number
    +width: number
    +height: number
    +recover(): void
    +run(context: Context, gx: number, gy: number): void
    +cmdID: string
    +{static} ID: string
    +{static} create(texture: Texture, x: number, y: number, width: number, height: number): DrawImageCmd
}
class DrawLineCmd {
    +fromX: number
    +fromY: number
    +toX: number
    +toY: number
    +lineColor: string
    +lineWidth: number
    +vid: number
    +recover(): void
    +run(context: Context, gx: number, gy: number): void
    +cmdID: string
    +{static} ID: string
    +{static} create(fromX: number, fromY: number, toX: number, toY: number, lineColor: string, lineWidth: number, vid: number): DrawLineCmd
}
class DrawLinesCmd {
    +x: number
    +y: number
    +points: number[]
    +lineColor: any
    +lineWidth: number
    +vid: number
    +recover(): void
    +run(context: Context, gx: number, gy: number): void
    +cmdID: string
    +{static} ID: string
    +{static} create(x: number, y: number, points: any[], lineColor: any, lineWidth: number, vid: number): DrawLinesCmd
}
class DrawPathCmd {
    +x: number
    +y: number
    +paths: any[]
    +brush: any
    +pen: any
    +recover(): void
    +run(context: Context, gx: number, gy: number): void
    +cmdID: string
    +{static} ID: string
    +{static} create(x: number, y: number, paths: any[], brush: any, pen: any): DrawPathCmd
}
class DrawPieCmd {
    +x: number
    +y: number
    +radius: number
    -_startAngle: number
    -_endAngle: number
    +fillColor: any
    +lineColor: any
    +lineWidth: number
    +vid: number
    +recover(): void
    +run(context: Context, gx: number, gy: number): void
    +cmdID: string
    +startAngle: number
    +startAngle: number
    +endAngle: number
    +endAngle: number
    +{static} ID: string
    +{static} create(x: number, y: number, radius: number, startAngle: number, endAngle: number, fillColor: any, lineColor: any, lineWidth: number, vid: number): DrawPieCmd
}
class DrawPolyCmd {
    +x: number
    +y: number
    +points: number[]
    +fillColor: any
    +lineColor: any
    +lineWidth: number
    +isConvexPolygon: boolean
    +vid: number
    +recover(): void
    +run(context: Context, gx: number, gy: number): void
    +cmdID: string
    +{static} ID: string
    +{static} create(x: number, y: number, points: any[], fillColor: any, lineColor: any, lineWidth: number, isConvexPolygon: boolean, vid: number): DrawPolyCmd
}
class DrawRectCmd {
    +x: number
    +y: number
    +width: number
    +height: number
    +fillColor: any
    +lineColor: any
    +lineWidth: number
    +recover(): void
    +run(context: Context, gx: number, gy: number): void
    +cmdID: string
    +{static} ID: string
    +{static} create(x: number, y: number, width: number, height: number, fillColor: any, lineColor: any, lineWidth: number): DrawRectCmd
}
class DrawTextureCmd {
    +texture: Texture
    +x: number
    +y: number
    +width: number
    +height: number
    +matrix: Matrix
    +alpha: number
    +color: string
    +colorFlt: ColorFilter
    +blendMode: string
    +uv: number[]
    +recover(): void
    +run(context: Context, gx: number, gy: number): void
    +cmdID: string
    +{static} ID: string
    +{static} create(texture: Texture, x: number, y: number, width: number, height: number, matrix: Matrix, alpha: number, color: string, blendMode: string, uv?: number[]): DrawTextureCmd
}
class FillTextureCmd {
    +texture: Texture
    +x: number
    +y: number
    +width: number
    +height: number
    +type: string
    +offset: Point
    +other: any
    +recover(): void
    +run(context: Context, gx: number, gy: number): void
    +cmdID: string
    +{static} ID: string
    +{static} create(texture: Texture, x: number, y: number, width: number, height: number, type: string, offset: Point, other: any): FillTextureCmd
}
class RestoreCmd {
    +recover(): void
    +run(context: Context, gx: number, gy: number): void
    +cmdID: string
    +{static} ID: string
    +{static} create(): RestoreCmd
}
class RotateCmd {
    +angle: number
    +pivotX: number
    +pivotY: number
    +recover(): void
    +run(context: Context, gx: number, gy: number): void
    +cmdID: string
    +{static} ID: string
    +{static} create(angle: number, pivotX: number, pivotY: number): RotateCmd
}
class ScaleCmd {
    +scaleX: number
    +scaleY: number
    +pivotX: number
    +pivotY: number
    +recover(): void
    +run(context: Context, gx: number, gy: number): void
    +cmdID: string
    +{static} ID: string
    +{static} create(scaleX: number, scaleY: number, pivotX: number, pivotY: number): ScaleCmd
}
class TransformCmd {
    +matrix: Matrix
    +pivotX: number
    +pivotY: number
    +recover(): void
    +run(context: Context, gx: number, gy: number): void
    +cmdID: string
    +{static} ID: string
    +{static} create(matrix: Matrix, pivotX: number, pivotY: number): TransformCmd
}
class TranslateCmd {
    +tx: number
    +ty: number
    +recover(): void
    +run(context: Context, gx: number, gy: number): void
    +cmdID: string
    +{static} ID: string
    +{static} create(tx: number, ty: number): TranslateCmd
}
class GrahamScan {
    -{static} _mPointList: any[]
    -{static} _tempPointList: any[]
    -{static} _temPList: any[]
    -{static} _temArr: any[]
    +{static} multiply(p1: Point, p2: Point, p0: Point): number
    +{static} dis(p1: Point, p2: Point): number
    -{static} _getPoints(count: number, tempUse?: boolean, rst?: any[]): any[]
    +{static} getFrom(rst: any[], src: any[], count: number): any[]
    +{static} getFromR(rst: any[], src: any[], count: number): any[]
    +{static} pListToPointList(pList: any[], tempUse?: boolean): any[]
    +{static} pointListToPlist(pointList: any[]): any[]
    +{static} scanPList(pList: any[]): any[]
    +{static} scan(PointSet: any[]): any[]
}
class Render {
    -_timeId: number
    -_onVisibilitychange(): void
    +initRender(canvas: HTMLCanvas, w: number, h: number): boolean
    -_enterFrame(e?: any): void
    +{static} _context: Context
    +{static} _mainCanvas: HTMLCanvas
    +{static} supportWebGLPlusCulling: boolean
    +{static} supportWebGLPlusAnimation: boolean
    +{static} supportWebGLPlusRendering: boolean
    +{static} isConchApp: boolean
    +{static} is3DMode: boolean
    +{static} context: Context
    +{static} canvas: any
}
class DrawTrianglesCmd {
    +texture: Texture
    +x: number
    +y: number
    +vertices: Float32Array
    +uvs: Float32Array
    +indices: Uint16Array
    +matrix: Matrix
    +alpha: number
    +blendMode: string
    +color: ColorFilter
    +colorNum: number
    +recover(): void
    +run(context: Context, gx: number, gy: number): void
    +cmdID: string
    +{static} ID: string
    +{static} create(texture: Texture, x: number, y: number, vertices: Float32Array, uvs: Float32Array, indices: Uint16Array, matrix: Matrix, alpha: number, color: string, blendMode: string, colorNum: number): DrawTrianglesCmd
}
class Draw9GridTexture {
    +texture: Texture
    +x: number
    +y: number
    +width: number
    +height: number
    +sizeGrid: any[]
    +recover(): void
    +run(context: Context, gx: number, gy: number): void
    +cmdID: string
    +{static} ID: string
    +{static} create(texture: Texture, x: number, y: number, width: number, height: number, sizeGrid: any[]): Draw9GridTexture
}
class GraphicsBounds {
    -_temp: any[]
    -_bounds: Rectangle
    -_rstBoundPoints: any[]
    -_cacheBoundsType: boolean
    +_graphics: Graphics
    +destroy(): void
    +reset(): void
    +getBounds(realSize?: boolean): Rectangle
    +getBoundPoints(realSize?: boolean): any[]
    -_getCmdPoints(realSize?: boolean): any[]
    -_switchMatrix(tMatix: Matrix, tempMatrix: Matrix): void
    -_getPiePoints(x: number, y: number, radius: number, startAngle: number, endAngle: number): any[]
    -_getTriAngBBXPoints(vert: Float32Array): number[]
    -_getDraw9GridBBXPoints(cmd: Draw9GridTexture): number[]
    -_getPathPoints(paths: any[]): any[]
    -{static} _tempMatrix: Matrix
    -{static} _initMatrix: Matrix
    -{static} _tempPoints: any[]
    -{static} _tempMatrixArrays: any[]
    -{static} _tempCmds: any[]
    +{static} create(): GraphicsBounds
    -{static} _addPointArrToRst(rst: any[], points: any[], matrix: Matrix, dx?: number, dy?: number): void
    -{static} _addPointToRst(rst: any[], x: number, y: number, matrix: Matrix): void
}
class ClipRectCmd {
    +x: number
    +y: number
    +width: number
    +height: number
    +recover(): void
    +run(context: Context, gx: number, gy: number): void
    +cmdID: string
    +{static} ID: string
    +{static} create(x: number, y: number, width: number, height: number): ClipRectCmd
}
class DrawTexturesCmd {
    +texture: Texture
    +pos: any[]
    +recover(): void
    +run(context: Context, gx: number, gy: number): void
    +cmdID: string
    +{static} ID: string
    +{static} create(texture: Texture, pos: any[]): DrawTexturesCmd
}
class FillTextCmd {
    -_text: string | WordText
    +_textIsWorldText: boolean
    +_words: HTMLChar[]
    +x: number
    +y: number
    -_font: string
    -_color: string
    -_borderColor: string
    -_lineWidth: number
    -_textAlign: string
    -_fontColor: number
    -_strokeColor: number
    -_fontObj: FontInfo
    -_nTexAlign: number
    +recover(): void
    +run(context: Context, gx: number, gy: number): void
    +cmdID: string
    +text: string | WordText
    +text: string | WordText
    +font: string
    +font: string
    +color: string
    +color: string
    +textAlign: string
    +textAlign: string
    +{static} ID: string
    -{static} _defFontObj: FontInfo
    +{static} create(text: string | WordText, words: HTMLChar[], x: number, y: number, font: string, color: string, textAlign: string, lineWidth: number, borderColor: string): FillTextCmd
}
class SaveCmd {
    +recover(): void
    +run(context: Context, gx: number, gy: number): void
    +cmdID: string
    +{static} ID: string
    +{static} create(): SaveCmd
}
class CacheManger {
    +{static} loopTimeLimit: number
    -{static} _cacheList: any[]
    -{static} _index: number
    +{static} regCacheByFunction(disposeFunction: Function, getCacheListFunction: Function): void
    +{static} unRegCacheByFunction(disposeFunction: Function, getCacheListFunction: Function): void
    +{static} forceDispose(): void
    +{static} beginCheck(waitTime?: number): void
    +{static} stopCheck(): void
    -{static} _checkLoop(): void
}
class VectorGraphManager {
    +useDic: any
    +shapeDic: any
    +shapeLineDic: any
    -_id: number
    -_checkKey: boolean
    -_freeIdArray: any[]
    +getId(): number
    +addShape(id: number, shape: any): void
    +addLine(id: number, Line: any): void
    +getShape(id: number): void
    +deleteShape(id: number): void
    +getCacheList(): any[]
    +startDispose(key: boolean): void
    +endDispose(): void
    +{static} instance: VectorGraphManager
    +{static} getInstance(): VectorGraphManager
}
class Graphics {
    +_sp: Sprite
    +_one: any
    +_render: Function
    -_cmds: any[]
    #_vectorgraphArray: any[]
    -_graphicBounds: GraphicsBounds
    +autoDestroy: boolean
    +_createData(): void
    +_clearData(): void
    +_destroyData(): void
    +destroy(): void
    +clear(recoverCmds?: boolean): void
    -_clearBoundsCache(): void
    -_initGraphicBounds(): void
    +_repaint(): void
    +_isOnlyOne(): boolean
    +cmds: any[]
    +cmds: any[]
    +getBounds(realSize?: boolean): Rectangle
    +getBoundPoints(realSize?: boolean): any[]
    +drawImage(texture: Texture, x?: number, y?: number, width?: number, height?: number): DrawImageCmd
    +drawTexture(texture: Texture, x?: number, y?: number, width?: number, height?: number, matrix?: Matrix, alpha?: number, color?: string, blendMode?: string, uv?: number[]): DrawTextureCmd
    +drawTextures(texture: Texture, pos: any[]): DrawTexturesCmd
    +drawTriangles(texture: Texture, x: number, y: number, vertices: Float32Array, uvs: Float32Array, indices: Uint16Array, matrix?: Matrix, alpha?: number, color?: string, blendMode?: string, colorNum?: number): DrawTrianglesCmd
    +fillTexture(texture: Texture, x: number, y: number, width?: number, height?: number, type?: string, offset?: Point): FillTextureCmd
    +_saveToCmd(fun: Function, args: any): any
    +clipRect(x: number, y: number, width: number, height: number): ClipRectCmd
    +fillText(text: string, x: number, y: number, font: string, color: string, textAlign: string): FillTextCmd
    +fillBorderText(text: string, x: number, y: number, font: string, fillColor: string, textAlign: string, lineWidth: number, borderColor: string): FillTextCmd
    +fillWords(words: any[], x: number, y: number, font: string, color: string): FillTextCmd
    +fillBorderWords(words: any[], x: number, y: number, font: string, fillColor: string, borderColor: string, lineWidth: number): FillTextCmd
    +strokeText(text: string, x: number, y: number, font: string, color: string, lineWidth: number, textAlign: string): FillTextCmd
    +alpha(alpha: number): AlphaCmd
    +transform(matrix: Matrix, pivotX?: number, pivotY?: number): TransformCmd
    +rotate(angle: number, pivotX?: number, pivotY?: number): RotateCmd
    +scale(scaleX: number, scaleY: number, pivotX?: number, pivotY?: number): ScaleCmd
    +translate(tx: number, ty: number): TranslateCmd
    +save(): SaveCmd
    +restore(): RestoreCmd
    +replaceText(text: string): boolean
    -_isTextCmd(cmd: any): boolean
    +replaceTextColor(color: string): void
    -_setTextCmdColor(cmdO: any, color: string): void
    +loadImage(url: string, x?: number, y?: number, width?: number, height?: number, complete?: Function): void
    +_renderEmpty(sprite: Sprite, context: Context, x: number, y: number): void
    +_renderAll(sprite: Sprite, context: Context, x: number, y: number): void
    +_renderOne(sprite: Sprite, context: Context, x: number, y: number): void
    +_renderOneImg(sprite: Sprite, context: Context, x: number, y: number): void
    +drawLine(fromX: number, fromY: number, toX: number, toY: number, lineColor: string, lineWidth?: number): DrawLineCmd
    +drawLines(x: number, y: number, points: any[], lineColor: any, lineWidth?: number): DrawLinesCmd
    +drawCurves(x: number, y: number, points: any[], lineColor: any, lineWidth?: number): DrawCurvesCmd
    +drawRect(x: number, y: number, width: number, height: number, fillColor: any, lineColor?: any, lineWidth?: number): DrawRectCmd
    +drawCircle(x: number, y: number, radius: number, fillColor: any, lineColor?: any, lineWidth?: number): DrawCircleCmd
    +drawPie(x: number, y: number, radius: number, startAngle: number, endAngle: number, fillColor: any, lineColor?: any, lineWidth?: number): DrawPieCmd
    +drawPoly(x: number, y: number, points: any[], fillColor: any, lineColor?: any, lineWidth?: number): DrawPolyCmd
    +drawPath(x: number, y: number, paths: any[], brush?: any, pen?: any): DrawPathCmd
    +draw9Grid(texture: Texture, x?: number, y?: number, width?: number, height?: number, sizeGrid?: any[]): void
}
class HitArea {
    -_hit: Graphics
    -_unHit: Graphics
    +contains(x: number, y: number): boolean
    +hit: Graphics
    +hit: Graphics
    +unHit: Graphics
    +unHit: Graphics
    -{static} _cmds: any[]
    -{static} _rect: Rectangle
    -{static} _ptPoint: Point
    +{static} _isHitGraphic(x: number, y: number, graphic: Graphics): boolean
    +{static} _isHitCmd(x: number, y: number, cmd: any): boolean
    +{static} _ptInPolygon(x: number, y: number, areaPoints: any[]): boolean
}
class ClassUtils {
    -{static} DrawTypeDic: any
    -{static} _temParam: any[]
    -{static} _classMap: any
    -{static} _tM: Matrix
    -{static} _alpha: number
    +{static} regClass(className: string, classDef: any): void
    +{static} regShortClassName(classes: any[]): void
    +{static} getRegClass(className: string): any
    +{static} getClass(className: string): any
    +{static} getInstance(className: string): any
    +{static} createByJson(json: any, node?: any, root?: Node, customHandler?: Handler, instanceHandler?: Handler): any
    +{static} _addGraphicsToSprite(graphicO: any, sprite: Sprite): void
    +{static} _addGraphicToSprite(graphicO: any, sprite: Sprite, isChild?: boolean): void
    -{static} _getGraphicsFromSprite(dataO: any, sprite: Sprite): Graphics
    -{static} _getTransformData(propsO: any): Matrix
    -{static} _addGraphicToGraphics(graphicO: any, graphic: Graphics): void
    -{static} _adptLineData(params: any[]): any[]
    -{static} _adptTextureData(params: any[]): any[]
    -{static} _adptLinesData(params: any[]): any[]
    +{static} _isDrawType(type: string): boolean
    -{static} _getParams(obj: any, params: any[], xPos?: number, adptFun?: string): any[]
    +{static} _getPointListByStr(str: string): any[]
    -{static} _getObjVar(obj: any, key: string, noValue: any): any
}
class BitmapFont {
    -_texture: Texture
    -_fontCharDic: any
    -_fontWidthMap: any
    -_complete: Handler
    -_path: string
    -_maxWidth: number
    -_spaceWidth: number
    -_padding: any[]
    +fontSize: number
    +autoScaleSize: boolean
    +letterSpacing: number
    +loadFont(path: string, complete: Handler): void
    -_onLoaded(): void
    +parseFont(xml: XMLDocument, texture: Texture): void
    +parseFont2(xml: XMLDocument, texture: Texture): void
    +getCharTexture(char: string): Texture
    +destroy(): void
    +setSpaceWidth(spaceWidth: number): void
    +getCharWidth(char: string): number
    +getTextWidth(text: string): number
    +getMaxWidth(): number
    +getMaxHeight(): number
    +_drawText(text: string, sprite: Sprite, drawX: number, drawY: number, align: string, width: number): void
}
class CallLater {
    -_pool: LaterHandler[]
    -_map: { [key: string]: LaterHandler; }
    -_laters: LaterHandler[]
    +_update(): void
    -_getHandler(caller: any, method: any): LaterHandler
    +callLater(caller: any, method: Function, args?: any[]): void
    +runCallLater(caller: any, method: Function): void
    +{static} I: CallLater
}
class LaterHandler {
    +key: string
    +caller: any
    +method: Function
    +args: any[]
    +clear(): void
    +run(): void
}
class Timer {
    +scale: number
    +currTimer: number
    +currFrame: number
    +_delta: number
    +_lastTimer: number
    -_map: any[]
    -_handlers: any[]
    -_temp: any[]
    -_count: number
    +delta: number
    +_update(): void
    -_clearHandlers(): void
    -_recoverHandler(handler: TimerHandler): void
    +_create(useFrame: boolean, repeat: boolean, delay: number, caller: any, method: Function, args: any[], coverBefore: boolean): TimerHandler
    -_indexHandler(handler: TimerHandler): void
    +once(delay: number, caller: any, method: Function, args?: any[], coverBefore?: boolean): void
    +loop(delay: number, caller: any, method: Function, args?: any[], coverBefore?: boolean, jumpFrame?: boolean): void
    +frameOnce(delay: number, caller: any, method: Function, args?: any[], coverBefore?: boolean): void
    +frameLoop(delay: number, caller: any, method: Function, args?: any[], coverBefore?: boolean): void
    +toString(): string
    +clear(caller: any, method: Function): void
    +clearAll(caller: any): void
    -_getHandler(caller: any, method: any): TimerHandler
    +callLater(caller: any, method: Function, args?: any[]): void
    +runCallLater(caller: any, method: Function): void
    +runTimer(caller: any, method: Function): void
    +pause(): void
    +resume(): void
    +{static} gSysTimer: Timer
    -{static} _pool: any[]
    +{static} _mid: number
}
class TimerHandler {
    +key: number
    +repeat: boolean
    +delay: number
    +userFrame: boolean
    +exeTime: number
    +caller: any
    +method: Function
    +args: any[]
    +jumpFrame: boolean
    +clear(): void
    +run(withClear: boolean): void
}
class Text extends Sprite {
    -_clipPoint: Point
    #_text: string
    #_isChanged: boolean
    #_textWidth: number
    #_textHeight: number
    #_lines: any[]
    #_lineWidths: number[]
    #_startX: number
    #_startY: number
    #_words: WordText[]
    #_charSize: any
    #_valign: string
    +_fontSize: number
    +_font: string
    +_color: string
    -_singleCharRender: boolean
    +overflow: string
    +getStyle(): SpriteStyle
    #_getTextStyle(): TextStyle
    +destroy(destroyChild?: boolean): void
    +_getBoundPointsM(ifRotate?: boolean): any[]
    +getGraphicBounds(realSize?: boolean): Rectangle
    +width: number
    +width: number
    +_getCSSStyle(): TextStyle
    +height: number
    +height: number
    +textWidth: number
    +textHeight: number
    +text: string
    +text: string
    +get_text(): string
    +set_text(value: string): void
    +lang(text: string, arg1?: any, arg2?: any, arg3?: any, arg4?: any, arg5?: any, arg6?: any, arg7?: any, arg8?: any, arg9?: any, arg10?: any): void
    +font: string
    +font: string
    +fontSize: number
    +fontSize: number
    +bold: boolean
    +bold: boolean
    +color: string
    +color: string
    +get_color(): string
    +set_color(value: string): void
    +italic: boolean
    +italic: boolean
    +align: string
    +align: string
    +valign: string
    +valign: string
    +wordWrap: boolean
    +wordWrap: boolean
    +leading: number
    +leading: number
    +padding: any[]
    +padding: any[]
    +bgColor: string
    +bgColor: string
    +set_bgColor(value: string): void
    +get_bgColor(): string
    +borderColor: string
    +borderColor: string
    +stroke: number
    +stroke: number
    +strokeColor: string
    +strokeColor: string
    #isChanged: boolean
    #_getContextFont(): string
    #_isPassWordMode(): boolean
    #_getPassWordTxt(txt: string): string
    #_renderText(): void
    -_drawUnderline(align: string, x: number, y: number, lineIndex: number): void
    +typeset(): void
    -_evalTextSize(): void
    -_checkEnabledViewportOrNot(): boolean
    +changeText(text: string): void
    #_parseLines(text: string): void
    #_parseLine(line: string, wordWrapWidth: number): void
    -_getTextWidth(text: string): number
    -_getWordWrapWidth(): number
    +getCharPoint(charIndex: number, out?: Point): Point
    +scrollX: number
    +scrollX: number
    +scrollY: number
    +scrollY: number
    +maxScrollX: number
    +maxScrollY: number
    +lines: any[]
    +underlineColor: string
    +underlineColor: string
    +underline: boolean
    +underline: boolean
    +singleCharRender: boolean
    +singleCharRender: boolean
    +{static} VISIBLE: string
    +{static} SCROLL: string
    +{static} HIDDEN: string
    +{static} defaultFontSize: number
    +{static} defaultFont: string
    +{static} defaultFontStr(): string
    +{static} langPacks: any
    +{static} isComplexText: boolean
    +{static} fontFamilyMap: any
    +{static} _testWord: string
    -{static} _bitmapFonts: any
    +{static} CharacterCache: boolean
    +{static} RightToLeft: boolean
    +{static} registerBitmapFont(name: string, bitmapFont: BitmapFont): void
    +{static} unregisterBitmapFont(name: string, destroy?: boolean): void
}
class Input extends Text {
    #_focus: boolean
    #_multiline: boolean
    #_editable: boolean
    #_restrictPattern: any
    #_maxChars: number
    -_type: string
    -_prompt: string
    -_promptColor: string
    -_originColor: string
    -_content: string
    +setSelection(startIndex: number, endIndex: number): void
    +multiline: boolean
    +multiline: boolean
    +nativeInput: any
    -_onUnDisplay(e?: Event): void
    -_onMouseDown(e: Event): void
    -_syncInputTransform(): void
    +select(): void
    +focus: boolean
    +focus: boolean
    -_setInputMethod(): void
    -_focusIn(): void
    -_setPromptColor(): void
    -_focusOut(): void
    -_onKeyDown(e: any): void
    +text: string
    +text: string
    +changeText(text: string): void
    +color: string
    +color: string
    +bgColor: string
    +bgColor: string
    +restrict: string
    +restrict: string
    +editable: boolean
    +editable: boolean
    +maxChars: number
    +maxChars: number
    +prompt: string
    +prompt: string
    +promptColor: string
    +promptColor: string
    +type: string
    +type: string
    +{static} TYPE_TEXT: string
    +{static} TYPE_PASSWORD: string
    +{static} TYPE_EMAIL: string
    +{static} TYPE_URL: string
    +{static} TYPE_NUMBER: string
    +{static} TYPE_RANGE: string
    +{static} TYPE_DATE: string
    +{static} TYPE_MONTH: string
    +{static} TYPE_WEEK: string
    +{static} TYPE_TIME: string
    +{static} TYPE_DATE_TIME: string
    +{static} TYPE_DATE_TIME_LOCAL: string
    +{static} TYPE_SEARCH: string
    #{static} input: any
    #{static} area: any
    #{static} inputElement: any
    #{static} inputContainer: any
    #{static} confirmButton: any
    #{static} promptStyleDOM: any
    +{static} IOS_IFRAME: boolean
    -{static} inputHeight: number
    +{static} isInputting: boolean
    +{static} __init__(): void
    -{static} _popupInputMethod(e: any): void
    -{static} _createInputElement(): void
    -{static} _initInput(input: any): void
    -{static} _processInputting(e: any): void
    -{static} _stopEvent(e: any): void
    -{static} stageMatrix: Matrix
}
class RunDriver {
    +{static} createShaderCondition: Function
    +{static} changeWebGLSize: Function
}
class Stage extends Sprite {
    +focus: Node
    +offset: Point
    -_frameRate: string
    +designWidth: number
    +designHeight: number
    +canvasRotation: boolean
    +canvasDegree: number
    +renderingEnabled: boolean
    +screenAdaptationEnabled: boolean
    +_canvasTransform: Matrix
    -_screenMode: string
    -_scaleMode: string
    -_alignV: string
    -_alignH: string
    -_bgColor: string
    -_mouseMoveTime: number
    -_renderCount: number
    -_safariOffsetY: number
    -_frameStartTime: number
    -_previousOrientation: number
    -_isFocused: boolean
    -_isVisibility: boolean
    +_wgColor: number[]
    +_scene3Ds: any[]
    -_globalRepaintSet: boolean
    -_globalRepaintGet: boolean
    +_3dUI: Sprite[]
    +_curUIBase: Sprite
    +useRetinalCanvas: boolean
    -_isInputting(): boolean
    +width: number
    +width: number
    +height: number
    +height: number
    +transform: Matrix
    +transform: Matrix
    +isFocused: boolean
    +isVisibility: boolean
    -_changeCanvasSize(): void
    #_resetCanvas(): void
    +setScreenSize(screenWidth: number, screenHeight: number): void
    -_formatData(value: number): number
    +scaleMode: string
    +scaleMode: string
    +alignH: string
    +alignH: string
    +alignV: string
    +alignV: string
    +bgColor: string
    +bgColor: string
    +mouseX: number
    +mouseY: number
    +getMousePoint(): Point
    +clientScaleX: number
    +clientScaleY: number
    +screenMode: string
    +screenMode: string
    +repaint(type?: number): void
    +parentRepaint(type?: number): void
    +_loop(): boolean
    +getFrameTm(): number
    -_onmouseMove(e: Event): void
    +getTimeFromFrameStart(): number
    +visible: boolean
    +visible: boolean
    +render(context: Context, x: number, y: number): void
    +renderToNative(context: Context, x: number, y: number): void
    -_updateTimers(): void
    +fullScreenEnabled: boolean
    +frameRate: string
    +frameRate: string
    -_requestFullscreen(): void
    -_fullScreenChanged(): void
    +exitFullscreen(): void
    +isGlobalRepaint(): boolean
    +setGlobalRepaint(): void
    +add3DUI(uibase: Sprite): void
    +remove3DUI(uibase: Sprite): boolean
    +{static} SCALE_NOSCALE: string
    +{static} SCALE_EXACTFIT: string
    +{static} SCALE_SHOWALL: string
    +{static} SCALE_NOBORDER: string
    +{static} SCALE_FULL: string
    +{static} SCALE_FIXED_WIDTH: string
    +{static} SCALE_FIXED_HEIGHT: string
    +{static} SCALE_FIXED_AUTO: string
    +{static} ALIGN_LEFT: string
    +{static} ALIGN_RIGHT: string
    +{static} ALIGN_CENTER: string
    +{static} ALIGN_TOP: string
    +{static} ALIGN_MIDDLE: string
    +{static} ALIGN_BOTTOM: string
    +{static} SCREEN_NONE: string
    +{static} SCREEN_HORIZONTAL: string
    +{static} SCREEN_VERTICAL: string
    +{static} FRAME_FAST: string
    +{static} FRAME_SLOW: string
    +{static} FRAME_MOUSE: string
    +{static} FRAME_SLEEP: string
    +{static} clear: Function
}
class Utils {
    +{static} gStage: Stage
    -{static} _gid: number
    -{static} _pi: number
    -{static} _pi2: number
    #{static} _extReg: RegExp
    +{static} toRadian(angle: number): number
    +{static} toAngle(radian: number): number
    +{static} toHexColor(color: number): string
    +{static} getGID(): number
    +{static} parseXMLFromString: Function
    +{static} concatArray(source: any[], array: any[]): any[]
    +{static} clearArray(array: any[]): any[]
    +{static} copyArray(source: any[], array: any[]): any[]
    +{static} getGlobalRecByPoints(sprite: Sprite, x0: number, y0: number, x1: number, y1: number): Rectangle
    +{static} getGlobalPosAndScale(sprite: Sprite): Rectangle
    +{static} bind(fun: Function, scope: any): Function
    +{static} updateOrder(array: any[]): boolean
    +{static} transPointList(points: any[], x: number, y: number): void
    +{static} parseInt(str: string, radix?: number): number
    +{static} getFileExtension(path: string): string
    +{static} getTransformRelativeToWindow(coordinateSpace: Sprite, x: number, y: number): any
    +{static} fitDOMElementInArea(dom: any, coordinateSpace: Sprite, x: number, y: number, width: number, height: number): void
    +{static} isOkTextureList(textureList: any[]): boolean
    +{static} isOKCmdList(cmds: any[]): boolean
    +{static} getQueryString(name: string): string
}
class Prefab {
    +json: any
    +create(): any
}
class SoundChannel extends EventDispatcher {
    +url: string
    +loops: number
    +startTime: number
    +isStopped: boolean
    +completeHandler: Handler
    +volume: number
    +volume: number
    +position: number
    +duration: number
    +play(): void
    +stop(): void
    +pause(): void
    +resume(): void
    #__runComplete(handler: Handler): void
}
class Sound extends EventDispatcher {
    +load(url: string): void
    +play(startTime?: number, loops?: number): SoundChannel
    +duration: number
    +dispose(): void
}
class AudioSoundChannel extends SoundChannel {
    -_audio: HTMLAudioElement
    -_onEnd: (evt: Event) => void
    -_resumePlay: (evt: Event) => void
    -__onEnd(evt: Event): void
    -__resumePlay(): void
    +play(): void
    +position: number
    +duration: number
    +stop(): void
    +pause(): void
    +resume(): void
    +volume: number
    +volume: number
}
class AudioSound extends EventDispatcher {
    +url: string
    +audio: HTMLAudioElement
    +loaded: boolean
    +dispose(): void
    +load(url: string): void
    +play(startTime?: number, loops?: number): SoundChannel
    +duration: number
    -{static} _audioCache: any
    +{static} _musicAudio: HTMLAudioElement
    +{static} _initMusicAudio(): void
    -{static} _makeMusicOK(): void
}
class WebAudioSoundChannel extends SoundChannel {
    +audioBuffer: any
    -gain: any
    -bufferSource: any
    -_currentTime: number
    -_volume: number
    -_startTime: number
    -_pauseTime: number
    -context: any
    -_onPlayEnd: Function
    +play(): void
    -__onPlayEnd(): void
    +position: number
    +duration: number
    -_clearBufferSource(): void
    -_tryClearBuffer(sourceNode: any): void
    +stop(): void
    +pause(): void
    +resume(): void
    +volume: number
    +volume: number
    -{static} _tryCleanFailed: boolean
    +{static} SetTargetDelay: number
}
class WebAudioSound extends EventDispatcher {
    +url: string
    +loaded: boolean
    +data: ArrayBuffer
    +audioBuffer: any
    -__toPlays: any[]
    -_disposed: boolean
    +load(url: string): void
    -_err(): void
    -_loaded(audioBuffer: any): void
    -_removeLoadEvents(): void
    -__playAfterLoaded(): void
    +play(startTime?: number, loops?: number, channel?: SoundChannel): SoundChannel
    +duration: number
    +dispose(): void
    -{static} _dataCache: any
    +{static} webAudioEnabled: boolean
    +{static} ctx: any
    +{static} buffs: any[]
    +{static} isDecoding: boolean
    +{static} _miniBuffer: any
    +{static} e: EventDispatcher
    -{static} _unlocked: boolean
    +{static} tInfo: any
    -{static} __loadingSound: any
    +{static} decode(): void
    -{static} _done(audioBuffer: any): void
    -{static} _fail(): void
    -{static} _playEmptySound(): void
    -{static} _unlock(): void
    +{static} initWebAudio(): void
}
class SoundManager {
    +{static} musicVolume: number
    +{static} soundVolume: number
    +{static} playbackRate: number
    -{static} _useAudioMusic: boolean
    -{static} _muted: boolean
    -{static} _soundMuted: boolean
    -{static} _musicMuted: boolean
    +{static} _bgMusic: string
    -{static} _musicChannel: SoundChannel
    -{static} _channels: any[]
    -{static} _autoStopMusic: boolean
    -{static} _blurPaused: boolean
    -{static} _isActive: boolean
    +{static} _soundClass: new () => any
    +{static} _musicClass: new () => any
    -{static} _lastSoundUsedTimeDic: any
    -{static} _isCheckingDispose: boolean
    +{static} __init__(): boolean
    +{static} autoReleaseSound: boolean
    +{static} addChannel(channel: SoundChannel): void
    +{static} removeChannel(channel: SoundChannel): void
    +{static} disposeSoundLater(url: string): void
    -{static} _checkDisposeSound(): void
    +{static} disposeSoundIfNotUsed(url: string): void
    +{static} autoStopMusic: boolean
    +{static} autoStopMusic: boolean
    -{static} _visibilityChange(): void
    -{static} _stageOnBlur(): void
    -{static} _recoverWebAudio(): void
    -{static} _stageOnFocus(): void
    +{static} muted: boolean
    +{static} muted: boolean
    +{static} soundMuted: boolean
    +{static} soundMuted: boolean
    +{static} musicMuted: boolean
    +{static} musicMuted: boolean
    +{static} useAudioMusic: boolean
    +{static} useAudioMusic: boolean
    +{static} playSound(url: string, loops?: number, complete?: Handler, soundClass?: new () => any, startTime?: number): SoundChannel
    +{static} destroySound(url: string): void
    +{static} playMusic(url: string, loops?: number, complete?: Handler, startTime?: number): SoundChannel
    +{static} stopSound(url: string): void
    +{static} stopAll(): void
    +{static} stopAllSound(): void
    +{static} stopMusic(): void
    +{static} setSoundVolume(volume: number, url?: string): void
    +{static} setMusicVolume(volume: number): void
    -{static} _setVolume(url: string, volume: number): void
}
class Byte {
    #_xd_: boolean
    -_allocated_: number
    #_d_: any
    #_u8d_: any
    #_pos_: number
    #_length: number
    +buffer: ArrayBuffer
    +endian: string
    +endian: string
    +length: number
    +length: number
    -_resizeBuffer(len: number): void
    +getString(): string
    +readString(): string
    +getFloat32Array(start: number, len: number): any
    +readFloat32Array(start: number, len: number): any
    +getUint8Array(start: number, len: number): Uint8Array
    +readUint8Array(start: number, len: number): Uint8Array
    +getInt16Array(start: number, len: number): any
    +readInt16Array(start: number, len: number): any
    +getFloat32(): number
    +readFloat32(): number
    +getFloat64(): number
    +readFloat64(): number
    +writeFloat32(value: number): void
    +writeFloat64(value: number): void
    +getInt32(): number
    +readInt32(): number
    +getUint32(): number
    +readUint32(): number
    +writeInt32(value: number): void
    +writeUint32(value: number): void
    +getInt16(): number
    +readInt16(): number
    +getUint16(): number
    +readUint16(): number
    +writeUint16(value: number): void
    +writeInt16(value: number): void
    +getUint8(): number
    +readUint8(): number
    +writeUint8(value: number): void
    +_getUInt8(pos: number): number
    +_readUInt8(pos: number): number
    +_getUint16(pos: number): number
    +_readUint16(pos: number): number
    +_getMatrix(): Matrix
    +_readMatrix(): Matrix
    -_rUTF(len: number): string
    +getCustomString(len: number): string
    +readCustomString(len: number): string
    +pos: number
    +pos: number
    +bytesAvailable: number
    +clear(): void
    +__getBuffer(): ArrayBuffer
    +writeUTFBytes(value: string): void
    +writeUTFString(value: string): void
    +readUTFString(): string
    +getUTFString(): string
    +readUTFBytes(len?: number): string
    +getUTFBytes(len?: number): string
    +writeByte(value: number): void
    +readByte(): number
    +getByte(): number
    +_ensureWrite(lengthToEnsure: number): void
    +writeArrayBuffer(arraybuffer: any, offset?: number, length?: number): void
    +readArrayBuffer(length: number): ArrayBuffer
    +{static} BIG_ENDIAN: string
    +{static} LITTLE_ENDIAN: string
    -{static} _sysEndian: string
    +{static} getSystemEndian(): string
}
class HttpRequest extends EventDispatcher {
    #_http: XMLHttpRequest
    #_responseType: string
    #_data: any
    #_url: string
    +send(url: string, data?: any, method?: string, responseType?: string, headers?: any[]): void
    #_onProgress(e: any): void
    #_onAbort(e: any): void
    #_onError(e: any): void
    #_onLoad(e: any): void
    #error(message: string): void
    #complete(): void
    #clear(): void
    +url: string
    +data: any
    +http: any
}
class TTFLoader {
    +fontName: string
    +complete: Handler
    +err: Handler
    -_fontTxt: string
    -_url: string
    -_div: any
    -_txtWidth: number
    -_http: HttpRequest
    +load(fontPath: string): void
    -_loadConch(): void
    -_onHttpLoaded(data?: any): void
    -_clearHttp(): void
    -_onErr(): void
    -_complete(): void
    -_checkComplete(): void
    -_loadWithFontFace(): void
    -_createDiv(): void
    -_loadWithCSS(): void
    -{static} _testString: string
}
class Loader extends EventDispatcher {
    +_data: any
    #_url: string
    #_type: string
    +_cache: boolean
    #_http: HttpRequest
    #_useWorkerLoader: boolean
    +_customParse: boolean
    +_constructParams: any[]
    +_propertyParams: any
    +_createCache: boolean
    +load(url: string, type?: string, cache?: boolean, group?: string, ignoreCache?: boolean, useWorkerLoader?: boolean): void
    +_loadResourceFilter(type: string, url: string): void
    -_loadResource(type: string, url: string): void
    -_loadHttpRequest(url: string, contentType: string, onLoadCaller: Object, onLoad: Function, onProcessCaller: any, onProcess: Function, onErrorCaller: any, onError: Function): void
    -_loadHtmlImage(url: string, onLoadCaller: any, onLoad: Function, onErrorCaller: any, onError: Function): void
    +_loadHttpRequestWhat(url: string, contentType: string): void
    #_loadTTF(url: string): void
    #_loadImage(url: string, isformatURL?: boolean): void
    +_loadSound(url: string): void
    #onProgress(value: number): void
    #onError(message: string): void
    #onLoaded(data?: any): void
    -parsePLFData(plfData: any): void
    -parsePLFBData(plfData: ArrayBuffer): void
    -parseOnePLFBFile(byte: Byte): void
    #complete(data: any): void
    +endLoad(content?: any): void
    +url: string
    +type: string
    +cache: boolean
    +data: any
    +{static} TEXT: string
    +{static} JSON: string
    +{static} PREFAB: string
    +{static} XML: string
    +{static} BUFFER: string
    +{static} IMAGE: string
    +{static} SOUND: string
    +{static} ATLAS: string
    +{static} FONT: string
    +{static} TTF: string
    +{static} PLF: string
    +{static} PLFB: string
    +{static} HIERARCHY: string
    +{static} MESH: string
    +{static} MATERIAL: string
    +{static} TEXTURE2D: string
    +{static} TEXTURECUBE: string
    +{static} ANIMATIONCLIP: string
    +{static} AVATAR: string
    +{static} TERRAINHEIGHTDATA: string
    +{static} TERRAINRES: string
    +{static} typeMap: { [key: string]: string; }
    +{static} parserMap: any
    +{static} maxTimeOut: number
    +{static} groupMap: { [key: string]: string[]; }
    +{static} loadedMap: { [key: string]: any; }
    +{static} atlasMap: { [key: string]: any[]; }
    +{static} textureMap: { [key: string]: Texture; }
    +{static} preLoadedMap: { [key: string]: ArrayBuffer; }
    #{static} _imgCache: { [key: string]: HTMLImageElement; }
    #{static} _loaders: Loader[]
    #{static} _isWorking: boolean
    #{static} _startIndex: number
    +{static} getTypeFromUrl(url: string): string
    -{static} checkNext(): void
    +{static} clearRes(url: string): void
    +{static} clearTextureRes(url: string): void
    +{static} getRes(url: string): any
    +{static} getAtlas(url: string): any[]
    +{static} cacheRes(url: string, data: any): void
    +{static} cacheTexture(url: string, data: Texture): void
    +{static} setGroup(url: string, group: string): void
    +{static} clearResByGroup(group: string): void
}
class AtlasInfoManager {
    -{static} _fileLoadDic: any
    +{static} enable(infoFile: string, callback?: Handler): void
    -{static} _onInfoLoaded(callback: Handler, data: any): void
    +{static} getFileLoadPath(file: string): string
}
class LoaderManager extends EventDispatcher {
    +retryNum: number
    +retryDelay: number
    +maxLoader: number
    -_loaders: any[]
    -_loaderCount: number
    -_resInfos: ResInfo[][]
    -_infoPool: any[]
    -_maxPriority: number
    -_failRes: any
    -_statInfo: any
    +getProgress(): number
    +resetProgress(): void
    +create(url: any, complete?: Handler, progress?: Handler, type?: string, constructParams?: any[], propertyParams?: any, priority?: number, cache?: boolean): void
    +_create(url: any, mainResou: boolean, complete?: Handler, progress?: Handler, type?: string, constructParams?: any[], propertyParams?: any, priority?: number, cache?: boolean): void
    -_createOne(url: string, mainResou: boolean, complete?: Handler, progress?: Handler, type?: string, constructParams?: any[], propertyParams?: any, priority?: number, cache?: boolean): void
    +load(url: string | string[] | loadItem[], complete?: Handler, progress?: Handler, type?: string, priority?: number, cache?: boolean, group?: string, ignoreCache?: boolean, useWorkerLoader?: boolean): LoaderManager
    -_resInfoLoaded(original: string, complete: Handler): void
    +_createLoad(url: any, complete?: Handler, progress?: Handler, type?: string, constructParams?: any[], propertyParams?: any, priority?: number, cache?: boolean, ignoreCache?: boolean): LoaderManager
    -_next(): void
    -_doLoad(resInfo: ResInfo): void
    -_endLoad(resInfo: ResInfo, content: any): void
    -_addReTry(resInfo: ResInfo): void
    +clearRes(url: string): void
    +clearTextureRes(url: string): void
    +getRes(url: string): any
    +cacheRes(url: string, data: any): void
    +setGroup(url: string, group: string): void
    +clearResByGroup(group: string): void
    +clearUnLoaded(): void
    +cancelLoadByUrls(urls: any[]): void
    +cancelLoadByUrl(url: string): void
    -_loadAssets(arr: string[] | loadItem[], complete?: Handler, progress?: Handler, type?: string, priority?: number, cache?: boolean, group?: string): LoaderManager
    +decodeBitmaps(urls: any[]): void
    -_decodeTexture(tex: Texture, ctx: any): void
    -{static} _resMap: { [key: string]: ResInfo; }
    +{static} createMap: any
    +{static} cacheRes(url: string, data: any): void
}
class ResInfo extends EventDispatcher {
    +url: string
    +type: string
    +cache: boolean
    +group: string
    +ignoreCache: boolean
    +useWorkerLoader: boolean
    +originalUrl: string
    +createCache: boolean
    +createConstructParams: any[]
    +createPropertyParams: any
}
interface loadItem {
    +url: string
    +type?: string
    +size?: number
    +priority?: number
    +useWorkerLoader?: boolean
    +progress?: number
    +group?: string
}
class Texture extends EventDispatcher {
    +uvrect: any[]
    -_destroyed: boolean
    -_bitmap: Texture2D | Texture
    +_uv: ArrayLike<number>
    -_referenceCount: number
    +_nativeObj: any
    +$_GID: number
    +offsetX: number
    +offsetY: number
    -_w: number
    -_h: number
    +sourceWidth: number
    +sourceHeight: number
    +url: string
    +scaleRate: number
    +uv: ArrayLike<number>
    +uv: ArrayLike<number>
    +width: number
    +width: number
    +height: number
    +height: number
    +bitmap: Texture2D | Texture
    +bitmap: Texture2D | Texture
    +destroyed: boolean
    +_addReference(): void
    +_removeReference(): void
    +_getSource(cb?: Function): any
    -_onLoaded(complete: Handler, context: any): void
    +getIsReady(): boolean
    +setTo(bitmap?: Texture2D | Texture, uv?: ArrayLike<number>, sourceWidth?: number, sourceHeight?: number): void
    +load(url: string, complete?: Handler): void
    +getTexturePixels(x: number, y: number, width: number, height: number): Uint8Array
    +getPixels(x: number, y: number, width: number, height: number): Uint8Array
    +recoverBitmap(onok?: Function): void
    +disposeBitmap(): void
    +destroy(force?: boolean): void
    +{static} DEF_UV: Float32Array
    +{static} NO_UV: Float32Array
    +{static} INV_UV: Float32Array
    -{static} _rect1: Rectangle
    -{static} _rect2: Rectangle
    +{static} moveUV(offsetX: number, offsetY: number, uv: any[]): any[]
    +{static} create(source: Texture2D | Texture, x: number, y: number, width: number, height: number, offsetX?: number, offsetY?: number, sourceWidth?: number, sourceHeight?: number): Texture
    +{static} _create(source: Texture2D | Texture, x: number, y: number, width: number, height: number, offsetX?: number, offsetY?: number, sourceWidth?: number, sourceHeight?: number, outTexture?: Texture): Texture
    +{static} createFromTexture(texture: Texture, x: number, y: number, width: number, height: number): Texture
}
class HTMLCanvas extends Bitmap {
    -_ctx: any
    +_source: HTMLCanvasElement
    +_texture: Texture
    +source: HTMLCanvasElement
    +_getSource(): HTMLCanvasElement
    +clear(): void
    +destroy(): void
    +release(): void
    +context: Context
    +_setContext(context: Context): void
    +getContext(contextID: string, other?: any): Context
    +getMemSize(): number
    +size(w: number, h: number): void
    +getTexture(): Texture
    +toBase64(type: string, encoderOptions: number): string
    +toBase64Async(type: string, encoderOptions: number, callBack: Function): void
}
class KeyBoardManager {
    -{static} _pressKeys: any
    +{static} enabled: boolean
    +{static} _event: Event
    +{static} __init__(): void
    -{static} _addEvent(type: string): void
    -{static} _dispatch(e: any, type: string): void
    +{static} hasKeyDown(key: number): boolean
}
class CommandEncoder {
    +_idata: any[]
    +getArrayData(): any[]
    +getPtrID(): number
    +beginEncoding(): void
    +endEncoding(): void
    +clearEncoding(): void
    +getCount(): number
    +add_ShaderValue(o: any): void
    +addShaderUniform(one: any): void
}
class LayaGLRunner {
    +{static} uploadShaderUniforms(layaGL: LayaGL, commandEncoder: CommandEncoder, shaderData: any, uploadUnTexture: boolean): number
    +{static} uploadCustomUniform(layaGL: LayaGL, custom: any[], index: number, data: any): number
    +{static} uploadShaderUniformsForNative(layaGL: any, commandEncoder: CommandEncoder, shaderData: any): number
}
class LocalStorage {
    +{static} _baseClass: any
    +{static} items: any
    +{static} support: boolean
    +{static} __init__(): boolean
    +{static} setItem(key: string, value: string): void
    +{static} getItem(key: string): string
    +{static} setJSON(key: string, value: any): void
    +{static} getJSON(key: string): any
    +{static} removeItem(key: string): void
    +{static} clear(): void
}
class Storage {
    +{static} items: any
    +{static} support: boolean
    +{static} init(): void
    +{static} setItem(key: string, value: string): void
    +{static} getItem(key: string): string
    +{static} setJSON(key: string, value: any): void
    +{static} getJSON(key: string): any
    +{static} removeItem(key: string): void
    +{static} clear(): void
}
class AnimationBase extends Sprite {
    +loop: boolean
    +wrapMode: number
    #_interval: number
    #_index: number
    #_count: number
    #_isPlaying: boolean
    #_labels: any
    #_isReverse: boolean
    #_frameRateChanged: boolean
    #_actionName: string
    -_controlNode: Sprite
    +play(start?: any, loop?: boolean, name?: string): void
    +interval: number
    +interval: number
    #_getFrameByLabel(label: string): number
    #_frameLoop(): void
    +_setControlNode(node: Sprite): void
    +_setDisplay(value: boolean): void
    #_resumePlay(): void
    +stop(): void
    +isPlaying: boolean
    +addLabel(label: string, index: number): void
    +removeLabel(label: string): void
    -_removeLabelFromList(list: any[], label: string): void
    +gotoAndStop(position: any): void
    +index: number
    +index: number
    #_displayToIndex(value: number): void
    +count: number
    +clear(): AnimationBase
    +{static} WRAP_POSITIVE: number
    +{static} WRAP_REVERSE: number
    +{static} WRAP_PINGPONG: number
}
class MathUtil {
    +{static} subtractVector3(l: Float32Array, r: Float32Array, o: Float32Array): void
    +{static} lerp(left: number, right: number, amount: number): number
    +{static} scaleVector3(f: Float32Array, b: number, e: Float32Array): void
    +{static} lerpVector3(l: Float32Array, r: Float32Array, t: number, o: Float32Array): void
    +{static} lerpVector4(l: Float32Array, r: Float32Array, t: number, o: Float32Array): void
    +{static} slerpQuaternionArray(a: Float32Array, Offset1: number, b: Float32Array, Offset2: number, t: number, out: Float32Array, Offset3: number): Float32Array
    +{static} getRotation(x0: number, y0: number, x1: number, y1: number): number
    +{static} sortBigFirst(a: number, b: number): number
    +{static} sortSmallFirst(a: number, b: number): number
    +{static} sortNumBigFirst(a: any, b: any): number
    +{static} sortNumSmallFirst(a: any, b: any): number
    +{static} sortByKey(key: string, bigFirst?: boolean, forceNum?: boolean): (a: any, b: any) => number
}
class Ease {
    -{static} HALF_PI: number
    -{static} PI2: number
    +{static} linearNone(t: number, b: number, c: number, d: number): number
    +{static} linearIn(t: number, b: number, c: number, d: number): number
    +{static} linearInOut(t: number, b: number, c: number, d: number): number
    +{static} linearOut(t: number, b: number, c: number, d: number): number
    +{static} bounceIn(t: number, b: number, c: number, d: number): number
    +{static} bounceInOut(t: number, b: number, c: number, d: number): number
    +{static} bounceOut(t: number, b: number, c: number, d: number): number
    +{static} backIn(t: number, b: number, c: number, d: number, s?: number): number
    +{static} backInOut(t: number, b: number, c: number, d: number, s?: number): number
    +{static} backOut(t: number, b: number, c: number, d: number, s?: number): number
    +{static} elasticIn(t: number, b: number, c: number, d: number, a?: number, p?: number): number
    +{static} elasticInOut(t: number, b: number, c: number, d: number, a?: number, p?: number): number
    +{static} elasticOut(t: number, b: number, c: number, d: number, a?: number, p?: number): number
    +{static} strongIn(t: number, b: number, c: number, d: number): number
    +{static} strongInOut(t: number, b: number, c: number, d: number): number
    +{static} strongOut(t: number, b: number, c: number, d: number): number
    +{static} sineInOut(t: number, b: number, c: number, d: number): number
    +{static} sineIn(t: number, b: number, c: number, d: number): number
    +{static} sineOut(t: number, b: number, c: number, d: number): number
    +{static} quintIn(t: number, b: number, c: number, d: number): number
    +{static} quintInOut(t: number, b: number, c: number, d: number): number
    +{static} quintOut(t: number, b: number, c: number, d: number): number
    +{static} quartIn(t: number, b: number, c: number, d: number): number
    +{static} quartInOut(t: number, b: number, c: number, d: number): number
    +{static} quartOut(t: number, b: number, c: number, d: number): number
    +{static} cubicIn(t: number, b: number, c: number, d: number): number
    +{static} cubicInOut(t: number, b: number, c: number, d: number): number
    +{static} cubicOut(t: number, b: number, c: number, d: number): number
    +{static} quadIn(t: number, b: number, c: number, d: number): number
    +{static} quadInOut(t: number, b: number, c: number, d: number): number
    +{static} quadOut(t: number, b: number, c: number, d: number): number
    +{static} expoIn(t: number, b: number, c: number, d: number): number
    +{static} expoInOut(t: number, b: number, c: number, d: number): number
    +{static} expoOut(t: number, b: number, c: number, d: number): number
    +{static} circIn(t: number, b: number, c: number, d: number): number
    +{static} circInOut(t: number, b: number, c: number, d: number): number
    +{static} circOut(t: number, b: number, c: number, d: number): number
}
class FrameAnimation extends AnimationBase {
    +_targetDic: any
    +_animationData: any
    #_usedFrames: any[]
    +_setUp(targetDic: any, animationData: any): void
    +clear(): AnimationBase
    #_displayToIndex(value: number): void
    #_displayNodeToFrame(node: any, frame: number, targetDic?: any): void
    -_calculateDatas(): void
    #_calculateKeyFrames(node: any): void
    +resetNodes(): void
    -_calculateNodePropFrames(keyframes: any[], frames: any[], key: string, target: number): void
    -_dealKeyFrame(keyFrame: any): void
    -_calculateFrameValues(startFrame: any, endFrame: any, result: any[]): void
    -{static} _sortIndexFun(objpre: any, objnext: any): number
}
class WeakObject {
    +_obj: any
    +set(key: any, value: any): void
    +get(key: any): any
    +del(key: any): void
    +has(key: any): boolean
    +{static} supportWeakMap: boolean
    +{static} delInterval: number
    +{static} I: WeakObject
    -{static} _maps: any[]
    +{static} __init__(): void
    +{static} clearCache(): void
}
class SceneLoader extends EventDispatcher {
    +totalCount: number
    -_completeHandler: Handler
    -_toLoadList: any[]
    -_isLoading: boolean
    -_curUrl: string
    +reset(): void
    +leftCount: number
    +loadedCount: number
    +load(url: any, is3D?: boolean, ifCheck?: boolean): void
    -_addToLoadList(url: string, is3D?: boolean): void
    -_checkNext(): void
    -loadOne(url: any, is3D?: boolean): void
    -onOneLoadComplete(): void
    +getProgress(): number
    +{static} LoadableExtensions: any
    +{static} No3dLoadTypes: any
}
class Scene extends Sprite {
    +autoDestroyAtClosed: boolean
    +url: string
    -_timer: Timer
    -_viewCreated: boolean
    +_idMap: any
    +_$componentType: string
    #createChildren(): void
    +loadScene(path: string): void
    -_onSceneLoaded(url: string): void
    +createView(view: any): void
    +getNodeByID(id: number): any
    +open(closeOther?: boolean, param?: any): void
    +onOpened(param: any): void
    +close(type?: string): void
    +onClosed(type?: string): void
    +destroy(destroyChild?: boolean): void
    +scaleX: number
    +scaleX: number
    +scaleY: number
    +scaleY: number
    +width: number
    +width: number
    +height: number
    +height: number
    #_sizeChanged(): void
    +timer: Timer
    +timer: Timer
    +{static} unDestroyedScenes: any[]
    -{static} _root: Sprite
    -{static} _loadPage: Scene
    +{static} setUIMap(url: any): void
    +{static} root: Sprite
    +{static} load(url: string, complete?: Handler, progress?: Handler): void
    +{static} open(url: string, closeOther?: boolean, param?: any, complete?: Handler, progress?: Handler): void
    -{static} _onSceneLoaded(closeOther: boolean, complete: Handler, param: any, scene: Scene): void
    +{static} close(url: string, name?: string): boolean
    +{static} closeAll(): void
    +{static} destroy(url: string, name?: string): boolean
    +{static} gc(): void
    +{static} setLoadingPage(loadPage: Scene): void
    +{static} showLoadingPage(param?: any, delay?: number): void
    -{static} _showLoading(param: any): void
    -{static} _hideLoading(): void
    +{static} hideLoadingPage(delay?: number): void
}
class SceneUtils {
    -{static} _funMap: WeakObject
    -{static} _parseWatchData: RegExp
    -{static} _parseKeyWord: RegExp
    +{static} _sheet: any
    +{static} __init(): void
    +{static} getBindFun(value: string): Function
    +{static} createByData(root: any, uiView: any): any
    +{static} createInitTool(): InitTool
    +{static} createComp(uiView: any, comp?: any, view?: any, dataMap?: any[], initTool?: InitTool): any
    -{static} setCompValue(comp: any, prop: string, value: any, view?: any, dataMap?: any[]): void
    +{static} getCompInstance(json: any): any
}
class DataWatcher {
    +comp: any
    +prop: string
    +value: string
    +exe(view: any): void
}
class InitTool {
    -_nodeRefList: any[]
    -_initList: any[]
    -_loadList: any[]
    +_idMap: any[]
    +_scene: Scene
    +reset(): void
    +recover(): void
    +addLoadRes(url: string, type?: string): void
    +addNodeRef(node: any, prop: string, referStr: string): void
    +setNodeRef(): void
    +getReferData(referStr: string): any
    +addInitItem(item: any): void
    +doInits(): void
    +finish(): void
    +beginLoad(scene: Scene): void
    +{static} create(): InitTool
}
class StatUI extends IStatRender {
    -_txt: Text
    -_leftText: Text
    +_sp: Sprite
    +_titleSp: Sprite
    +_bgSp: Sprite
    +_show: boolean
    +_useCanvas: boolean
    -_canvas: HTMLCanvas
    -_ctx: Context
    -_first: boolean
    -_vx: number
    -_width: number
    -_height: number
    -_view: any[]
    +show(x?: number, y?: number): void
    -createUIPre(x: number, y: number): void
    -createUI(x: number, y: number): void
    +enable(): void
    +hide(): void
    +set_onclick(fn: (this: GlobalEventHandlers, ev: MouseEvent) => any): void
    +loop(): void
    -renderInfoPre(): void
    -renderInfo(): void
    +isCanvasRender(): boolean
    +renderNotCanvas(ctx: any, x: number, y: number): void
    -{static} _fontSize: number
}
class SkinSV extends Value2D {
    +texcoord: any
    +position: any
    +offsetX: number
    +offsetY: number
}
class PrimitiveSV extends Value2D
class WorkerLoader extends EventDispatcher {
    +worker: Worker
    #_useWorkerLoader: boolean
    -workerMessage(data: any): void
    -imageLoaded(data: any): void
    +loadImage(url: string): void
    #_loadImage(url: string): void
    +{static} I: WorkerLoader
    +{static} workerPath: string
    -{static} _preLoadFun: Function
    -{static} _enable: boolean
    -{static} _tryEnabled: boolean
    +{static} __init__(): boolean
    +{static} workerSupported(): boolean
    +{static} enableWorkerLoader(): void
    +{static} enable: boolean
    +{static} enable: boolean
}
class Mouse {
    -{static} _style: any
    -{static} _preCursor: string
    +{static} cursor: string
    +{static} cursor: string
    +{static} __init__(): any
    +{static} hide(): void
    +{static} show(): void
}
class MeshParticle2D extends Mesh2D {
    +setMaxParticleNum(maxNum: number): void
    +releaseMesh(): void
    +destroy(): void
    +{static} const_stride: number
    -{static} _fixattriInfo: any[]
    -{static} _POOL: any[]
    +{static} __init__(): void
    +{static} getAMesh(maxNum: number): MeshParticle2D
}
class HTMLImage extends Bitmap {
    +{static} create: Function
}
class Laya {
    +{static} stage: Stage
    +{static} systemTimer: Timer
    +{static} startTimer: Timer
    +{static} physicsTimer: Timer
    +{static} updateTimer: Timer
    +{static} lateTimer: Timer
    +{static} timer: Timer
    +{static} loader: LoaderManager
    +{static} version: string
    +{static} render: Render
    -{static} _isinit: boolean
    +{static} isWXOpenDataContext: boolean
    +{static} isWXPosMsg: boolean
    +{static} __classmap: Object
    +{static} Config: typeof Config
    +{static} TextRender: typeof TextRender
    +{static} EventDispatcher: typeof EventDispatcher
    +{static} SoundChannel: typeof SoundChannel
    +{static} Stage: typeof Stage
    +{static} Render: typeof Render
    +{static} Browser: typeof Browser
    +{static} Sprite: typeof Sprite
    +{static} Node: typeof Node
    +{static} Context: typeof Context
    +{static} WebGL: typeof WebGL
    +{static} Handler: typeof Handler
    +{static} RunDriver: typeof RunDriver
    +{static} Utils: typeof Utils
    +{static} Input: typeof Input
    +{static} Loader: typeof Loader
    +{static} LocalStorage: typeof LocalStorage
    +{static} SoundManager: typeof SoundManager
    +{static} URL: typeof URL
    +{static} Event: typeof Event
    +{static} Matrix: typeof Matrix
    +{static} HTMLImage: typeof HTMLImage
    +{static} Laya: typeof Laya
    +{static} __init(_classs: any[]): void
    +{static} init(width: number, height: number, plugins: any[]): any
    +{static} _getUrlPath(): string
    +{static} _arrayBufferSlice(start: number, end: number): ArrayBuffer
    +{static} alertGlobalError: boolean
    -{static} _evcode: string
    +{static} _runScript(script: string): any
    +{static} enableDebugPanel(debugJsPath?: string): void
    -{static} isNativeRender_enable: boolean
    -{static} enableWebGLPlus(): void
    -{static} enableNative(): void
}
class Browser {
    +{static} userAgent: string
    +{static} onMobile: boolean
    +{static} onIOS: boolean
    +{static} onMac: boolean
    +{static} onIPhone: boolean
    +{static} onIPad: boolean
    +{static} onAndroid: boolean
    +{static} onWP: boolean
    +{static} onQQBrowser: boolean
    +{static} onMQQBrowser: boolean
    +{static} onSafari: boolean
    +{static} onIE: boolean
    +{static} onWeiXin: boolean
    +{static} onPC: boolean
    +{static} onMiniGame: boolean
    +{static} onBDMiniGame: boolean
    +{static} onKGMiniGame: boolean
    +{static} onQGMiniGame: boolean
    +{static} onVVMiniGame: boolean
    +{static} onAlipayMiniGame: boolean
    +{static} onQQMiniGame: boolean
    +{static} onFirefox: boolean
    +{static} onEdge: boolean
    +{static} onLayaRuntime: boolean
    +{static} supportWebAudio: boolean
    +{static} supportLocalStorage: boolean
    +{static} canvas: HTMLCanvas
    +{static} context: CanvasRenderingContext2D
    -{static} _window: any
    -{static} _document: any
    -{static} _container: any
    -{static} _pixelRatio: number
    +{static} mainCanvas: any
    -{static} hanzi: RegExp
    -{static} fontMap: any[]
    +{static} measureText: Function
    +{static} __init__(): any
    +{static} createElement(type: string): any
    +{static} getElementById(type: string): any
    +{static} removeElement(ele: any): void
    +{static} now(): number
    +{static} clientWidth: number
    +{static} clientHeight: number
    +{static} width: number
    +{static} height: number
    +{static} pixelRatio: number
    +{static} container: any
    +{static} container: any
    +{static} window: any
    +{static} document: any
}
class TouchManager {
    -preOvers: any[]
    -preDowns: any[]
    -preRightDowns: any[]
    +enable: boolean
    +_event: Event
    -_lastClickTime: number
    -_clearTempArrs(): void
    -getTouchFromArr(touchID: number, arr: any[]): any
    -removeTouchFromArr(touchID: number, arr: any[]): void
    -createTouchO(ele: any, touchID: number): any
    +onMouseDown(ele: any, touchID: number, isLeft?: boolean): void
    -sendEvents(eles: any[], type: string): void
    -getEles(start: Node, end?: Node, rst?: any[]): any[]
    -checkMouseOutAndOverOfMove(eleNew: Node, elePre: Node, touchID?: number): void
    +onMouseMove(ele: any, touchID: number): void
    +getLastOvers(): any[]
    +stageMouseOut(): void
    +onMouseUp(ele: any, touchID: number, isLeft?: boolean): void
    +{static} I: TouchManager
    -{static} _oldArr: any[]
    -{static} _newArr: any[]
    -{static} _tEleArr: any[]
}
class MouseManager {
    +mouseX: number
    +mouseY: number
    +disableMouseEvent: boolean
    +mouseDownTime: number
    +mouseMoveAccuracy: number
    +_event: Event
    -_stage: Stage
    -_captureSp: Sprite
    -_captureChain: Sprite[]
    -_captureExlusiveMode: boolean
    -_hitCaputreSp: boolean
    -_point: Point
    -_rect: Rectangle
    -_target: any
    -_lastMoveTimer: number
    -_isLeftMouse: boolean
    -_prePoint: Point
    -_touchIDs: any
    -_curTouchID: number
    -_id: number
    +__init__(stage: Stage, canvas: any): void
    -_tTouchID: number
    -initEvent(e: any, nativeEvent?: any): void
    -checkMouseWheel(e: any): void
    -onMouseMove(ele: any): void
    -onMouseDown(ele: any): void
    -onMouseUp(ele: any): void
    -check(sp: Sprite, mouseX: number, mouseY: number, callBack: Function): boolean
    -hitTest(sp: Sprite, mouseX: number, mouseY: number): boolean
    -_checkAllBaseUI(mousex: number, mousey: number, callback: Function): boolean
    +check3DUI(mousex: number, mousey: number, callback: Function): boolean
    +handleExclusiveCapture(mousex: number, mousey: number, callback: Function): boolean
    +handleCapture(mousex: number, mousey: number, callback: Function): boolean
    +runEvent(evt: any): void
    +setCapture(sp: Sprite, exclusive?: boolean): void
    +releaseCapture(): void
    +{static} instance: MouseManager
    +{static} enabled: boolean
    +{static} multiTouchEnabled: boolean
    -{static} _isTouchRespond: boolean
    -{static} _isFirstTouch: boolean
}
class Tween {
    -_complete: Handler
    -_target: any
    -_ease: Function
    -_props: any[]
    -_duration: number
    -_delay: number
    -_startTimer: number
    -_usedTimer: number
    -_usedPool: boolean
    -_delayParam: any[]
    +gid: number
    +update: Handler
    +repeat: number
    -_count: number
    +to(target: any, props: any, duration: number, ease?: Function, complete?: Handler, delay?: number, coverBefore?: boolean): Tween
    +from(target: any, props: any, duration: number, ease?: Function, complete?: Handler, delay?: number, coverBefore?: boolean): Tween
    +_create(target: any, props: any, duration: number, ease: Function, complete: Handler, delay: number, coverBefore: boolean, isTo: boolean, usePool: boolean, runNow: boolean): Tween
    -firstStart(target: any, props: any, isTo: boolean): void
    -_initProps(target: any, props: any, isTo: boolean): void
    -_beginLoop(): void
    -_doEase(): void
    +_updateEase(time: number): void
    +progress: number
    +complete(): void
    +pause(): void
    +setStartTime(startTime: number): void
    +clear(): void
    +_clear(): void
    +recover(): void
    -_remove(): void
    +restart(): void
    +resume(): void
    -{static} tweenMap: any[]
    +{static} to(target: any, props: any, duration: number, ease?: Function, complete?: Handler, delay?: number, coverBefore?: boolean, autoRecover?: boolean): Tween
    +{static} from(target: any, props: any, duration: number, ease?: Function, complete?: Handler, delay?: number, coverBefore?: boolean, autoRecover?: boolean): Tween
    +{static} clearAll(target: any): void
    +{static} clear(tween: Tween): void
    +{static} clearTween(target: any): void
    -{static} easeNone(t: number, b: number, c: number, d: number): number
}
class Dragging {
    +target: Sprite
    +ratio: number
    +maxOffset: number
    +area: Rectangle
    +hasInertia: boolean
    +elasticDistance: number
    +elasticBackTime: number
    +data: any
    -_dragging: boolean
    -_clickOnly: boolean
    -_elasticRateX: number
    -_elasticRateY: number
    -_lastX: number
    -_lastY: number
    -_offsetX: number
    -_offsetY: number
    -_offsets: any[]
    -_disableMouseEvent: boolean
    -_tween: Tween
    -_parent: Sprite
    +start(target: Sprite, area: Rectangle, hasInertia: boolean, elasticDistance: number, elasticBackTime: number, data: any, disableMouseEvent: boolean, ratio?: number): void
    -clearTimer(): void
    +stop(): void
    -loop(): void
    -checkArea(): void
    -backToArea(): void
    -onStageMouseUp(e: Event): void
    -checkElastic(): void
    -tweenMove(): void
    -clear(): void
}
class ILaya {
    +{static} Laya: any
    +{static} Timer: typeof Timer
    +{static} WorkerLoader: typeof WorkerLoader
    +{static} Dragging: typeof Dragging
    +{static} GraphicsBounds: typeof GraphicsBounds
    +{static} Sprite: typeof Sprite
    +{static} TextRender: typeof TextRender
    +{static} TextAtlas: typeof TextAtlas
    +{static} timer: Timer
    +{static} systemTimer: Timer
    +{static} startTimer: Timer
    +{static} updateTimer: Timer
    +{static} lateTimer: Timer
    +{static} physicsTimer: Timer
    +{static} stage: Stage
    +{static} Loader: typeof Loader
    +{static} loader: LoaderManager
    +{static} TTFLoader: typeof TTFLoader
    +{static} SoundManager: typeof SoundManager
    +{static} WebAudioSound: typeof WebAudioSound
    +{static} AudioSound: typeof AudioSound
    +{static} ShaderCompile: typeof ShaderCompile
    +{static} ClassUtils: typeof ClassUtils
    +{static} SceneUtils: typeof SceneUtils
    +{static} Context: typeof Context
    +{static} Render: typeof Render
    +{static} MouseManager: typeof MouseManager
    +{static} Text: typeof Text
    +{static} Browser: typeof Browser
    +{static} WebGL: typeof WebGL
    +{static} Pool: typeof Pool
    +{static} Utils: typeof Utils
    +{static} Graphics: typeof Graphics
    +{static} Submit: typeof Submit
    +{static} Stage: typeof Stage
    +{static} Resource: typeof Resource
    +{static} __classMap: Object
    +{static} regClass(c: any): void
}
class BoundsStyle {
    +bounds: Rectangle
    +userBounds: Rectangle
    +temBM: any[]
    +reset(): BoundsStyle
    +recover(): void
    +{static} create(): BoundsStyle
}
class Sprite extends Node {
    +_x: number
    +_y: number
    +_width: number
    +_height: number
    +_visible: boolean
    +_mouseState: number
    +_zOrder: number
    +_renderType: number
    +_transform: Matrix
    #_tfChanged: boolean
    #_repaint: number
    -_texture: Texture
    +_style: SpriteStyle
    +_cacheStyle: CacheStyle
    +_boundStyle: BoundsStyle
    +_graphics: Graphics
    +mouseThrough: boolean
    +autoSize: boolean
    +hitTestPrior: boolean
    +destroy(destroyChild?: boolean): void
    +updateZOrder(): void
    +_getBoundsStyle(): BoundsStyle
    +_setCustomRender(): void
    +customRenderEnable: boolean
    +cacheAs: string
    +cacheAs: string
    +_setCacheAs(value: string): void
    -_checkCanvasEnable(): void
    +staticCache: boolean
    +staticCache: boolean
    +reCache(): void
    +getRepaint(): number
    +_setX(value: number): void
    +_setY(value: number): void
    +_setWidth(texture: Texture, value: number): void
    +_setHeight(texture: Texture, value: number): void
    +x: number
    +x: number
    +y: number
    +y: number
    +width: number
    +width: number
    +set_width(value: number): void
    +get_width(): number
    +height: number
    +height: number
    +set_height(value: number): void
    +get_height(): number
    +displayWidth: number
    +displayHeight: number
    +setSelfBounds(bound: Rectangle): void
    +getBounds(): Rectangle
    +getSelfBounds(): Rectangle
    +_boundPointsToParent(ifRotate?: boolean): any[]
    +getGraphicBounds(realSize?: boolean): Rectangle
    +_getBoundPointsM(ifRotate?: boolean): any[]
    +_getCacheStyle(): CacheStyle
    +getStyle(): SpriteStyle
    +setStyle(value: SpriteStyle): void
    +scaleX: number
    +scaleX: number
    +_setScaleX(value: number): void
    +scaleY: number
    +scaleY: number
    +_setScaleY(value: number): void
    +set_scaleX(value: number): void
    +get_scaleX(): number
    +set_scaleY(value: number): void
    +get_scaleY(): number
    +rotation: number
    +rotation: number
    +_setRotation(value: number): void
    +skewX: number
    +skewX: number
    +_setSkewX(value: number): void
    +skewY: number
    +skewY: number
    +_setSkewY(value: number): void
    +_createTransform(): Matrix
    #_adjustTransform(): Matrix
    +_setTransform(value: Matrix): void
    +transform: Matrix
    +transform: Matrix
    +get_transform(): Matrix
    +set_transform(value: Matrix): void
    +_setPivotX(value: number): void
    +_getPivotX(): number
    +_setPivotY(value: number): void
    +_getPivotY(): number
    +pivotX: number
    +pivotX: number
    +pivotY: number
    +pivotY: number
    +_setAlpha(value: number): void
    +_getAlpha(): number
    +alpha: number
    +alpha: number
    +visible: boolean
    +visible: boolean
    +get_visible(): boolean
    +set_visible(value: boolean): void
    +_setBlendMode(value: string): void
    +blendMode: string
    +blendMode: string
    +graphics: Graphics
    +graphics: Graphics
    +_setGraphics(value: Graphics): void
    +_setGraphicsCallBack(): void
    +scrollRect: Rectangle
    +scrollRect: Rectangle
    +_setScrollRect(value: Rectangle): void
    +pos(x: number, y: number, speedMode?: boolean): Sprite
    +pivot(x: number, y: number): Sprite
    +size(width: number, height: number): Sprite
    +scale(scaleX: number, scaleY: number, speedMode?: boolean): Sprite
    +skew(skewX: number, skewY: number): Sprite
    +render(ctx: Context, x: number, y: number): void
    +drawToCanvas(canvasWidth: number, canvasHeight: number, offsetX: number, offsetY: number): HTMLCanvas
    +drawToTexture(canvasWidth: number, canvasHeight: number, offsetX: number, offsetY: number, rt?: RenderTexture2D): RenderTexture2D | Texture
    +drawToTexture3D(offx: number, offy: number, tex: Texture2D): void
    +customRender(context: Context, x: number, y: number): void
    +_applyFilters(): void
    +filters: any[]
    +filters: any[]
    +_setColorFilter(value: any): void
    +_isHaveGlowFilter(): boolean
    +localToGlobal(point: Point, createNewPoint?: boolean, globalNode?: Sprite): Point
    +globalToLocal(point: Point, createNewPoint?: boolean, globalNode?: Sprite): Point
    +toParentPoint(point: Point): Point
    +fromParentPoint(point: Point): Point
    +fromStagePoint(point: Point): Point
    +on(type: string, caller: any, listener: Function, args?: any[]): EventDispatcher
    +once(type: string, caller: any, listener: Function, args?: any[]): EventDispatcher
    #_onDisplay(v?: boolean): void
    #_setParent(value: Node): void
    +loadImage(url: string, complete?: Handler): Sprite
    +repaint(type?: number): void
    +_needRepaint(): boolean
    #_childChanged(child?: Node): void
    +parentRepaint(type?: number): void
    +stage: Stage
    +hitArea: any
    +hitArea: any
    +_setMask(value: Sprite): void
    +mask: Sprite
    +mask: Sprite
    +mouseEnabled: boolean
    +mouseEnabled: boolean
    +startDrag(area?: Rectangle, hasInertia?: boolean, elasticDistance?: number, elasticBackTime?: number, data?: any, disableMouseEvent?: boolean, ratio?: number): void
    +stopDrag(): void
    +_setDisplay(value: boolean): void
    +hitTestPoint(x: number, y: number): boolean
    +getMousePoint(): Point
    +globalScaleX: number
    +globalRotation: number
    +globalScaleY: number
    +mouseX: number
    +mouseY: number
    +zOrder: number
    +zOrder: number
    +texture: Texture
    +texture: Texture
    +_setTexture(value: string | Texture): void
    +viewport: Rectangle
    +viewport: Rectangle
    +_setRenderType(type: number): void
    +_setTranformChange(): void
    +_setBgStyleColor(x: number, y: number, width: number, height: number, fillColor: any): void
    +_setBorderStyleColor(x: number, y: number, width: number, height: number, fillColor: any, borderWidth: number): void
    +captureMouseEvent(exclusive: boolean): void
    +releaseMouseEvent(): void
    +drawCallOptimize: boolean
    +drawCallOptimize: boolean
    +{static} drawToCanvas(sprite: Sprite, _renderType: number, canvasWidth: number, canvasHeight: number, offsetX: number, offsetY: number): HTMLCanvas
    +{static} drawtocanvCtx: Context
    +{static} drawToTexture(sprite: Sprite, _renderType: number, canvasWidth: number, canvasHeight: number, offsetX: number, offsetY: number, rt?: RenderTexture2D): RenderTexture2D | Texture
    +{static} fromImage(url: string): Sprite
}
class Event {
    +type: string
    +nativeEvent: any
    +target: Sprite
    +currentTarget: Sprite
    +_stoped: boolean
    +touchId: number
    +keyCode: number
    +delta: number
    +setTo(type: string, currentTarget: Sprite, target: Sprite): Event
    +stopPropagation(): void
    +touches: any[]
    +altKey: boolean
    +ctrlKey: boolean
    +shiftKey: boolean
    +charCode: boolean
    +keyLocation: number
    +stageX: number
    +stageY: number
    +{static} EMPTY: Event
    +{static} MOUSE_DOWN: string
    +{static} MOUSE_UP: string
    +{static} CLICK: string
    +{static} RIGHT_MOUSE_DOWN: string
    +{static} RIGHT_MOUSE_UP: string
    +{static} RIGHT_CLICK: string
    +{static} MOUSE_MOVE: string
    +{static} MOUSE_OVER: string
    +{static} MOUSE_OUT: string
    +{static} MOUSE_WHEEL: string
    +{static} ROLL_OVER: string
    +{static} ROLL_OUT: string
    +{static} DOUBLE_CLICK: string
    +{static} CHANGE: string
    +{static} CHANGED: string
    +{static} RESIZE: string
    +{static} ADDED: string
    +{static} REMOVED: string
    +{static} DISPLAY: string
    +{static} UNDISPLAY: string
    +{static} ERROR: string
    +{static} COMPLETE: string
    +{static} LOADED: string
    +{static} READY: string
    +{static} PROGRESS: string
    +{static} INPUT: string
    +{static} RENDER: string
    +{static} OPEN: string
    +{static} MESSAGE: string
    +{static} CLOSE: string
    +{static} KEY_DOWN: string
    +{static} KEY_PRESS: string
    +{static} KEY_UP: string
    +{static} FRAME: string
    +{static} DRAG_START: string
    +{static} DRAG_MOVE: string
    +{static} DRAG_END: string
    +{static} ENTER: string
    +{static} SELECT: string
    +{static} BLUR: string
    +{static} FOCUS: string
    +{static} VISIBILITY_CHANGE: string
    +{static} FOCUS_CHANGE: string
    +{static} PLAYED: string
    +{static} PAUSED: string
    +{static} STOPPED: string
    +{static} START: string
    +{static} END: string
    +{static} COMPONENT_ADDED: string
    +{static} COMPONENT_REMOVED: string
    +{static} RELEASED: string
    +{static} LINK: string
    +{static} LABEL: string
    +{static} FULL_SCREEN_CHANGE: string
    +{static} DEVICE_LOST: string
    +{static} TRANSFORM_CHANGED: string
    +{static} ANIMATION_CHANGED: string
    +{static} TRAIL_FILTER_CHANGE: string
    +{static} TRIGGER_ENTER: string
    +{static} TRIGGER_STAY: string
    +{static} TRIGGER_EXIT: string
}
class Node extends EventDispatcher {
    -_bits: number
    +_children: any[]
    +_extUIChild: any[]
    +_parent: Node
    +name: string
    +destroyed: boolean
    +_conchData: any
    +createGLBuffer(): void
    +_setBit(type: number, value: boolean): void
    +_getBit(type: number): boolean
    +_setUpNoticeChain(): void
    +_setBitUp(type: number): void
    +on(type: string, caller: any, listener: Function, args?: any[]): EventDispatcher
    +once(type: string, caller: any, listener: Function, args?: any[]): EventDispatcher
    +destroy(destroyChild?: boolean): void
    +onDestroy(): void
    +destroyChildren(): void
    +addChild(node: Node): Node
    +addInputChild(node: Node): Node
    +removeInputChild(node: Node): void
    +addChildren(args: any[]): void
    +addChildAt(node: Node, index: number): Node
    +getChildIndex(node: Node): number
    +getChildByName(name: string): Node
    +getChildAt(index: number): Node
    +setChildIndex(node: Node, index: number): Node
    #_childChanged(child?: Node): void
    +removeChild(node: Node): Node
    +removeSelf(): Node
    +removeChildByName(name: string): Node
    +removeChildAt(index: number): Node
    +removeChildren(beginIndex?: number, endIndex?: number): Node
    +replaceChild(newNode: Node, oldNode: Node): Node
    +numChildren: number
    +parent: Node
    #_setParent(value: Node): void
    +displayedInStage: boolean
    -_updateDisplayedInstage(): void
    +_setDisplay(value: boolean): void
    -_displayChild(node: Node, display: boolean): void
    +contains(node: Node): boolean
    +timerLoop(delay: number, caller: any, method: Function, args?: any[], coverBefore?: boolean, jumpFrame?: boolean): void
    +timerOnce(delay: number, caller: any, method: Function, args?: any[], coverBefore?: boolean): void
    +frameLoop(delay: number, caller: any, method: Function, args?: any[], coverBefore?: boolean): void
    +frameOnce(delay: number, caller: any, method: Function, args?: any[], coverBefore?: boolean): void
    +clearTimer(caller: any, method: Function): void
    +callLater(method: Function, args?: any[]): void
    +runCallLater(method: Function): void
    -_components: any[]
    -_activeChangeScripts: any[]
    +_scene: Node
    +scene: any
    +active: boolean
    +active: boolean
    +activeInHierarchy: boolean
    #_onActive(): void
    #_onInActive(): void
    #_onActiveInScene(): void
    #_onInActiveInScene(): void
    +_parse(data: any, spriteMap: any): void
    +_setBelongScene(scene: Node): void
    +_setUnBelongScene(): void
    +onAwake(): void
    +onEnable(): void
    +_processActive(): void
    +_activeHierarchy(activeChangeScripts: any[]): void
    -_activeScripts(): void
    -_processInActive(): void
    +_inActiveHierarchy(activeChangeScripts: any[]): void
    -_inActiveScripts(): void
    +onDisable(): void
    #_onAdded(): void
    #_onRemoved(): void
    +_addComponentInstance(comp: Component): void
    +_destroyComponent(comp: Component): void
    +_destroyAllComponent(): void
    +_cloneTo(destObject: any, srcRoot: Node, dstRoot: Node): void
    +addComponentIntance(component: Component): any
    +addComponent(componentType: typeof Component): any
    +getComponent(componentType: typeof Component): any
    +getComponents(componentType: typeof Component): any[]
    +timer: Timer
    #{static} ARRAY_EMPTY: any[]
}
interface ISingletonElement {
    +_getIndexInList(): number
    +_setIndexInList(index: number): void
}
class Component implements ISingletonElement, IDestroy {
    -_indexInList: number
    +_destroyed: boolean
    +_id: number
    +_enabled: boolean
    +_awaked: boolean
    +owner: Node
    +id: number
    +enabled: boolean
    +enabled: boolean
    +isSingleton: boolean
    +destroyed: boolean
    +_isScript(): boolean
    -_resetComp(): void
    +_getIndexInList(): number
    +_setIndexInList(index: number): void
    +_onAdded(): void
    +_onAwake(): void
    +_onEnable(): void
    #_onDisable(): void
    #_onDestroy(): void
    +onReset(): void
    +_parse(data: any): void
    +_cloneTo(dest: Component): void
    +_setActive(value: boolean): void
    +destroy(): void
    +_destroy(): void
}
class Widget extends Component {
    -_top: number
    -_bottom: number
    -_left: number
    -_right: number
    -_centerX: number
    -_centerY: number
    +onReset(): void
    +_onEnable(): void
    #_onDisable(): void
    +_onAdded(): void
    #_onParentResize(): void
    +resetLayoutX(): boolean
    +resetLayoutY(): boolean
    +resetLayout(): void
    +top: number
    +top: number
    +bottom: number
    +bottom: number
    +left: number
    +left: number
    +right: number
    +right: number
    +centerX: number
    +centerX: number
    +centerY: number
    +centerY: number
    +{static} EMPTY: Widget
}
class GraphicAnimation extends FrameAnimation {
    +animationList: any[]
    +animationDic: any
    #_nodeList: any[]
    #_nodeDefaultProps: any
    #_gList: any[]
    #_nodeIDAniDic: any
    -_rootNode: any
    #_nodeGDic: any
    -_parseNodeList(uiView: any): void
    -_calGraphicData(aniData: any): void
    -_createGraphicData(): void
    #_createFrameGraphic(frame: number): any
    #_updateNodeGraphic(node: any, frame: number, parentTransfrom: Matrix, g: Graphics, alpha?: number): void
    #_updateNoChilds(tNodeG: GraphicNode, g: Graphics): void
    #_updateNodeGraphic2(node: any, frame: number, g: Graphics): void
    #_calculateKeyFrames(node: any): void
    #getNodeDataByID(nodeID: number): any
    #_getParams(obj: any, params: any[], frame: number, obj2: any): any[]
    -_getObjVar(obj: any, key: string, frame: number, noValue: any, obj2: any): any
    #_getNodeGraphicData(nodeID: number, frame: number, rst: GraphicNode): GraphicNode
    #_getTextureByUrl(url: string): any
    +setAniData(uiView: any, aniName?: string): void
    +parseByData(aniData: any): any
    +setUpAniData(uiView: any): void
    #_clear(): void
    #{static} _drawTextureCmd: any[]
    #{static} _temParam: any[]
    -{static} _I: GraphicAnimation
    -{static} _rootMatrix: Matrix
    -{static} _tempMt: Matrix
    +{static} parseAnimationByData(animationObject: any): any
    +{static} parseAnimationData(aniData: any): any
}
class GraphicNode {
    +skin: string
    +transform: Matrix
    +resultTransform: Matrix
    +width: number
    +height: number
    +alpha: number
}
class Animation extends AnimationBase {
    #_frames: any[]
    #_url: string
    +destroy(destroyChild?: boolean): void
    +play(start?: any, loop?: boolean, name?: string): void
    #_setFramesFromCache(name: string, showWarn?: boolean): boolean
    -_copyLabels(labels: any): any
    #_frameLoop(): void
    #_displayToIndex(value: number): void
    +frames: any[]
    +frames: any[]
    +source: string
    +autoAnimation: string
    +autoPlay: boolean
    +clear(): AnimationBase
    +loadImages(urls: any[], cacheName?: string): Animation
    +loadAtlas(url: string, loaded?: Handler, cacheName?: string): Animation
    +loadAnimation(url: string, loaded?: Handler, atlas?: string): Animation
    -_loadAnimationData(url: string, loaded?: Handler, atlas?: string): void
    +{static} framesMap: any
    +{static} createFrames(url: string | string[], name: string): any[]
    +{static} clearCache(key: string): void
}
class UIEvent extends Event {
    +{static} SHOW_TIP: string
    +{static} HIDE_TIP: string
}
class UIUtils {
    -{static} grayFilter: ColorFilter
    +{static} escapeSequence: any
    +{static} fillArray(arr: any[], str: string, type?: NumberConstructor | StringConstructor): any[]
    +{static} toColor(color: number): string
    +{static} gray(traget: Sprite, isGray?: boolean): void
    +{static} addFilter(target: Sprite, filter: IFilter): void
    +{static} clearFilter(target: Sprite, filterType: new () => any): void
    -{static} _getReplaceStr(word: string): string
    +{static} adptString(str: string): string
    -{static} _funMap: WeakObject
    +{static} getBindFun(value: string): Function
}
class UIComponent extends Sprite {
    #_anchorX: number
    #_anchorY: number
    #_dataSource: any
    #_toolTip: any
    #_tag: any
    #_disabled: boolean
    #_gray: boolean
    #_widget: Widget
    +destroy(destroyChild?: boolean): void
    #preinitialize(): void
    #createChildren(): void
    #initialize(): void
    +width: number
    +width: number
    +get_width(): number
    #measureWidth(): number
    #commitMeasure(): void
    +height: number
    +height: number
    +get_height(): number
    #measureHeight(): number
    +dataSource: any
    +dataSource: any
    +get_dataSource(): any
    +set_dataSource(value: any): void
    +top: number
    +top: number
    +get_top(): number
    +set_top(value: number): void
    +bottom: number
    +bottom: number
    +get_bottom(): number
    +set_bottom(value: number): void
    +left: number
    +left: number
    +right: number
    +right: number
    +centerX: number
    +centerX: number
    +centerY: number
    +centerY: number
    #_sizeChanged(): void
    +tag: any
    +tag: any
    +toolTip: any
    +toolTip: any
    -onMouseOver(e: Event): void
    -onMouseOut(e: Event): void
    +gray: boolean
    +gray: boolean
    +disabled: boolean
    +disabled: boolean
    -_getWidget(): Widget
    +scaleX: number
    +scaleX: number
    +set_scaleX(value: number): void
    +scaleY: number
    +scaleY: number
    +set_scaleY(value: number): void
    #onCompResize(): void
    +set_width(value: number): void
    +set_height(value: number): void
    +anchorX: number
    +anchorX: number
    +get_anchorX(): number
    +set_anchorX(value: number): void
    +anchorY: number
    +anchorY: number
    +get_anchorY(): number
    +set_anchorY(value: number): void
    #_childChanged(child?: Node): void
}
interface IBox
class Box extends UIComponent implements IBox {
    -_bgColor: string
    +dataSource: any
    +dataSource: any
    +bgColor: string
    +bgColor: string
    -_onResize(e: Event): void
}
interface ISelect {
    +selected: boolean
    +clickHandler: Handler
}
class Styles {
    +{static} defaultSizeGrid: any[]
    +{static} labelColor: string
    +{static} labelPadding: any[]
    +{static} inputLabelPadding: any[]
    +{static} buttonStateNum: number
    +{static} buttonLabelColors: any[]
    +{static} comboBoxItemColors: any[]
    +{static} scrollBarMinNum: number
    +{static} scrollBarDelayTime: number
}
class AutoBitmap extends Graphics {
    +autoCacheCmd: boolean
    -_width: number
    -_height: number
    -_source: Texture
    -_sizeGrid: number[]
    #_isChanged: boolean
    +_offset: any[]
    +uv: number[]
    +destroy(): void
    +sizeGrid: number[]
    +sizeGrid: number[]
    +width: number
    +width: number
    +height: number
    +height: number
    +source: Texture
    +source: Texture
    #_setChanged(): void
    #changeSource(): void
    -drawBitmap(repeat: boolean, tex: Texture, x: number, y: number, width?: number, height?: number): void
    -{static} getTexture(tex: Texture, x: number, y: number, width: number, height: number): Texture
}
class Button extends UIComponent implements ISelect {
    +toggle: boolean
    #_bitmap: AutoBitmap
    #_text: Text
    #_labelColors: any[]
    #_strokeColors: any[]
    #_state: number
    #_selected: boolean
    #_skin: string
    #_autoSize: boolean
    #_stateNum: number
    #_sources: any[]
    #_clickHandler: Handler
    #_stateChanged: boolean
    +destroy(destroyChild?: boolean): void
    #createChildren(): void
    #createText(): void
    #initialize(): void
    #onMouse(e: Event): void
    +skin: string
    +skin: string
    #_skinLoaded(): void
    +stateNum: number
    +stateNum: number
    #changeClips(): void
    #measureWidth(): number
    #measureHeight(): number
    +label: string
    +label: string
    +selected: boolean
    +selected: boolean
    #state: number
    #state: number
    #changeState(): void
    +labelColors: string
    +labelColors: string
    +strokeColors: string
    +strokeColors: string
    +labelPadding: string
    +labelPadding: string
    +labelSize: number
    +labelSize: number
    +labelStroke: number
    +labelStroke: number
    +labelStrokeColor: string
    +labelStrokeColor: string
    +labelBold: boolean
    +labelBold: boolean
    +labelFont: string
    +labelFont: string
    +labelAlign: string
    +labelAlign: string
    +clickHandler: Handler
    +clickHandler: Handler
    +text: Text
    +sizeGrid: string
    +sizeGrid: string
    +width: number
    +width: number
    +height: number
    +height: number
    +dataSource: any
    +dataSource: any
    +iconOffset: string
    +iconOffset: string
    #_setStateChanged(): void
    #{static} stateMap: any
}
class CheckBox extends Button {
    #preinitialize(): void
    #initialize(): void
    +dataSource: any
    +dataSource: any
}
class Image extends UIComponent {
    +_bitmap: AutoBitmap
    #_skin: string
    #_group: string
    +destroy(destroyChild?: boolean): void
    +dispose(): void
    #createChildren(): void
    +skin: string
    +skin: string
    +source: Texture
    +source: Texture
    +group: string
    +group: string
    #setSource(url: string, img?: any): void
    #measureWidth(): number
    #measureHeight(): number
    +width: number
    +width: number
    +height: number
    +height: number
    +sizeGrid: string
    +sizeGrid: string
    +dataSource: any
    +dataSource: any
}
class Label extends UIComponent {
    #_tf: Text
    +destroy(destroyChild?: boolean): void
    #createChildren(): void
    +text: string
    +text: string
    +changeText(text: string): void
    +wordWrap: boolean
    +wordWrap: boolean
    +color: string
    +color: string
    +font: string
    +font: string
    +align: string
    +align: string
    +valign: string
    +valign: string
    +bold: boolean
    +bold: boolean
    +italic: boolean
    +italic: boolean
    +leading: number
    +leading: number
    +fontSize: number
    +fontSize: number
    +padding: string
    +padding: string
    +bgColor: string
    +bgColor: string
    +borderColor: string
    +borderColor: string
    +stroke: number
    +stroke: number
    +strokeColor: string
    +strokeColor: string
    +textField: Text
    #measureWidth(): number
    #measureHeight(): number
    +width: number
    +width: number
    +height: number
    +height: number
    +dataSource: any
    +dataSource: any
    +overflow: string
    +overflow: string
    +underline: boolean
    +underline: boolean
    +underlineColor: string
    +underlineColor: string
}
class ProgressBar extends UIComponent {
    +changeHandler: Handler
    #_bg: Image
    #_bar: Image
    #_skin: string
    #_value: number
    +destroy(destroyChild?: boolean): void
    #createChildren(): void
    +skin: string
    +skin: string
    #_skinLoaded(): void
    #measureWidth(): number
    #measureHeight(): number
    +value: number
    +value: number
    #changeValue(): void
    +bar: Image
    +bg: Image
    +sizeGrid: string
    +sizeGrid: string
    +width: number
    +width: number
    +height: number
    +height: number
    +dataSource: any
    +dataSource: any
}
class Radio extends Button {
    #_value: any
    +destroy(destroyChild?: boolean): void
    #preinitialize(): void
    #initialize(): void
    #onClick(e: Event): void
    +value: any
    +value: any
}
interface IItem {
    +initItems(): void
}
class UIGroup extends Box implements IItem {
    +selectHandler: Handler
    #_items: ISelect[]
    #_selectedIndex: number
    #_skin: string
    #_direction: string
    #_space: number
    #_labels: string
    #_labelColors: string
    -_labelFont: string
    #_labelStrokeColor: string
    #_strokeColors: string
    #_labelStroke: number
    #_labelSize: number
    #_labelBold: boolean
    #_labelPadding: string
    #_labelAlign: string
    #_stateNum: number
    #_labelChanged: boolean
    #preinitialize(): void
    +destroy(destroyChild?: boolean): void
    +addItem(item: ISelect, autoLayOut?: boolean): number
    +delItem(item: ISelect, autoLayOut?: boolean): void
    +_afterInited(): void
    +initItems(): void
    #itemClick(index: number): void
    +selectedIndex: number
    +selectedIndex: number
    #setSelect(index: number, selected: boolean): void
    +skin: string
    +skin: string
    #_skinLoaded(): void
    +labels: string
    +labels: string
    #createItem(skin: string, label: string): Sprite
    +labelColors: string
    +labelColors: string
    +labelStroke: number
    +labelStroke: number
    +labelStrokeColor: string
    +labelStrokeColor: string
    +strokeColors: string
    +strokeColors: string
    +labelSize: number
    +labelSize: number
    +stateNum: number
    +stateNum: number
    +labelBold: boolean
    +labelBold: boolean
    +labelFont: string
    +labelFont: string
    +labelPadding: string
    +labelPadding: string
    +direction: string
    +direction: string
    +space: number
    +space: number
    #changeLabels(): void
    #commitMeasure(): void
    +items: ISelect[]
    +selection: ISelect
    +selection: ISelect
    +dataSource: any
    +dataSource: any
    #_setLabelChanged(): void
}
class RadioGroup extends UIGroup {
    #createItem(skin: string, label: string): Sprite
}
class Tab extends UIGroup {
    #createItem(skin: string, label: string): Sprite
}
class ViewStack extends Box implements IItem {
    #_items: any[]
    #_setIndexHandler: Handler
    #_selectedIndex: number
    +setItems(views: any[]): void
    +addItem(view: Node): void
    +_afterInited(): void
    +initItems(): void
    +selectedIndex: number
    +selectedIndex: number
    #setSelect(index: number, selected: boolean): void
    +selection: Node
    +selection: Node
    +setIndexHandler: Handler
    +setIndexHandler: Handler
    #setIndex(index: number): void
    +items: any[]
    +dataSource: any
    +dataSource: any
}
class TextInput extends Label {
    #_bg: AutoBitmap
    #_skin: string
    #preinitialize(): void
    +destroy(destroyChild?: boolean): void
    #createChildren(): void
    -_onFocus(): void
    -_onBlur(): void
    -_onInput(): void
    -_onEnter(): void
    #initialize(): void
    +bg: AutoBitmap
    +bg: AutoBitmap
    +skin: string
    +skin: string
    #_skinLoaded(): void
    +sizeGrid: string
    +sizeGrid: string
    +text: string
    +text: string
    +width: number
    +width: number
    +height: number
    +height: number
    +multiline: boolean
    +multiline: boolean
    +editable: boolean
    +editable: boolean
    +select(): void
    +restrict: string
    +restrict: string
    +prompt: string
    +prompt: string
    +promptColor: string
    +promptColor: string
    +maxChars: number
    +maxChars: number
    +focus: boolean
    +focus: boolean
    +type: string
    +type: string
    +setSelection(startIndex: number, endIndex: number): void
}
class Slider extends UIComponent {
    +changeHandler: Handler
    +isVertical: boolean
    +showLabel: boolean
    #_allowClickBack: boolean
    #_max: number
    #_min: number
    #_tick: number
    #_value: number
    #_skin: string
    #_bg: Image
    #_progress: Image
    #_bar: Button
    #_tx: number
    #_ty: number
    #_maxMove: number
    #_globalSacle: Point
    +destroy(destroyChild?: boolean): void
    #createChildren(): void
    #initialize(): void
    #onBarMouseDown(e: Event): void
    #showValueText(): void
    #hideValueText(): void
    -mouseUp(e: Event): void
    -mouseMove(e: Event): void
    #sendChangeEvent(type?: string): void
    +skin: string
    +skin: string
    #_skinLoaded(): void
    #setBarPoint(): void
    #measureWidth(): number
    #measureHeight(): number
    #_sizeChanged(): void
    +sizeGrid: string
    +sizeGrid: string
    +setSlider(min: number, max: number, value: number): void
    +tick: number
    +tick: number
    +changeValue(): void
    +max: number
    +max: number
    +min: number
    +min: number
    +value: number
    +value: number
    +allowClickBack: boolean
    +allowClickBack: boolean
    #onBgMouseDown(e: Event): void
    +dataSource: any
    +dataSource: any
    +bar: Button
    +{static} label: Label
}
class UIConfig {
    +{static} touchScrollEnable: boolean
    +{static} mouseWheelEnable: boolean
    +{static} showButtons: boolean
    +{static} popupBgColor: string
    +{static} popupBgAlpha: number
    +{static} closeDialogOnSide: boolean
}
class ScrollBar extends UIComponent {
    +rollRatio: number
    +changeHandler: Handler
    +scaleBar: boolean
    +autoHide: boolean
    +elasticDistance: number
    +elasticBackTime: number
    +upButton: Button
    +downButton: Button
    +slider: Slider
    #_showButtons: boolean
    #_scrollSize: number
    #_skin: string
    #_thumbPercent: number
    #_target: Sprite
    #_lastPoint: Point
    #_lastOffset: number
    #_checkElastic: boolean
    #_isElastic: boolean
    #_value: number
    #_hide: boolean
    #_clickOnly: boolean
    #_offsets: any[]
    #_touchScrollEnable: boolean
    #_mouseWheelEnable: boolean
    +destroy(destroyChild?: boolean): void
    #createChildren(): void
    #initialize(): void
    #onSliderChange(): void
    #onButtonMouseDown(e: Event): void
    #startLoop(isUp: boolean): void
    #slide(isUp: boolean): void
    #onStageMouseUp(e: Event): void
    +skin: string
    +skin: string
    #_skinLoaded(): void
    #changeScrollBar(): void
    #_sizeChanged(): void
    -resetPositions(): void
    #resetButtonPosition(): void
    #measureWidth(): number
    #measureHeight(): number
    +setScroll(min: number, max: number, value: number): void
    +max: number
    +max: number
    +min: number
    +min: number
    +value: number
    +value: number
    +isVertical: boolean
    +isVertical: boolean
    +sizeGrid: string
    +sizeGrid: string
    +scrollSize: number
    +scrollSize: number
    +dataSource: any
    +dataSource: any
    +thumbPercent: number
    +thumbPercent: number
    +target: Sprite
    +target: Sprite
    +hide: boolean
    +hide: boolean
    +showButtons: boolean
    +showButtons: boolean
    +touchScrollEnable: boolean
    +touchScrollEnable: boolean
    +mouseWheelEnable: boolean
    +mouseWheelEnable: boolean
    #onTargetMouseWheel(e: Event): void
    +isLockedFun: Function
    #onTargetMouseDown(e: Event): void
    +startDragForce(): void
    -cancelDragOp(): void
    +triggerDownDragLimit: Function
    +triggerUpDragLimit: Function
    -checkTriggers(isTweenMove?: boolean): boolean
    +lastOffset: number
    +startTweenMoveForce(lastOffset: number): void
    #loop(): void
    #onStageMouseUp2(e: Event): void
    -elasticOver(): void
    #tweenMove(maxDistance: number): void
    +stopScroll(): void
    +tick: number
    +tick: number
}
class VScrollBar extends ScrollBar
class HScrollBar extends ScrollBar {
    #initialize(): void
}
class TextArea extends TextInput {
    #_vScrollBar: VScrollBar
    #_hScrollBar: HScrollBar
    -_onTextChange(): void
    +destroy(destroyChild?: boolean): void
    #initialize(): void
    +width: number
    +width: number
    +height: number
    +height: number
    +vScrollBarSkin: string
    +vScrollBarSkin: string
    +hScrollBarSkin: string
    +hScrollBarSkin: string
    #onVBarChanged(e: Event): void
    #onHBarChanged(e: Event): void
    +vScrollBar: VScrollBar
    +hScrollBar: HScrollBar
    +maxScrollY: number
    +scrollY: number
    +maxScrollX: number
    +scrollX: number
    -changeScroll(): void
    +scrollTo(y: number): void
}
class ColorPicker extends UIComponent {
    +changeHandler: Handler
    #_gridSize: number
    #_bgColor: string
    #_borderColor: string
    #_inputColor: string
    #_inputBgColor: string
    #_colorPanel: Box
    #_colorTiles: Sprite
    #_colorBlock: Sprite
    #_colorInput: Input
    #_colorButton: Button
    #_colors: any[]
    #_selectedColor: string
    #_panelChanged: boolean
    +destroy(destroyChild?: boolean): void
    #createChildren(): void
    #initialize(): void
    -onPanelMouseDown(e: Event): void
    #changePanel(): void
    -onColorButtonClick(e: Event): void
    +open(): void
    +close(): void
    -removeColorBox(e?: Event): void
    -onColorFieldKeyDown(e: Event): void
    -onColorInputChange(e?: Event): void
    -onColorTilesClick(e: Event): void
    -onColorTilesMouseMove(e: Event): void
    #getColorByMouse(): string
    -drawBlock(color: string): void
    +selectedColor: string
    +selectedColor: string
    +skin: string
    +skin: string
    -changeColor(): void
    +bgColor: string
    +bgColor: string
    +borderColor: string
    +borderColor: string
    +inputColor: string
    +inputColor: string
    +inputBgColor: string
    +inputBgColor: string
    #_setPanelChanged(): void
}
class ScaleBox extends Box {
    -_oldW: number
    -_oldH: number
    +onEnable(): void
    +onDisable(): void
    -onResize(): void
    +width: number
    +width: number
    +height: number
    +height: number
}
class Clip extends UIComponent {
    #_sources: any[]
    #_bitmap: AutoBitmap
    #_skin: string
    #_clipX: number
    #_clipY: number
    #_clipWidth: number
    #_clipHeight: number
    #_autoPlay: boolean
    #_interval: number
    #_complete: Handler
    #_isPlaying: boolean
    #_index: number
    #_clipChanged: boolean
    #_group: string
    #_toIndex: number
    +destroy(destroyChild?: boolean): void
    +dispose(): void
    #createChildren(): void
    #_onDisplay(e?: boolean): void
    +skin: string
    +skin: string
    #_skinLoaded(): void
    +clipX: number
    +clipX: number
    +clipY: number
    +clipY: number
    +clipWidth: number
    +clipWidth: number
    +clipHeight: number
    +clipHeight: number
    #changeClip(): void
    #loadComplete(url: string, img: Texture): void
    +sources: any[]
    +sources: any[]
    +group: string
    +group: string
    +width: number
    +width: number
    +height: number
    +height: number
    #measureWidth(): number
    #measureHeight(): number
    +sizeGrid: string
    +sizeGrid: string
    +index: number
    +index: number
    +total: number
    +autoPlay: boolean
    +autoPlay: boolean
    +interval: number
    +interval: number
    +isPlaying: boolean
    +isPlaying: boolean
    +play(from?: number, to?: number): void
    #_loop(): void
    +stop(): void
    +dataSource: any
    +dataSource: any
    +bitmap: AutoBitmap
    #_setClipChanged(): void
}
interface IRender {
    +itemRender: any
}
class List extends Box implements IRender, IItem {
    +selectHandler: Handler
    +renderHandler: Handler
    +mouseHandler: Handler
    +selectEnable: boolean
    +totalPage: number
    +_$componentType: string
    #_content: Box
    #_scrollBar: ScrollBar
    #_itemRender: any
    #_repeatX: number
    #_repeatY: number
    #_repeatX2: number
    #_repeatY2: number
    #_spaceX: number
    #_spaceY: number
    #_cells: Box[]
    #_array: any[]
    #_startIndex: number
    #_selectedIndex: number
    #_page: number
    #_isVertical: boolean
    #_cellSize: number
    #_cellOffset: number
    #_isMoved: boolean
    +cacheContent: boolean
    #_createdLine: number
    #_cellChanged: boolean
    #_offset: Point
    #_usedCache: string
    #_elasticEnabled: boolean
    +destroy(destroyChild?: boolean): void
    #createChildren(): void
    +cacheAs: string
    +cacheAs: string
    -onScrollStart(): void
    -onScrollEnd(): void
    +content: Box
    +vScrollBarSkin: string
    +vScrollBarSkin: string
    -_removePreScrollBar(): void
    +hScrollBarSkin: string
    +hScrollBarSkin: string
    +scrollBar: ScrollBar
    +scrollBar: ScrollBar
    +itemRender: any
    +itemRender: any
    +width: number
    +width: number
    +height: number
    +height: number
    +repeatX: number
    +repeatX: number
    +repeatY: number
    +repeatY: number
    +spaceX: number
    +spaceX: number
    +spaceY: number
    +spaceY: number
    #changeCells(): void
    -_getOneCell(): Box
    -_createItems(startY: number, numX: number, numY: number): void
    #createItem(): Box
    #addCell(cell: Box): void
    +_afterInited(): void
    +initItems(): void
    +setContentSize(width: number, height: number): void
    #onCellMouse(e: Event): void
    #changeCellState(cell: Box, visible: boolean, index: number): void
    #_sizeChanged(): void
    #onScrollBarChange(e?: Event): void
    -posCell(cell: Box, cellIndex: number): void
    +selectedIndex: number
    +selectedIndex: number
    #changeSelectStatus(): void
    +selectedItem: any
    +selectedItem: any
    +selection: Box
    +selection: Box
    +startIndex: number
    +startIndex: number
    #renderItems(from?: number, to?: number): void
    #renderItem(cell: Box, index: number): void
    -_bindData(cell: any, data: any): void
    +array: any[]
    +array: any[]
    -_preLen: number
    +updateArray(array: any[]): void
    +page: number
    +page: number
    +length: number
    +dataSource: any
    +dataSource: any
    +cells: Box[]
    +elasticEnabled: boolean
    +elasticEnabled: boolean
    +refresh(): void
    +getItem(index: number): any
    +changeItem(index: number, source: any): void
    +setItem(index: number, source: any): void
    +addItem(souce: any): void
    +addItemAt(souce: any, index: number): void
    +deleteItem(index: number): void
    +getCell(index: number): Box
    +scrollTo(index: number): void
    +tweenTo(index: number, time?: number, complete?: Handler): void
    #_setCellChanged(): void
    #commitMeasure(): void
}
class ComboBox extends UIComponent {
    #_visibleNum: number
    #_button: Button
    #_list: List
    #_isOpen: boolean
    #_itemColors: any[]
    #_itemSize: number
    #_labels: any[]
    #_selectedIndex: number
    #_selectHandler: Handler
    #_itemHeight: number
    #_listHeight: number
    #_listChanged: boolean
    #_itemChanged: boolean
    #_scrollBarSkin: string
    #_isCustomList: boolean
    +itemRender: any
    +destroy(destroyChild?: boolean): void
    #createChildren(): void
    -_createList(): void
    -_setListEvent(list: List): void
    -onListDown(e: Event): void
    -onScrollBarDown(e: Event): void
    -onButtonMouseDown(e: Event): void
    +skin: string
    +skin: string
    #measureWidth(): number
    #measureHeight(): number
    #changeList(): void
    #onlistItemMouse(e: Event, index: number): void
    -switchTo(value: boolean): void
    #changeOpen(): void
    +width: number
    +width: number
    +height: number
    +height: number
    +labels: string
    +labels: string
    #changeItem(): void
    +selectedIndex: number
    +selectedIndex: number
    -changeSelected(): void
    +selectHandler: Handler
    +selectHandler: Handler
    +selectedLabel: string
    +selectedLabel: string
    +visibleNum: number
    +visibleNum: number
    +itemColors: string
    +itemColors: string
    +itemSize: number
    +itemSize: number
    +isOpen: boolean
    +isOpen: boolean
    -_onStageMouseWheel(e: Event): void
    #removeList(e: Event): void
    +scrollBarSkin: string
    +scrollBarSkin: string
    +sizeGrid: string
    +sizeGrid: string
    +scrollBar: VScrollBar
    +button: Button
    +list: List
    +list: List
    +dataSource: any
    +dataSource: any
    +labelColors: string
    +labelColors: string
    +labelPadding: string
    +labelPadding: string
    +labelSize: number
    +labelSize: number
    +labelBold: boolean
    +labelBold: boolean
    +labelFont: string
    +labelFont: string
    +stateNum: number
    +stateNum: number
}
class HSlider extends Slider
class Panel extends Box {
    #_content: Box
    #_vScrollBar: VScrollBar
    #_hScrollBar: HScrollBar
    #_scrollChanged: boolean
    #_usedCache: string
    #_elasticEnabled: boolean
    +destroy(destroyChild?: boolean): void
    +destroyChildren(): void
    #createChildren(): void
    +addChild(child: Node): Node
    -onResize(): void
    +addChildAt(child: Node, index: number): Node
    +removeChild(child: Node): Node
    +removeChildAt(index: number): Node
    +removeChildren(beginIndex?: number, endIndex?: number): Node
    +getChildAt(index: number): Node
    +getChildByName(name: string): Node
    +getChildIndex(child: Node): number
    +numChildren: number
    -changeScroll(): void
    #_sizeChanged(): void
    +contentWidth: number
    +contentHeight: number
    -setContentSize(width: number, height: number): void
    +width: number
    +width: number
    +height: number
    +height: number
    +vScrollBarSkin: string
    +vScrollBarSkin: string
    +hScrollBarSkin: string
    +hScrollBarSkin: string
    +vScrollBar: ScrollBar
    +hScrollBar: ScrollBar
    +content: Sprite
    #onScrollBarChange(scrollBar: ScrollBar): void
    +scrollTo(x?: number, y?: number): void
    +refresh(): void
    +cacheAs: string
    +cacheAs: string
    +elasticEnabled: boolean
    +elasticEnabled: boolean
    -onScrollStart(): void
    -onScrollEnd(): void
    #_setScrollChanged(): void
}
class VSlider extends Slider
class Tree extends Box implements IRender {
    #_list: List
    #_source: any[]
    #_renderHandler: Handler
    #_spaceLeft: number
    #_spaceBottom: number
    #_keepStatus: boolean
    +destroy(destroyChild?: boolean): void
    #createChildren(): void
    #onListChange(e?: Event): void
    +keepStatus: boolean
    +keepStatus: boolean
    +array: any[]
    +array: any[]
    +source: any[]
    +list: List
    +itemRender: any
    +itemRender: any
    +scrollBarSkin: string
    +scrollBarSkin: string
    +scrollBar: ScrollBar
    +mouseHandler: Handler
    +mouseHandler: Handler
    +renderHandler: Handler
    +renderHandler: Handler
    +spaceLeft: number
    +spaceLeft: number
    +spaceBottom: number
    +spaceBottom: number
    +selectedIndex: number
    +selectedIndex: number
    +selectedItem: any
    +selectedItem: any
    +width: number
    +width: number
    +height: number
    +height: number
    #getArray(): any[]
    #getDepth(item: any, num?: number): number
    #getParentOpenStatus(item: any): boolean
    #renderItem(cell: Box, index: number): void
    -onArrowClick(e: Event): void
    +setItemState(index: number, isOpen: boolean): void
    +fresh(): void
    +dataSource: any
    +dataSource: any
    +xml: XMLDocument
    #parseXml(xml: ChildNode, source: any[], nodeParent: any, isRoot: boolean): void
    #parseOpenStatus(oldSource: any[], newSource: any[]): void
    #isSameParent(item1: any, item2: any): boolean
    +selectedPath: string
    +filter(key: string): void
    -getFilterSource(array: any[], result: any[], key: string): void
}
class LayoutBox extends Box {
    #_space: number
    #_align: string
    #_itemChanged: boolean
    +addChild(child: Node): Node
    -onResize(e: Event): void
    +addChildAt(child: Node, index: number): Node
    +removeChildAt(index: number): Node
    +refresh(): void
    #changeItems(): void
    +space: number
    +space: number
    +align: string
    +align: string
    #sortItem(items: any[]): void
    #_setItemChanged(): void
}
class HBox extends LayoutBox {
    #sortItem(items: any[]): void
    +height: number
    +height: number
    #changeItems(): void
    +{static} NONE: string
    +{static} TOP: string
    +{static} MIDDLE: string
    +{static} BOTTOM: string
}
class VBox extends LayoutBox {
    +width: number
    +width: number
    #changeItems(): void
    +{static} NONE: string
    +{static} LEFT: string
    +{static} CENTER: string
    +{static} RIGHT: string
}
class FontClip extends Clip {
    #_valueArr: string
    #_indexMap: any
    #_sheet: string
    #_direction: string
    #_spaceX: number
    #_spaceY: number
    -_align: string
    -_wordsW: number
    -_wordsH: number
    #createChildren(): void
    -_onClipLoaded(): void
    +sheet: string
    +sheet: string
    +value: string
    +value: string
    +direction: string
    +direction: string
    +spaceX: number
    +spaceX: number
    +spaceY: number
    +spaceY: number
    +align: string
    +align: string
    #changeValue(): void
    +width: number
    +width: number
    +height: number
    +height: number
    #measureWidth(): number
    #measureHeight(): number
    +destroy(destroyChild?: boolean): void
}
class View extends Scene {
    +_watchMap: any
    #_widget: Widget
    #_dataSource: any
    #_anchorX: number
    #_anchorY: number
    +destroy(destroyChild?: boolean): void
    +changeData(key: string): void
    +top: number
    +top: number
    +bottom: number
    +bottom: number
    +left: number
    +left: number
    +right: number
    +right: number
    +centerX: number
    +centerX: number
    +centerY: number
    +centerY: number
    +anchorX: number
    +anchorX: number
    +anchorY: number
    +anchorY: number
    #_sizeChanged(): void
    -_getWidget(): Widget
    #loadUI(path: string): void
    +dataSource: any
    +dataSource: any
    +{static} uiMap: any
    +{static} __init__(): void
    +{static} regComponent(key: string, compClass: new () => any): void
    +{static} regViewRuntime(key: string, compClass: new () => any): void
    +{static} regUI(url: string, json: any): void
}
class IUI {
    +{static} Dialog: typeof Dialog
}
class DialogManager extends Sprite {
    +maskLayer: Sprite
    +lockLayer: Sprite
    +popupEffect: (dialog: Dialog) => void
    +closeEffect: (dialog: Dialog) => void
    +popupEffectHandler: Handler
    +closeEffectHandler: Handler
    -_closeOnSide(): void
    +setLockView(value: UIComponent): void
    -_onResize(e?: Event): void
    -_centerDialog(dialog: Dialog): void
    +open(dialog: Dialog, closeOther?: boolean, showEffect?: boolean): void
    -_clearDialogEffect(dialog: Dialog): void
    +doOpen(dialog: Dialog): void
    +lock(value: boolean): void
    +close(dialog: Dialog): void
    +doClose(dialog: Dialog): void
    +closeAll(): void
    -_closeAll(): void
    +getDialogsByGroup(group: string): any[]
    +closeByGroup(group: string): any[]
    +_checkMask(): void
}
class Dialog extends View {
    +closeHandler: Handler
    +popupEffect: Handler
    +closeEffect: Handler
    +group: string
    +isModal: boolean
    +isShowEffect: boolean
    +isPopupCenter: boolean
    +closeType: string
    -_dragArea: Rectangle
    +_param: any
    +_effectTween: Tween
    #_dealDragArea(): void
    +dragArea: string
    +dragArea: string
    -_onMouseDown(e: Event): void
    #_onClick(e: Event): void
    +open(closeOther?: boolean, param?: any): void
    +close(type?: string): void
    +destroy(destroyChild?: boolean): void
    +show(closeOther?: boolean, showEffect?: boolean): void
    +popup(closeOther?: boolean, showEffect?: boolean): void
    #_open(modal: boolean, closeOther: boolean, showEffect: boolean): void
    +isPopup: boolean
    +zOrder: number
    +zOrder: number
    +{static} CLOSE: string
    +{static} CANCEL: string
    +{static} SURE: string
    +{static} NO: string
    +{static} YES: string
    +{static} OK: string
    -{static} _manager: DialogManager
    +{static} manager: DialogManager
    +{static} manager: DialogManager
    +{static} setLockView(view: UIComponent): void
    +{static} lock(value: boolean): void
    +{static} closeAll(): void
    +{static} getDialogsByGroup(group: string): any[]
    +{static} closeByGroup(group: string): any[]
}
interface HonorDialog extends Dialog {
    +HonorEffectTween?: Tween
    +config?: HonorDialogConfig
    +onMounted(params: any[]): void
    +onResize(width?: number, height?: number): void
}
interface HonorScene extends Scene {
    +onResize(width: number, height: number): void
    +onMounted(param: any[]): void
}
interface HonorLoadScene extends HonorScene {
    +onHide(): void
    +onShow(): void
    +onProgress(val: number): void
}
class DialogManagerCtor {
    -wait_dialog_task: WaitOpenDialogMap
    -open_dialog_list: DialogInfo[]
    -dialog_pool_list: DialogInfo[]
    -dialog_manager: DialogManager
    +openDialog(url: any, params?: any[], config?: HonorDialogConfig, use_exist?: boolean, show_effect?: boolean): Promise<HonorDialog>
    +toOpenDialog(url: any): Promise<HonorDialog>
    -setDialogConfig(url: any, dialog: HonorDialog, config?: HonorDialogConfig): HonorDialogConfig
    -getDialogConfig(dialog: HonorDialog): HonorDialogConfig
    -injectDoCloseAfter(dialog_manager: DialogManager, result: any, dialog: HonorDialog): void
    -injectDoOpenAfter(dialog_manager: DialogManager, result: any, dialog: HonorDialog): void
    -checkMask(): void
    +closeAllDialogs(): void
    +getDialogsByGroup(group: string): void
    +closeDialogsByGroup(group: string): void
    +getDialogByName(name: string): HonorDialog
    +closeDialogByName(name: string): void
    +hideMask(visible: boolean): void
}
class SceneManagerCtor {
    +sceneChangeBeforeListener: SceneChangeListener[]
    +sceneChangeAfterListener: SceneChangeListener[]
    +sceneClassMap: SceneClassMap
    +scene_pool: SceneMap
    -cur_scene: HonorScene
    +onResize(width: number, height: number): void
    +getCurScene(): HonorScene
    +switchScene(params: any[], scene: HonorScene): SceneChangeData
    -callChangeListener(type: "after" | "before", params: [any, any]): boolean
    +runScene(url: any, params: any[]): Promise<Scene>
}
class LoaderManagerCtor {
    +force: boolean
    -load_map: LoadingMap
    +loadScene(type: ViewType, url: string): Promise<unknown>
    +load(res: string[] | ResItem[], type?: ViewType): Promise<unknown>
    +toggleLoading(type: ViewType, status: boolean): void
    +setLoadView(type: ViewType, url: string): Promise<void>
    +setLoadViewVisible(type: ViewType, visible: boolean, force?: boolean): void
    +setLoadProgress(type: ViewType, val: number): void
}
class DirectorCtor {
    +init(): void
    -onResize(): void
    +runScene(url: any, params: any[]): Promise<void | Scene>
    +runningScene: HonorScene
    +openDialog(url: any, params?: any[], config?: HonorDialogConfig, use_exist?: boolean, show_effect?: boolean): Promise<HonorDialog>
    +load(res: string[] | ResItem[], type?: ViewType): Promise<unknown>
    +getDialogByName(name: string): HonorDialog
    +getDialogsByGroup(group: string): void
    +closeDialogByName(name: string): void
    +closeDialogsByGroup(group: string): void
    +closeAllDialogs(): void
    +setLoadViewVisible(type: ViewType, visible: boolean, force?: boolean): void
    +setLoadPageForScene(url: string): Promise<void>
    +setLoadPageForDialog(url: string): Promise<void>
    +clearDialog(fn: SceneChangeListener): Promise<void>
    +onSceneChangeBefore(fn: SceneChangeListener): Promise<void>
    +onSceneChangeAfter(fn: SceneChangeListener): Promise<void>
    +clearListener(fn: SceneChangeListener): Promise<void>
    +hideDialog(visible: boolean): void
}
class Transform {
    +skX: number
    +skY: number
    +scX: number
    +scY: number
    +x: number
    +y: number
    +skewX: number
    +skewY: number
    -mMatrix: Matrix
    +initData(data: any): void
    +getMatrix(): Matrix
    +skew(m: Matrix, x: number, y: number): Matrix
}
class Bone {
    +name: string
    +root: Bone
    +parentBone: Bone
    +length: number
    +transform: Transform
    +resultTransform: Transform
    +resultMatrix: Matrix
    +inheritScale: boolean
    +inheritRotation: boolean
    +rotation: number
    +resultRotation: number
    +d: number
    -_tempMatrix: Matrix
    -_children: Bone[]
    -_sprite: Sprite
    +setTempMatrix(matrix: Matrix): void
    +update(pMatrix?: Matrix): void
    +updateChild(): void
    +setRotation(rd: number): void
    +updateDraw(x: number, y: number): void
    +addChild(bone: Bone): void
    +findBone(boneName: string): Bone
    +localToWorld(local: number[]): void
    +{static} ShowBones: any
}
class TfConstraintData {
    +name: string
    +boneIndexs: number[]
    +targetIndex: number
    +rotateMix: number
    +translateMix: number
    +scaleMix: number
    +shearMix: number
    +offsetRotation: number
    +offsetX: number
    +offsetY: number
    +offsetScaleX: number
    +offsetScaleY: number
    +offsetShearY: number
}
class PathConstraintData {
    +name: string
    +bones: number[]
    +target: string
    +positionMode: string
    +spacingMode: string
    +rotateMode: string
    +offsetRotation: number
    +position: number
    +spacing: number
    +rotateMix: number
    +translateMix: number
}
class SkinSlotDisplayData {
    +name: string
    +attachmentName: string
    +type: number
    +transform: Transform
    +width: number
    +height: number
    +texture: Texture
    +bones: any[]
    +uvs: any[]
    +weights: any[]
    +triangles: any[]
    +vertices: any[]
    +lengths: any[]
    +verLen: number
    +createTexture(currTexture: Texture): Texture
    +destory(): void
}
class SlotData {
    +name: string
    +displayArr: any[]
    +getDisplayByName(name: string): number
}
class UVTools {
    +{static} getRelativeUV(bigUV: ArrayLike<number>, smallUV: any[], rst?: any[]): any[]
    +{static} getAbsoluteUV(bigUV: ArrayLike<number>, smallUV: any[], rst?: any[]): any[]
}
class MeshData {
    +texture: Texture
    +uvs: Float32Array
    +vertices: Float32Array
    +indexes: Uint16Array
    +uvTransform: Matrix
    +useUvTransform: boolean
    +canvasPadding: number
    +getBounds(): Rectangle
}
class SkinMeshForGraphic extends MeshData {
    +transform: Matrix
    +init2(texture: Texture, ps: any[], verticles: any[], uvs: any[]): void
}
class GraphicsAni extends Graphics {
    +drawSkin(skinA: SkinMeshForGraphic, alpha: number): void
    -{static} _caches: any[]
    +{static} create(): GraphicsAni
    +{static} recycle(graphics: GraphicsAni): void
}
class BoneSlot {
    +name: string
    +parent: string
    +attachmentName: string
    +srcDisplayIndex: number
    +type: string
    +templet: Templet
    +currSlotData: SlotData
    +currTexture: Texture
    +currDisplayData: SkinSlotDisplayData
    +displayIndex: number
    +originalIndex: number
    -_diyTexture: Texture
    -_parentMatrix: Matrix
    -_resultMatrix: Matrix
    -_replaceDic: any
    -_curDiyUV: any[]
    -_skinSprite: any
    +deformData: any[]
    +showSlotData(slotData: SlotData, freshIndex?: boolean): void
    +showDisplayByName(name: string): void
    +replaceDisplayByName(tarName: string, newName: string): void
    +replaceDisplayByIndex(tarIndex: number, newIndex: number): void
    +showDisplayByIndex(index: number): void
    +replaceSkin(_texture: Texture): void
    +setParentMatrix(parentMatrix: Matrix): void
    -_mVerticleArr: any[]
    -_preGraphicVerticle: any[]
    -getSaveVerticle(tArr: any[]): any[]
    -_preGraphicMatrix: Matrix
    -getSaveMatrix(tResultMatrix: Matrix): Matrix
    +draw(graphics: GraphicsAni, boneMatrixArray: any[], noUseSave?: boolean, alpha?: number): void
    -skinMesh(boneMatrixArray: any[], skinSprite: any): void
    +drawBonePoint(graphics: Graphics): void
    -getDisplayMatrix(): Matrix
    +getMatrix(): Matrix
    +copy(): BoneSlot
    -{static} _tempMatrix: Matrix
    +{static} createSkinMesh(): any
    -{static} isSameArr(arrA: any[], arrB: any[]): boolean
    -{static} _tempResultMatrix: Matrix
    +{static} isSameMatrix(mtA: Matrix, mtB: Matrix): boolean
    -{static} useSameMatrixAndVerticle: boolean
    -{static} _tempVerticleArr: any[]
}
class DeformSlotDisplayData {
    +boneSlot: BoneSlot
    +slotIndex: number
    +attachment: string
    +timeList: number[]
    +vectices: any[][]
    +tweenKeyList: boolean[]
    +deformData: any[]
    +frameIndex: number
    -binarySearch1(values: number[], target: number): number
    +apply(time: number, boneSlot: BoneSlot, alpha?: number): void
}
class DeformSlotData {
    +deformSlotDisplayList: DeformSlotDisplayData[]
}
class DeformAniData {
    +skinName: string
    +deformSlotDataList: DeformSlotData[]
}
class DrawOrderData {
    +time: number
    +drawOrder: number[]
}
class EventData {
    +name: string
    +intValue: number
    +floatValue: number
    +stringValue: string
    +audioValue: string
    +time: number
}
class KeyFramesContent {
    +startTime: number
    +duration: number
    +interpolationData: any[]
    +data: Float32Array
    +dData: Float32Array
    +nextData: Float32Array
}
class AnimationNodeContent {
    +name: string
    +parentIndex: number
    +parent: AnimationNodeContent
    +keyframeWidth: number
    +lerpType: number
    +interpolationMethod: any[]
    +childs: any[]
    +keyFrame: KeyFramesContent[]
    +playTime: number
    +extenData: ArrayBuffer
    +dataOffset: number
}
class AnimationContent {
    +nodes: AnimationNodeContent[]
    +name: string
    +playTime: number
    +bone3DMap: any
    +totalKeyframeDatasLength: number
}
class IkConstraintData {
    +name: string
    +targetBoneName: string
    +boneNames: string[]
    +bendDirection: number
    +mix: number
    +isSpine: boolean
    +targetBoneIndex: number
    +boneIndexs: number[]
}
class IkConstraint {
    -_targetBone: Bone
    -_bones: Bone[]
    +name: string
    +mix: number
    +bendDirection: number
    +isSpine: boolean
    +apply(): void
    -_applyIk1(bone: Bone, targetX: number, targetY: number, alpha: number): void
    -_sp: Sprite
    -isDebug: boolean
    +updatePos(x: number, y: number): void
    -_applyIk2(parent: Bone, child: Bone, targetX: number, targetY: number, bendDir: number, alpha: number): void
    -_applyIk3(parent: Bone, child: Bone, targetX: number, targetY: number, bendDir: number, alpha: number): void
    +{static} radDeg: number
    +{static} degRad: number
    -{static} _tempMatrix: Matrix
}
class PathConstraint {
    +target: BoneSlot
    +data: PathConstraintData
    +bones: Bone[]
    +position: number
    +spacing: number
    +rotateMix: number
    +translateMix: number
    -_debugKey: boolean
    -_segments: number[]
    -_curves: number[]
    -_spaces: number[]
    +apply(boneList: Bone[], graphics: Graphics): void
    +computeWorldVertices2(boneSlot: BoneSlot, boneList: Bone[], start: number, count: number, worldVertices: number[], offset: number): void
    -computeWorldPositions(boneSlot: BoneSlot, boneList: Bone[], graphics: Graphics, spacesCount: number, tangents: boolean, percentPosition: boolean, percentSpacing: boolean): number[]
    -addBeforePosition(p: number, temp: number[], i: number, out: number[], o: number): void
    -addAfterPosition(p: number, temp: number[], i: number, out: number[], o: number): void
    -addCurvePosition(p: number, x1: number, y1: number, cx1: number, cy1: number, cx2: number, cy2: number, x2: number, y2: number, out: number[], o: number, tangents: boolean): void
    -{static} BEFORE: number
    -{static} AFTER: number
    -{static} _tempMt: Matrix
}
class TfConstraint {
    -_data: TfConstraintData
    -_bones: Bone[]
    +target: Bone
    +rotateMix: number
    +translateMix: number
    +scaleMix: number
    +shearMix: number
    -_temp: number[]
    +apply(): void
}
class SkinData {
    +name: string
    +slotArr: any[]
}
class AnimationState {
    +{static} stopped: number
    +{static} paused: number
    +{static} playing: number
}
class AnimationPlayer extends EventDispatcher implements IDestroy {
    -_destroyed: boolean
    -_templet: AnimationTemplet
    -_currentTime: number
    -_currentFrameTime: number
    -_playStart: number
    -_playEnd: number
    -_playDuration: number
    -_overallDuration: number
    -_stopWhenCircleFinish: boolean
    +_elapsedPlaybackTime: number
    -_startUpdateLoopCount: number
    -_currentAnimationClipIndex: number
    -_currentKeyframeIndex: number
    -_paused: boolean
    -_cacheFrameRate: number
    -_cacheFrameRateInterval: number
    -_cachePlayRate: number
    +isCache: boolean
    +playbackRate: number
    +returnToZeroStopped: boolean
    +templet: AnimationTemplet
    +templet: AnimationTemplet
    +playStart: number
    +playEnd: number
    +playDuration: number
    +overallDuration: number
    +currentAnimationClipIndex: number
    +currentKeyframeIndex: number
    +currentPlayTime: number
    +currentFrameTime: number
    +cachePlayRate: number
    +cachePlayRate: number
    +cacheFrameRate: number
    +cacheFrameRate: number
    +currentTime: number
    +paused: boolean
    +paused: boolean
    +cacheFrameRateInterval: number
    +state: number
    +destroyed: boolean
    +_onTempletLoadedComputeFullKeyframeIndices(cachePlayRate: number, cacheFrameRate: number, templet: AnimationTemplet): void
    -_computeFullKeyframeIndices(): void
    -_onAnimationTempletLoaded(): void
    -_calculatePlayDuration(): void
    -_setPlayParams(time: number, cacheFrameInterval: number): void
    -_setPlayParamsWhenStop(currentAniClipPlayDuration: number, cacheFrameInterval: number, playEnd?: number): void
    +_update(elapsedTime: number): void
    +_destroy(): void
    +play(index?: number, playbackRate?: number, overallDuration?: number, playStart?: number, playEnd?: number): void
    +playByFrame(index?: number, playbackRate?: number, overallDuration?: number, playStartFrame?: number, playEndFrame?: number, fpsIn3DBuilder?: number): void
    +stop(immediate?: boolean): void
    +destroy(): void
}
class Skeleton extends Sprite {
    #_templet: Templet
    #_player: AnimationPlayer
    #_curOriginalData: Float32Array
    -_boneMatrixArray: any[]
    -_lastTime: number
    -_currAniIndex: number
    -_pause: boolean
    #_aniClipIndex: number
    #_clipIndex: number
    -_skinIndex: number
    -_skinName: string
    -_aniMode: number
    -_graphicsCache: any[]
    -_boneSlotDic: any
    -_bindBoneBoneSlotDic: any
    -_boneSlotArray: any[]
    -_index: number
    -_total: number
    -_indexControl: boolean
    -_aniPath: string
    -_complete: Handler
    -_loadAniMode: number
    -_yReverseMatrix: Matrix
    -_ikArr: any[]
    -_tfArr: any[]
    -_pathDic: any
    -_rootBone: Bone
    #_boneList: Bone[]
    #_aniSectionDic: any
    -_eventIndex: number
    -_drawOrderIndex: number
    -_drawOrder: number[]
    -_lastAniClipIndex: number
    -_lastUpdateAniClipIndex: number
    -_playAudio: boolean
    -_soundChannelArr: any[]
    +init(templet: Templet, aniMode?: number): void
    +url: string
    +url: string
    +load(path: string, complete?: Handler, aniMode?: number): void
    -_onLoaded(): void
    -_parseComplete(): void
    -_parseFail(): void
    -_onPlay(): void
    -_onStop(): void
    -_onPause(): void
    -_parseSrcBoneMatrix(): void
    -_emitMissedEvents(startTime: number, endTime: number, startIndex?: number): void
    -_update(autoKey?: boolean): void
    -_onAniSoundStoped(force: boolean): void
    #_createGraphics(_clipIndex?: number): GraphicsAni
    -_checkIsAllParsed(_aniClipIndex: number): void
    -_setDeform(tDeformAniData: DeformAniData, tDeformDic: any, _boneSlotArray: any[], curTime: number): void
    +getAnimNum(): number
    +getAniNameByIndex(index: number): string
    +getSlotByName(name: string): BoneSlot
    +showSkinByName(name: string, freshSlotIndex?: boolean): void
    +showSkinByIndex(skinIndex: number, freshSlotIndex?: boolean): void
    +showSlotSkinByIndex(slotName: string, index: number): void
    +showSlotSkinByName(slotName: string, name: string): void
    +replaceSlotSkinName(slotName: string, oldName: string, newName: string): void
    +replaceSlotSkinByIndex(slotName: string, oldIndex: number, newIndex: number): void
    +setSlotSkin(slotName: string, texture: Texture): void
    -_clearCache(): void
    +play(nameOrIndex: any, loop: boolean, force?: boolean, start?: number, end?: number, freshSkin?: boolean, playAudio?: boolean): void
    +stop(): void
    +playbackRate(value: number): void
    +paused(): void
    +resume(): void
    -_getGrahicsDataWithCache(aniIndex: number, frameIndex: number): Graphics
    -_setGrahicsDataWithCache(aniIndex: number, frameIndex: number, graphics: Graphics): void
    +destroy(destroyChild?: boolean): void
    +index: number
    +index: number
    +total: number
    +player: AnimationPlayer
    +templet: Templet
    +{static} useSimpleMeshInCanvas: boolean
}
class IAniLib {
    +{static} Skeleton: typeof Skeleton
    +{static} AnimationTemplet: typeof AnimationTemplet
    +{static} Templet: typeof Templet
}
class AnimationParser01 {
    +{static} parse(templet: AnimationTemplet, reader: Byte): void
}
class AnimationParser02 {
    -{static} _templet: AnimationTemplet
    -{static} _reader: Byte
    -{static} _strings: any[]
    -{static} _BLOCK: any
    -{static} _DATA: any
    -{static} READ_DATA(): void
    -{static} READ_BLOCK(): void
    -{static} READ_STRINGS(): void
    +{static} parse(templet: AnimationTemplet, reader: Byte): void
    +{static} READ_ANIMATIONS(): void
}
class BezierLerp {
    -{static} _bezierResultCache: any
    -{static} _bezierPointsCache: any
    +{static} getBezierRate(t: number, px0: number, py0: number, px1: number, py1: number): number
    -{static} _getBezierParamKey(px0: number, py0: number, px1: number, py1: number): number
    -{static} _getBezierPoints(px0: number, py0: number, px1: number, py1: number, key: number): any[]
}
class AnimationTemplet extends Resource {
    +_aniVersion: string
    +_anis: AnimationContent[]
    +_aniMap: any
    +_publicExtData: ArrayBuffer
    +_useParent: boolean
    #unfixedCurrentFrameIndexes: Uint32Array
    #unfixedCurrentTimes: Float32Array
    #unfixedKeyframes: KeyFramesContent[]
    #unfixedLastAniIndex: number
    +_aniClassName: string
    +_animationDatasCache: any
    +_fullFrames: any[]
    -_boneCurKeyFrm: any[]
    +parse(data: ArrayBuffer): void
    +_calculateKeyFrame(node: AnimationNodeContent, keyframeCount: number, keyframeDataCount: number): void
    +_onAsynLoaded(data: any, propertyParams?: any): void
    +getAnimationCount(): number
    +getAnimation(aniIndex: number): any
    +getAniDuration(aniIndex: number): number
    +getNodes(aniIndex: number): any
    +getNodeIndexWithName(aniIndex: number, name: string): number
    +getNodeCount(aniIndex: number): number
    +getTotalkeyframesLength(aniIndex: number): number
    +getPublicExtData(): ArrayBuffer
    +getAnimationDataWithCache(key: any, cacheDatas: any, aniIndex: number, frameIndex: number): Float32Array
    +setAnimationDataWithCache(key: any, cacheDatas: any[], aniIndex: number, frameIndex: number, data: any): void
    +getNodeKeyFrame(nodeframes: KeyFramesContent[], nodeid: number, tm: number): number
    +getOriginalData(aniIndex: number, originalData: Float32Array, nodesFrameIndices: any[], frameIndex: number, playCurTime: number): void
    +getNodesCurrentFrameIndex(aniIndex: number, playCurTime: number): Uint32Array
    +getOriginalDataUnfixedRate(aniIndex: number, originalData: Float32Array, playCurTime: number): void
    +{static} interpolation: any[]
    -{static} _LinearInterpolation_0(bone: AnimationNodeContent, index: number, out: Float32Array, outOfs: number, data: Float32Array, dt: number, dData: Float32Array, duration: number, nextData: Float32Array, interData?: any[]): number
    -{static} _QuaternionInterpolation_1(bone: any, index: number, out: Float32Array, outOfs: number, data: Float32Array, dt: number, dData: Float32Array, duration: number, nextData: Float32Array, interData?: any[]): number
    -{static} _AngleInterpolation_2(bone: AnimationNodeContent, index: number, out: Float32Array, outOfs: number, data: Float32Array, dt: number, dData: Float32Array, duration: number, nextData: Float32Array, interData?: any[]): number
    -{static} _RadiansInterpolation_3(bone: AnimationNodeContent, index: number, out: Float32Array, outOfs: number, data: Float32Array, dt: number, dData: Float32Array, duration: number, nextData: Float32Array, interData?: any[]): number
    -{static} _Matrix4x4Interpolation_4(bone: any, index: number, out: Float32Array, outOfs: number, data: Float32Array, dt: number, dData: Float32Array, duration: number, nextData: Float32Array, interData?: any[]): number
    -{static} _NoInterpolation_5(bone: AnimationNodeContent, index: number, out: Float32Array, outOfs: number, data: Float32Array, dt: number, dData: Float32Array, duration: number, nextData: Float32Array, interData?: any[]): number
    -{static} _BezierInterpolation_6(bone: AnimationNodeContent, index: number, out: Float32Array, outOfs: number, data: Float32Array, dt: number, dData: Float32Array, duration: number, nextData: Float32Array, interData?: any[], offset?: number): number
    -{static} _BezierInterpolation_7(bone: AnimationNodeContent, index: number, out: Float32Array, outOfs: number, data: Float32Array, dt: number, dData: Float32Array, duration: number, nextData: Float32Array, interData?: any[], offset?: number): number
}
class Templet extends AnimationTemplet {
    -_mainTexture: Texture
    -_graphicsCache: any[]
    +srcBoneMatrixArr: any[]
    +ikArr: any[]
    +tfArr: any[]
    +pathArr: any[]
    +boneSlotDic: any
    +bindBoneBoneSlotDic: any
    +boneSlotArray: any[]
    +skinDataArray: any[]
    +skinDic: any
    +subTextureDic: any
    +isParseFail: boolean
    +yReverseMatrix: Matrix
    +drawOrderAniArr: any[]
    +eventAniArr: any[]
    +attachmentNames: any[]
    +deformAniArr: any[]
    +skinSlotDisplayDataArr: SkinSlotDisplayData[]
    -_isParseAudio: boolean
    -_isDestroyed: boolean
    -_rate: number
    +isParserComplete: boolean
    +aniSectionDic: any
    -_skBufferUrl: string
    -_textureDic: any
    -_loadList: any[]
    -_path: string
    -_relativeUrl: string
    +tMatrixDataLen: number
    +mRootBone: Bone
    +mBoneArr: Bone[]
    +loadAni(url: string): void
    -onComplete(content?: any): void
    +parseData(texture: Texture, skeletonData: ArrayBuffer, playbackRate?: number): void
    +buildArmature(aniMode?: number): Skeleton
    +parse(data: ArrayBuffer): void
    -_parseTexturePath(): void
    -_textureComplete(): void
    -_parsePublicExtData(): void
    +getTexture(name: string): Texture
    +showSkinByIndex(boneSlotDic: any, skinIndex: number, freshDisplayIndex?: boolean): boolean
    +getSkinIndexByName(skinName: string): number
    +getGrahicsDataWithCache(aniIndex: number, frameIndex: number): Graphics
    +_setCreateURL(url: string): void
    +setGrahicsDataWithCache(aniIndex: number, frameIndex: number, graphics: Graphics): void
    +deleteAniData(aniIndex: number): void
    +destroy(): void
    +getAniNameByIndex(index: number): string
    +rate: number
    +rate: number
    +{static} LAYA_ANIMATION_160_VISION: string
    +{static} LAYA_ANIMATION_VISION: string
    +{static} TEMPLET_DICTIONARY: any
}
namespace __global {
    interface Window {
        +applicationCache: ApplicationCache
        +clientInformation: Navigator
        +closed: boolean
        +customElements: CustomElementRegistry
        +defaultStatus: string
        +devicePixelRatio: number
        +doNotTrack: string
        +document: Document
        +event: Event
        +external: External
        +frameElement: Element
        +frames: Window
        +history: History
        +innerHeight: number
        +innerWidth: number
        +isSecureContext: boolean
        +length: number
        +location: Location
        +locationbar: BarProp
        +menubar: BarProp
        +msContentScript: ExtensionScriptApis
        +name: string
        +navigator: Navigator
        +offscreenBuffering: string | boolean
        +oncompassneedscalibration: (this: Window, ev: Event) => any
        +ondevicelight: (this: Window, ev: DeviceLightEvent) => any
        +ondevicemotion: (this: Window, ev: DeviceMotionEvent) => any
        +ondeviceorientation: (this: Window, ev: DeviceOrientationEvent) => any
        +ondeviceorientationabsolute: (this: Window, ev: DeviceOrientationEvent) => any
        +onmousewheel: (this: Window, ev: Event) => any
        +onmsgesturechange: (this: Window, ev: Event) => any
        +onmsgesturedoubletap: (this: Window, ev: Event) => any
        +onmsgestureend: (this: Window, ev: Event) => any
        +onmsgesturehold: (this: Window, ev: Event) => any
        +onmsgesturestart: (this: Window, ev: Event) => any
        +onmsgesturetap: (this: Window, ev: Event) => any
        +onmsinertiastart: (this: Window, ev: Event) => any
        +onmspointercancel: (this: Window, ev: Event) => any
        +onmspointerdown: (this: Window, ev: Event) => any
        +onmspointerenter: (this: Window, ev: Event) => any
        +onmspointerleave: (this: Window, ev: Event) => any
        +onmspointermove: (this: Window, ev: Event) => any
        +onmspointerout: (this: Window, ev: Event) => any
        +onmspointerover: (this: Window, ev: Event) => any
        +onmspointerup: (this: Window, ev: Event) => any
        +onorientationchange: (this: Window, ev: Event) => any
        +onreadystatechange: (this: Window, ev: ProgressEvent<Window>) => any
        +onvrdisplayactivate: (this: Window, ev: Event) => any
        +onvrdisplayblur: (this: Window, ev: Event) => any
        +onvrdisplayconnect: (this: Window, ev: Event) => any
        +onvrdisplaydeactivate: (this: Window, ev: Event) => any
        +onvrdisplaydisconnect: (this: Window, ev: Event) => any
        +onvrdisplayfocus: (this: Window, ev: Event) => any
        +onvrdisplaypointerrestricted: (this: Window, ev: Event) => any
        +onvrdisplaypointerunrestricted: (this: Window, ev: Event) => any
        +onvrdisplaypresentchange: (this: Window, ev: Event) => any
        +opener: any
        +orientation: string | number
        +outerHeight: number
        +outerWidth: number
        +pageXOffset: number
        +pageYOffset: number
        +parent: Window
        +personalbar: BarProp
        +screen: Screen
        +screenLeft: number
        +screenTop: number
        +screenX: number
        +screenY: number
        +scrollX: number
        +scrollY: number
        +scrollbars: BarProp
        +self: Window & typeof globalThis
        +speechSynthesis: SpeechSynthesis
        +status: string
        +statusbar: BarProp
        +styleMedia: StyleMedia
        +toolbar: BarProp
        +top: Window
        +window: Window & typeof globalThis
        +alert(message?: any): void
        +blur(): void
        +captureEvents(): void
        +close(): void
        +confirm(message?: string): boolean
        +departFocus(navigationReason: NavigationReason, origin: FocusNavigationOrigin): void
        +focus(): void
        +getComputedStyle(elt: Element, pseudoElt?: string): CSSStyleDeclaration
        +getMatchedCSSRules(elt: Element, pseudoElt?: string): CSSRuleList
        +getSelection(): Selection
        +matchMedia(query: string): MediaQueryList
        +moveBy(x: number, y: number): void
        +moveTo(x: number, y: number): void
        +msWriteProfilerMark(profilerMarkName: string): void
        +open(url?: string, target?: string, features?: string, replace?: boolean): Window
        +postMessage(message: any, targetOrigin: string, transfer?: Transferable[]): void
        +print(): void
        +prompt(message?: string, _default?: string): string
        +releaseEvents(): void
        +resizeBy(x: number, y: number): void
        +resizeTo(x: number, y: number): void
        +scroll(options?: ScrollToOptions): void
        +scroll(x: number, y: number): void
        +scrollBy(options?: ScrollToOptions): void
        +scrollBy(x: number, y: number): void
        +scrollTo(options?: ScrollToOptions): void
        +scrollTo(x: number, y: number): void
        +stop(): void
        +webkitCancelAnimationFrame(handle: number): void
        +webkitConvertPointFromNodeToPage(node: Node, pt: WebKitPoint): WebKitPoint
        +webkitConvertPointFromPageToNode(node: Node, pt: WebKitPoint): WebKitPoint
        +webkitRequestAnimationFrame(callback: FrameRequestCallback): number
        +addEventListener(type: K, listener: (this: Window, ev: WindowEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void
        +addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void
        +removeEventListener(type: K, listener: (this: Window, ev: WindowEventMap[K]) => any, options?: boolean | EventListenerOptions): void
        +removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void
        +CDN_VERSION: string
        +Laya3D: any
    }
}
class HTMLExtendStyle {
    +stroke: number
    +strokeColor: string
    +leading: number
    +lineHeight: number
    +letterSpacing: number
    +href: string
    +reset(): HTMLExtendStyle
    +recover(): void
    +{static} EMPTY: HTMLExtendStyle
    +{static} create(): HTMLExtendStyle
}
class HTMLStyle {
    +_type: number
    +fontSize: number
    +family: string
    +color: string
    +ower: HTMLElement
    -_extendStyle: HTMLExtendStyle
    +textDecoration: string
    +bgColor: string
    +borderColor: string
    +padding: any[]
    -_getExtendStyle(): HTMLExtendStyle
    +href: string
    +href: string
    +stroke: number
    +stroke: number
    +strokeColor: string
    +strokeColor: string
    +leading: number
    +leading: number
    +lineHeight: number
    +lineHeight: number
    +align: string
    +align: string
    +valign: string
    +valign: string
    +font: string
    +font: string
    +block: boolean
    +block: boolean
    +reset(): HTMLStyle
    +recover(): void
    +inherit(src: HTMLStyle): void
    +wordWrap: boolean
    +wordWrap: boolean
    +bold: boolean
    +bold: boolean
    +italic: boolean
    +italic: boolean
    +_widthAuto(): boolean
    +widthed(sprite: any): boolean
    +whiteSpace: string
    +whiteSpace: string
    +_calculation(type: string, value: string): boolean
    +width: any
    +height: any
    +heighted(sprite: any): boolean
    +size(w: number, h: number): void
    +getLineElement(): boolean
    +setLineElement(value: boolean): void
    +_enableLayout(): boolean
    +letterSpacing: number
    +letterSpacing: number
    +cssText(text: string): void
    +attrs(attrs: any[]): void
    +position: string
    +position: string
    +absolute: boolean
    +paddingLeft: number
    +paddingTop: number
    -{static} _CSSTOVALUE: any
    -{static} _parseCSSRegExp: RegExp
    -{static} _inheritProps: any[]
    +{static} ALIGN_LEFT: string
    +{static} ALIGN_CENTER: string
    +{static} ALIGN_RIGHT: string
    +{static} VALIGN_TOP: string
    +{static} VALIGN_MIDDLE: string
    +{static} VALIGN_BOTTOM: string
    +{static} styleSheets: any
    +{static} ADDLAYOUTED: number
    -{static} _PADDING: any[]
    #{static} _HEIGHT_SET: number
    #{static} _LINE_ELEMENT: number
    #{static} _NOWARP: number
    #{static} _WIDTHAUTO: number
    #{static} _BOLD: number
    #{static} _ITALIC: number
    #{static} _CSS_BLOCK: number
    #{static} _DISPLAY_NONE: number
    #{static} _ABSOLUTE: number
    #{static} _WIDTH_SET: number
    #{static} alignVDic: any
    #{static} align_Value: any
    #{static} vAlign_Value: any
    #{static} _ALIGN: number
    #{static} _VALIGN: number
    +{static} create(): HTMLStyle
    +{static} parseOneCSS(text: string, clipWord: string): any[]
    +{static} parseCSS(text: string, uri: URL): void
}
class HTMLDocument {
    +all: HTMLElement[]
    +styleSheets: any
    +getElementById(id: string): HTMLElement
    +setElementById(id: string, e: HTMLElement): void
    +{static} document: HTMLDocument
}
class HTMLHitRect {
    +rec: Rectangle
    +href: string
    +reset(): HTMLHitRect
    +recover(): void
    +{static} create(): HTMLHitRect
}
interface ILayout {
    +x: number
    +y: number
    +width: number
    +height: number
    +_isChar(): boolean
    +_getCSSStyle(): HTMLStyle
}
class HTMLImageElement extends HTMLElement {
    -_tex: Texture
    -_url: string
    +reset(): HTMLElement
    +src: string
    -onloaded(): void
    +_addToLayout(out: ILayout[]): void
    +renderSelfToGraphic(graphic: Graphics, gX: number, gY: number, recList: any[]): void
}
class HTMLBrElement {
    +_addToLayout(out: ILayout[]): void
    +reset(): HTMLBrElement
    +destroy(): void
    #_setParent(value: HTMLElement): void
    +parent: any
    +URI: any
    +href: any
    +_getCSSStyle(): HTMLStyle
    +renderSelfToGraphic(graphic: Graphics, gX: number, gY: number, recList: any[]): void
    +{static} brStyle: HTMLStyle
}
class HTMLStyleElement extends HTMLElement {
    #_creates(): void
    +drawToGraphic(graphic: Graphics, gX: number, gY: number, recList: any[]): void
    +reset(): HTMLElement
    +innerTEXT: string
    +innerTEXT: string
}
class HTMLLinkElement extends HTMLElement {
    +type: string
    -_loader: Loader
    #_creates(): void
    +drawToGraphic(graphic: Graphics, gX: number, gY: number, recList: any[]): void
    +reset(): HTMLElement
    +_onload(data: string): void
    +href: string
    +href: string
    +{static} _cuttingStyle: RegExp
}
class HTMLParse {
    -{static} char255: string
    -{static} spacePattern: RegExp
    -{static} char255AndOneSpacePattern: RegExp
    -{static} _htmlClassMapShort: any
    +{static} getInstance(type: string): any
    +{static} parse(ower: HTMLDivParser, xmlString: string, url: URL): void
    -{static} _parseXML(parent: HTMLElement, xml: any, url: URL, href?: string): void
}
class IHtml {
    +{static} HTMLDivElement: typeof HTMLDivElement
    +{static} HTMLImageElement: typeof HTMLImageElement
    +{static} HTMLBrElement: typeof HTMLBrElement
    +{static} HTMLDivParser: typeof HTMLDivParser
    +{static} HTMLParse: typeof HTMLParse
    +{static} HTMLElementType: typeof HTMLElementType
}
class LayoutLine {
    +elements: ILayout[]
    +x: number
    +y: number
    +w: number
    +h: number
    +wordStartIndex: number
    +minTextHeight: number
    +mWidth: number
    +updatePos(left: number, width: number, lineNum: number, dy: number, align: string, valign: string, lineHeight: number): void
}
class Layout {
    -{static} DIV_ELEMENT_PADDING: number
    -{static} _will: HTMLElement[]
    +{static} later(element: HTMLElement): void
    +{static} layout(element: HTMLElement): any[]
    +{static} _multiLineLayout(element: HTMLElement): any[]
}
enum HTMLElementType {
    BASE
    IMAGE
}
class HTMLElement {
    +eletype: HTMLElementType
    +URI: URL
    +parent: HTMLElement
    +_style: HTMLStyle
    #_text: any
    #_children: any[]
    #_x: number
    #_y: number
    #_width: number
    #_height: number
    #_creates(): void
    +reset(): HTMLElement
    +_getCSSStyle(): HTMLStyle
    +_addChildsToLayout(out: ILayout[]): boolean
    +_addToLayout(out: ILayout[]): void
    +id: string
    +repaint(recreate?: boolean): void
    +parentRepaint(recreate?: boolean): void
    +innerTEXT: string
    +innerTEXT: string
    #_setParent(value: HTMLElement): void
    +appendChild(c: HTMLElement): HTMLElement
    +addChild(c: HTMLElement): HTMLElement
    +removeChild(c: HTMLElement): HTMLElement
    +destroy(): void
    +destroyChildren(): void
    +style: HTMLStyle
    +_getWords(): HTMLChar[]
    +_isChar(): boolean
    +_layoutLater(): void
    +x: number
    +x: number
    +y: number
    +y: number
    +width: number
    +width: number
    +height: number
    +height: number
    +_setAttributes(name: string, value: string): void
    +href: string
    +href: string
    +formatURL(url: string): string
    +color: string
    +className: string
    +drawToGraphic(graphic: Graphics, gX: number, gY: number, recList: any[]): void
    +renderSelfToGraphic(graphic: Graphics, gX: number, gY: number, recList: any[]): void
    -workLines(wordList: any[], g: Graphics, recList: any[]): void
    -createOneLine(startWord: HTMLChar, lastWords: HTMLChar, hasLine: boolean, graphic: Graphics, recList: any[]): void
    -{static} _EMPTYTEXT: any
    +{static} formatURL1(url: string, basePath?: string): string
    +{static} getClassName(tar: any): string
}
class HTMLDivParser extends HTMLElement {
    +contextHeight: number
    +contextWidth: number
    -_htmlBounds: Rectangle
    -_boundsRec: Rectangle
    +repaintHandler: Handler
    +reset(): HTMLElement
    +innerHTML: string
    +width: number
    +width: number
    +appendHTML(text: string): void
    +_addChildsToLayout(out: ILayout[]): boolean
    +_addToLayout(out: ILayout[]): void
    +getBounds(): Rectangle
    +parentRepaint(recreate?: boolean): void
    +layout(): void
    +height: number
    +height: number
}
class HTMLDivElement extends Sprite {
    +_element: HTMLDivParser
    -_recList: any[]
    -_innerHTML: string
    -_repaintState: number
    +destroy(destroyChild?: boolean): void
    -_htmlDivRepaint(recreate?: boolean): void
    -_updateGraphicWork(): void
    -_setGraphicDirty(): void
    -_doClears(): void
    -_updateGraphic(): void
    +style: HTMLStyle
    +innerHTML: string
    -_refresh(): void
    +contextWidth: number
    +contextHeight: number
    -_onMouseClick(): void
    -_eventLink(href: string): void
}
namespace ui {
}
namespace ui {
}
namespace ui {
}
namespace ui {
}
namespace ui {
}
namespace ui {
}
namespace ui {
}
class AudioCtrl {
    -{static} voice: number
    -{static} music: number
    -{static} sound_manager: typeof SoundManager
    +{static} setVoice(voice: number): void
    +{static} setMusic(music: number): void
    +{static} play(audio: string, is_bg?: boolean): void
    +{static} stop(audio?: string): boolean
    +{static} stopAll(): void
    +{static} changeVolume(volume: number): void
    +{static} isMute(is_bg?: boolean): boolean
}
class default implements HonorDialog {
    +isModal: boolean
    +tip(msg: string): Promise<unknown>
    -analysisSize(msg: string): void
    -setTipText(msg: string): void
    +{static} tip(msg: string): Promise<void>
}
class default implements HonorDialog {
    +isShowEffect: boolean
    +isPopupCenter: boolean
    +tip(msg: string, time: number): Promise<unknown>
    -analysisSize(msg: string): void
    -setTipText(msg: string): void
    +{static} tip(msg: string, time?: number): Promise<void>
}
interface Component {
    +destroy(): void
}
class ComponentManager {
    +destroyed: boolean
    -components: Set<Component>
    +addCom(com_list: Component[]): void
    +delCom(com_list: Component[]): void
    +getCom(ctor: any): T
    +destroy(): void
}
class EventCom {
    #events: Map<string, EventData>
    +on(event: string, callback: any, caller?: any, once?: boolean): void
    +once(event: string, callback?: any, caller?: any): void
    +getBind(event: string): EventData
    +off(event: string, callback: any, caller: any): void
    +offAllCaller(caller: any): void
    +emit(event: string, params: any[]): void
    +destroy(): void
}
class WebSocketCtrl {
    +url: string
    +handlers: Handlers
    -ws: WebSocket
    -reconnect_count: number
    -reconnect_max: number
    -reconnect_timeout: number
    -heartbeat_interval: number
    -heartbeat_gap_timeout: number
    -heartbeat_time: number
    -heartbeat_gap_time: number
    -ping_pong_map?: PingPongMap
    +status: Status
    +connect(): void
    +send(msg: string): void
    -onopen: () => void
    -onmessage: (ev: MessageEvent) => void
    -onError: () => void
    -onclose: () => void
    +reconnect(): void
    +startHeartBeat(): void
    +clearHearBeatGapTimeout(): void
    +sendPing(): void
    +sendPong(): void
    +disconnect(): void
    -end(): void
    -reset(): void
}
enum ServerMsgType {
    OnData
    PingTimeOut
    Ping
    Pong
    Error
    MsgAck
}
interface WebSocketTrait {
    +event: EventCom
    +setParams(params: {}): void
    +send(cmd: string, data?: {}): void
    +disconnect(): void
}
class WebSocketWrapCtrl extends ComponentManager implements WebSocketTrait {
    -ws: WebSocketCtrl
    -params: {}
    +event: EventCom
    -config: Config
    -init(): void
    +setParams(params: {}): void
    +send(cmd: string, data?: {}): void
    +disconnect(): void
    -onInit: () => void
    -onData: (msg: string) => void
    -onClose: () => void
    -onEnd: () => void
    -onReconnect: () => void
    -onReconnected: () => void
}
enum ServerErrCode {
    TokenExpire
}
class GlowFilterGLRender {
    -setShaderInfo(shader: Value2D, w: number, h: number, data: GlowFilter): void
    +render(rt: RenderTexture2D, ctx: Context, width: number, height: number, filter: GlowFilter): void
}
class BlurFilterGLRender {
    +render(rt: RenderTexture2D, ctx: Context, width: number, height: number, filter: BlurFilter): void
    +setShaderInfo(shader: Value2D, filter: BlurFilter, w: number, h: number): void
    -{static} blurinfo: any[]
}
class BlurFilter extends Filter {
    +strength: number
    +strength_sig2_2sig2_gauss1: any[]
    +strength_sig2_native: Float32Array
    +renderFunc: any
    +type: number
    +getStrenth_sig2_2sig2_native(): Float32Array
}
class GlowFilter extends Filter {
    -_elements: Float32Array
    +_sv_blurInfo1: any[]
    +_sv_blurInfo2: any[]
    -_color: ColorUtils
    +_color_native: Float32Array
    +_blurInof1_native: Float32Array
    +_blurInof2_native: Float32Array
    +type: number
    +offY: number
    +offY: number
    +offX: number
    +offX: number
    +getColor(): any[]
    +blur: number
    +blur: number
    +getColorNative(): Float32Array
    +getBlurInfo1Native(): Float32Array
    +getBlurInfo2Native(): Float32Array
}
class default implements HonorDialog {
    -is_init: boolean
    +isModal: boolean
    -lottery_interval: number
    -remain_info: { lottery_num: number; lottery_cost: number; }
    +onMounted(): void
    -init(): void
    +initData(data: LotteryPopData): void
    -renderLottery: (box: itemUI, index: number) => void
    -runLottery(): void
    +runLotteryAni(id: string): Promise<unknown>
    -completeLottery(): void
    -renderExchange: (box: item2UI, index: number) => void
    -runTicketExchange(index: number): Promise<void>
    +destroy(): void
    +{static} preEnter(): Promise<void>
}
enum GunSkinStatus {
    NoHave
    Have
    Used
}
class default implements HonorDialog {
    +isModal: boolean
    -is_init: boolean
    +init(): void
    +onMounted(): void
    +initData(data: ShopData): void
    -renderGunList: (box: shopGunItemUI, index: number) => void
    +useGunSkin(id: string): void
    +buyGunSkin(id: string): void
    -renderItemList: (box: shopItemItemUI, index: number) => void
    +{static} preEnter(): Promise<void>
}
interface GameSprite {
    +gun: { [key: string]: string[]; }
    +bullet: { [key: string]: SpriteInfo; }
    +fish_icon: { [key: string]: SpriteInfo; }
    +net: { [key: string]: SpriteInfo; }
    +fish_shadow: { [key: string]: SpriteInfo; }
    +fish: { [key: string]: FishSpriteInfo; }
    +other: { [key: string]: SpriteInfo; }
}
interface ShapeOriData {
    +bullet: shapeOriInfoItem
    +net: shapeOriInfoItem
    +fish: { [key: string]: shapeOriInfoItem; }
}
class Line {
    -direction: Vector
    +is_static: boolean
    -len: number
    -start_pos: any
    -end_pos: any
    +get(t: number): { x: any; y: any; }
    +derivative(t: number): Vector
    +length(t: number): number
}
class Displace {
    #curve_list: CurveInfo[]
    #used_frame: number
    #total_frame: number
    #cur_curve_info: CurCurveInfo
    -is_reverse: boolean
    +radio: number
    +update(update_frame: number): DisplaceInfo
    #getPointAtRadio(radio: number): { position: any; direction: Vector; }
    #calcCurCurveInfo(radio: number): CurCurveInfo
}
class BodyCom {
    -angle: number
    -pos: any
    +horizon_turn: boolean
    +shapes: ShapeInfo[]
    +update(pos: any, direction?: Vector): void
    -setPos(pos: any): void
    -setAngle(direction: Vector): void
    +destroy(): void
}
class TimeoutCom implements Component {
    -timeout_list: Set<number>
    -interval_list: Set<number>
    +createTimeout(fn: TimeoutFn, time?: number): number
    +createInterval(fn: TimeoutFn, time: number): number
    +clear(timeout: number): void
    +destroy(): void
}
class GameFreezeCom extends ComponentManager {
    -game: GameModel
    -freezing_timeout: number
    +freezing(cool_time: number, fish_list: string[]): void
    +unFreezing(): void
}
class MoveDisplaceCom implements MoveCom {
    -displace: Displace
    -tick_index: number
    -is_stop: boolean
    -update_fn: MoveUpdateFn
    +onUpdate(update_fn: MoveUpdateFn): void
    +start(): void
    -onTick: (t: number) => void
    +stop(): void
    +getRadio(): number
    +destroy(): void
}
class ShoalCom extends ComponentManager {
    -game: GameModel
    +shoal_map: Map<string, Set<FishModel>>
    +preAddShoal(reverse: boolean): void
    +addShoal(shoal_info: any): void
    +removeShoal(shoal_id: string): void
    -genFish(): void
    +destroy(): void
}
class GunAutoLaunchCom extends ComponentManager {
    -gun: GunModel
    +active(): void
    +clear(): void
    +destroy(): void
}
interface TrackTarget {
    +pos: any
}
class MoveTrackCom implements MoveCom {
    -target: TrackTarget
    -pos: any
    -start_pos: any
    -velocity_size: number
    -update_fn: any
    -on_hit: OnHit
    -tick_index: number
    -is_stop: boolean
    +start(): void
    +stop(): void
    +onUpdate(update_fn: any): void
    -update: (t: number) => void
    -detectOnHit(): boolean
    +destroy(): void
}
class MoveVelocityCom implements MoveCom {
    -pos: any
    -velocity: Vector
    -update_fn: any
    -tick_index: number
    -is_stop: boolean
    +start(): void
    +stop(): void
    +update(t: number): void
    +onUpdate(update_fn: any): void
    +detectHitWall(): void
    +destroy(): void
}
class SettingModel extends ComponentManager {
    +voice: number
    +music: number
    +initAudio(): void
    +event: Component
    +setVoice(voice: number): void
    +setMusic(music: number): void
}
enum Lang {
    Zh
    Kor
    En
    Jp
}
class UserInfoModel extends ComponentManager {
    +lang: Lang
    +cur_balance: string
    +user_id: string
    +nickname: string
    +account_map: AccountMap
    +event: Component
    +setCurBalance(balance: string, force_change?: boolean): void
    +setLang(lang: Lang): void
    +setUserId(name: string): void
    +setNickname(name: string): void
    +setAccount(data: any): void
}
class AppModel extends ComponentManager {
    +game: GameModel
    +setting: SettingModel
    +user_info: UserInfoModel
    +init(): void
    +enterGame(): GameModel
    +leaveGame(): void
}
class NetModel extends ComponentManager {
    +pos: any
    +bullet_cost: number
    +skin: string
    +skin_level: string
    +show_cast: boolean
    +event: EventCom
    +body: Component
    -init(): void
    +destroy(): void
}
class BulletModel extends ComponentManager {
    +skin_level: string
    +bullet_cost: number
    +skin: string
    +pos: any
    +velocity: Vector
    +cast_fn: CastFn
    +track: TrackTarget
    +event: EventCom
    -body: BodyCom
    -move_com: any
    -initCom(): void
    +init(): void
    -onMoveChange: (move_info: any) => void
    -onTrackMoveChange: (move_info: any) => void
    -onHit: (fish: FishModel) => void
    +addNet: (show_cast: boolean) => void
    +destroy(): void
}
class BulletGroup extends ComponentManager {
    +bullet_list: Set<BulletModel>
    -gun: GunModel
    +bullet_cost: number
    -casted: boolean
    +event: EventCom
    +init(): void
    -initBullet(info: BulletGroupInfo): void
    -castFn: (fish: FishModel) => void
    +destroy(): void
}
enum GunStatus {
    Normal
    AutoLaunch
    TrackFish
}
class GunModel extends ComponentManager {
    +direction: Vector
    +pos: any
    +bullet_cost: number
    +skin: string
    +skin_level: string
    +hole_num: number
    -bullet_list: Set<BulletGroup>
    +player: PlayerModel
    +track_fish: FishModel
    +status: GunStatus
    +is_speedup: boolean
    +launch_space: number
    -is_on: boolean
    +rage: boolean
    +event: EventCom
    +timeout: TimeoutCom
    -initCom(): void
    +init(): void
    -initDirection(): void
    +setDirection(direction: Vector): void
    +changeSkin(skinId: string): void
    +setBulletCost(bullet_cost: number, force?: boolean): void
    +setStatus(status: GunStatus): void
    +toggleSpeedUp(is_speedup: boolean): void
    +autoLaunch: Component
    +preAddBullet(velocity: Vector, force?: boolean): void
    +addBullet(direction: any): void
    +castFish(fish: FishModel, level: number): void
    +removeBullet(bullet: BulletGroup): void
    +destroy(): void
}
enum SkillStatus {
    Normal
    PreActive
    Active
}
class SkillCoreCom extends ComponentManager {
    +item_id: string
    +num: number
    +cool_time: number
    +used_time: number
    +count_index: number
    +status: SkillStatus
    +player: PlayerModel
    +event: EventCom
    -initCom(): void
    +init(): void
    +addNum(num: number): void
    +setStatus(status: SkillStatus): void
    +activeEvent(info: any): void
    +active(info?: SkillActiveInfo): Promise<unknown>
    +reset(): void
    +disable(): void
    +destroy(): void
}
class AutoLaunchModel extends ComponentManager implements SkillModel {
    +skill_core: SkillCoreCom
    -initCom(info: SkillInfo): void
    +toggle(): void
    +init(): void
    +reset(): void
    +active(): void
    +disable(): void
}
class FishBombCom {
    -fish: FishModel
    +active(need_emit?: boolean): void
    +destroy(): void
}
class BombModel extends ComponentManager implements SkillModel {
    +skill_core: SkillCoreCom
    -initCom(info: SkillInfo): void
    +reset(): void
    +init(): void
    +active(info: BombInfo): void
    +disable(): void
}
class FreezeModel extends ComponentManager implements SkillModel {
    +skill_core: SkillCoreCom
    -initCom(info: SkillInfo): void
    +init(): void
    +reset(): void
    +active(info: FreezeInfo): void
    +disable(): void
}
interface TrackFishInitInfo extends SkillInfo {
    +lock_fish: string
    +lock_left: number
}
class TrackFishModel extends ComponentManager implements SkillModel {
    +skill_core: SkillCoreCom
    -timeout: TimeoutCom
    -init_info: TrackFishInitInfo
    +fish: FishModel
    +bullet_list: Set<BulletGroup>
    -gun: GunModel
    +init(): void
    +reset(): void
    -initCom(info: TrackFishInitInfo): void
    +active(info: TrackFishActiveInfo): void
    +tipTrack(): void
    -track(fish: FishModel): void
    -bindTrackFish(fish: FishModel): void
    -onTrackMove: () => void
    -unTrack: () => void
    +disable(): void
}
interface SkillModel {
    +skill_core: SkillCoreCom
    +init(): void
    +active(info: any): void
    +reset(): void
    +disable(): void
    +destroy(): void
}
class PlayerModel extends ComponentManager {
    +need_emit: boolean
    +user_id: string
    +is_cur_player: boolean
    +server_index: number
    +bullet_cost: number
    +bullet_num: number
    +nickname: string
    +avatar: string
    +gun: GunModel
    +skill_map: Map<string, SkillModel>
    +game: GameModel
    +event: Component
    -createGun(player_info: PlayerInfo): void
    +init(): void
    +updateInfo(info: Partial<PlayerInfo>): void
    -initSkill(skills: SkillInfoMap): void
    +activeSkill(skill: SkillMap, data?: any): void
    +resetSkill(skill: SkillMap): void
    +addSkillNum(id: string, num: number): void
    +captureFish(pos: any, data: { win: number; drop: any[]; }): Promise<void>
    +changeSkin(skinId: string): void
    +destroy(): void
}
class GameModel extends ComponentManager {
    +fish_list: Set<FishModel>
    -player_list: Set<PlayerModel>
    -initCom(): void
    +event: Component
    +freezing_com: Component
    +addFish(fish_info: any): void
    +removeFish(fish: FishModel): void
    +getFishById(id: string): FishModel
    +getAllFish(): FishModel[]
    +captureFish(info: any): void
    +shoal_com: Component
    +addPlayer(data: PlayerInfo): PlayerModel
    +getPlayerById(id: string): PlayerModel
    +removePlayer(player: PlayerModel): void
    +activeSkill(skill: SkillMap, data: { user_id: string; }): void
    +resetSkill(skill: SkillMap, user_id: string): void
    +shoot(data: any): void
    +shoalComingTip(reverse: boolean): void
    +destroy(): void
}
enum FishStatus {
    Normal
    Freezed
    QuickLeave
    Dead
}
class FishModel extends ComponentManager {
    +id: string
    +type: string
    +pos: any
    +velocity: Vector
    -status: FishStatus
    +horizon_turn: boolean
    -move_com: any
    +visible: boolean
    +score: number
    -game: GameModel
    +event: EventCom
    +body: BodyCom
    -initCom(data: FishData): void
    +init(): void
    +setMoveCom(move_com: any): void
    -onMoveChange: (displace_info: DisplaceInfo) => void
    +setStatus(status: FishStatus): void
    +setVisible(visible: boolean): void
    +beCast(): void
    +beCapture(): Promise<any>
    +destroy(): void
}
class FishView extends Sprite {
    -fish_ani: Skeleton
    -shadow_node: Sprite
    +info: FishViewInfo
    -pool: Sprite
    -time_out: number
    -turn_ani: boolean
    -turn_ani_name: string
    -initAni(): void
    +playSwimAni(): void
    +stopSwimAni(): void
    +setVisible(visible: boolean): void
    +syncPos(pos: any, velocity: Vector, horizon_turn: boolean): void
    +beCastAni(): Promise<unknown>
    +destroy(): void
}
class default {
    -time_out: number
    +gun_skin: string
    -gun_direct: Vector
    +onEnable(): void
    -init(): void
    +setBulletCost(level_info: LevelInfo): void
    +fixServerTopPos(): void
    +setDirection(direction: Vector): void
    +fire(direction: Vector, nickname: string): void
    +addBullet(skin: string, rage: boolean): Skeleton
    +activePosTip(): void
    +stopPosTip(): void
    +setPos(x: number, y: number): void
}
class default {
    -cool_mask: Sprite
    -init(): void
    +setId(skill_id: string): void
    +setNum(num: number): void
    +highlight(): void
    +unHighlight(): void
    +showCoolTime(radio: number): void
}
class default implements HonorScene {
    +upside_down: boolean
    -fish_click_observer: Subscriber<string>
    +onResize(width: number, height: number): void
    +upSideDown(): void
    +addFish(info: FishViewInfo & { horizon_turn: boolean; }): FishView
    +addBullet(skin: string, rage?: boolean): Skeleton
    +addNet(skin: string): Sprite
    +onPoolClick(): Promise<any>
    +onFishClick(): Observable<string>
    +offFishClick(): void
    +addGun(): GunBoxView
    +setBulletNum(num: number): void
    +getSkillItemByIndex(index: number): SkillItemView
    +getAutoLaunchSkillItem(): Sprite
    +setExchangeRate(rate: number, currency: string): void
    +setEnergyRadio(radio: number): void
    +energyLight(): Promise<unknown>
    +setBulletBoxPos(pos: BulletBoxPos): void
    +getPoolMousePos(): Point
    +{static} preEnter(): Promise<GameView>
}
class default {
    +onResize(width: number, height: number): void
    +onEnable(): void
    +activeAni(type: string): void
    +setNickname(nickname_str: string): void
    +coinMenuRender(box: Box, index: number): void
    +setCoinData(data: AccountMap): void
    +setFlagData(data: string[]): void
    +toggleBalanceMenu(): void
    +setCurBalance(type: string, icon: string, num: number): void
    +toggleFlagMenu(): void
    +setFlag(type: string): void
    +destroy(): void
    +{static} preEnter(): Promise<void | Scene>
}
class default {
    +zOrder: number
    +onShow(): void
    +onHide(): void
    +onProgress(val: number): void
}
class default {
    +{static} preEnter(): Promise<void | Scene>
}
class default {
    +{static} width: number
    +{static} height: number
    +{static} scaleMode: string
    +{static} screenMode: string
    +{static} alignV: string
    +{static} alignH: string
    +{static} startScene: any
    +{static} sceneRoot: string
    +{static} debug: boolean
    +{static} stat: boolean
    +{static} physicsDebug: boolean
    +{static} exportSceneToJson: boolean
    +{static} init(): void
}
class default implements HonorDialog {
    +isModal: boolean
    +close_resolve: (type: CloseType) => void
    +onAwake(): void
    -initEvent(): void
    +alert(msg: string): Promise<CloseType>
    +close(type: CloseType): void
    +{static} alert(msg: string): Promise<CloseType>
}
class default implements HonorDialog {
    +isModal: boolean
    +onMounted(): void
    +{static} preEnter(): void
}
class FishCtrl extends ComponentManager {
    -view: FishView
    -model: FishModel
    -init(): void
    -initEvent(): void
    +onBomb: (data: FishBombInfo) => void
    +setVisible: (visible: boolean) => void
    +syncPos: () => void
    +beCapture: (handler: any) => void
    +destroy(): void
}
class NetCtrl {
    -view: Skeleton
    -model: NetModel
    -init(): void
    -initEvent(): void
}
class BulletCtrl {
    -view: Skeleton
    -model: BulletModel
    -init(): void
    -initView(): void
    -initEvent(): void
    -syncPos: () => void
    -rage: () => void
}
class SkillCtrl {
    -is_cur_player: boolean
    -view: SkillItemView
    -model: SkillModel
    -initEvent(): void
    -setInfo(): void
}
class PlayerCtrl {
    -view: GunBoxView
    -model: PlayerModel
    -init(): void
    -initGun(): void
    -initEvent(): void
    -handleAutoLaunch(model: AutoLaunchModel, view: Sprite): void
    -sendChangeBulletCost(type: "add" | "minus"): void
    +destroy(): void
}
class default {
    -view: ProgressUI
    -on_progress: OnProgressChange
    -radio: number
    -initEvent(): void
    -onClick(e: Event): void
    -onMouseMove(e: Event): void
    -onMouseOut(e: Event): void
    +setProgress(radio: number): void
    +destroy(): void
}
class default implements HonorDialog {
    +isModal: boolean
    -music_ctrl: ProgressCtrl
    -voice_ctrl: ProgressCtrl
    +onAwake(): void
    -onMusicChange: (radio: number) => void
    -onVoiceChange: (radio: number) => void
    +destroy(): void
    +{static} preEnter(): void
}
class GameCtrl {
    +view: GameView
    -model: GameModel
    -init(url: string): void
    -initEvent(): void
    -onModel(): void
    +onEnterGame(data: { exchange_rate: any; fish: any; users: PlayerInfo[]; frozen: any; frozen_left: number; fish_list: string[]; }): void
    +onShoot(data: any): void
    +onHit(data: any): void
    +shoalComingTip(reverse: boolean): void
    +resetSkill(skill: SkillMap, user_id: string): void
    +activeSkill(skill: SkillMap, data: any): void
    +addFish(fish_list: any[]): void
    +addPlayers(player_list: PlayerInfo[]): void
    +changeBulletCost(data: any): void
    +changeSkin(skinId: string): void
    +tableOut(data: any): void
    +roomOut(data: any): void
    +destroy(): void
    +{static} preEnter(url: string, game_model: GameModel): Promise<void>
}
class HallCtrl {
    +view: HallView
    -init(): Promise<void>
    -initModelEvent(): void
    +selectCoin: (index: number) => void
    +selectFlag: (index: number) => void
    +onUserAccount(data: any): void
    +destroy(): void
    +{static} preEnter(): Promise<void>
}
class AppCtrl {
    +model: AppModel
    +startApp(): Promise<void>
    -startHonor(): Promise<void>
    +enterGame(url: string): Promise<void>
}
@enduml