modern-canvas 0.8.9 → 0.9.0

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { Font } from 'modern-font';
-import { EventListenerOptions as EventListenerOptions$1, EventListenerValue, EventEmitter, PropertyDeclaration, ReactiveObject, ReactiveObjectPropertyAccessorContext, Color as Color$1, RawWeakMap as RawWeakMap$1, LinearGradient, RadialGradient, NormalizedFill, Fill, NormalizedBackground, Background, NormalizedForeground, Foreground, NormalizedOutline, Outline, NormalizedShadow, Shadow, NormalizedShape, Shape, FullStyle, Text as Text$1, TextContent, Style, ImageFillCropRect } from 'modern-idoc';
+import { ObservableEvents, Observable, ReactivableEvents, Reactivable, Color as Color$1, RawWeakMap as RawWeakMap$1, LinearGradient, RadialGradient, NormalizedFill, Fill, NormalizedBackground, Background, NormalizedForeground, Foreground, NormalizedOutline, Outline, NormalizedShadow, Shadow, NormalizedShape, Shape, FullStyle, Text as Text$1, TextContent, Style, ImageFillCropRect } from 'modern-idoc';
 export { Color as ColorValue } from 'modern-idoc';
 import { AnimationItem } from 'lottie-web';
 import { Colord, RgbaColor, HslaColor, HsvaColor } from 'colord';
@@ -190,7 +190,7 @@ declare class WheelInputEvent extends MouseInputEvent implements WheelEvent {
     readonly DOM_DELTA_PAGE = 2;
 }
 
-interface InputEventMap {
+interface InputEvents extends ObservableEvents {
     pointerdown: (ev: PointerInputEvent) => void;
     pointerover: (ev: PointerInputEvent) => void;
     pointermove: (ev: PointerInputEvent) => void;
@@ -200,14 +200,14 @@ interface InputEventMap {
     keypress: (ev: KeyboardInputEvent) => void;
     keyup: (ev: KeyboardInputEvent) => void;
 }
-type InputEventKey = keyof InputEventMap;
+type InputEventKey = keyof InputEvents;
 interface Input {
-    on: (<K extends keyof InputEventMap>(type: K, listener: InputEventMap[K], options?: EventListenerOptions$1) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions$1) => this);
-    once: (<K extends keyof InputEventMap>(type: K, listener: InputEventMap[K], options?: EventListenerOptions$1) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions$1) => this);
-    off: (<K extends keyof InputEventMap>(type: K, listener?: InputEventMap[K], options?: EventListenerOptions$1) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions$1) => this);
-    emit: (<K extends keyof InputEventMap>(type: K, ...args: Parameters<InputEventMap[K]>) => boolean) & ((type: string, ...args: any[]) => boolean);
+    on: <K extends keyof InputEvents & string>(event: K, listener: InputEvents[K]) => this;
+    once: <K extends keyof InputEvents & string>(event: K, listener: InputEvents[K]) => this;
+    off: <K extends keyof InputEvents & string>(event: K, listener: InputEvents[K]) => this;
+    emit: <K extends keyof InputEvents & string>(event: K, ...args: Parameters<InputEvents[K]>) => this;
 }
-declare class Input extends EventEmitter {
+declare class Input extends Observable {
     /**
      * Current event
      */
@@ -245,68 +245,38 @@ declare class Input extends EventEmitter {
     protected _onWheel: (nativeEvent: WheelEvent) => void;
 }
 
-interface CoreObjectEventMap {
-    updateProperty: (key: string, newValue: any, oldValue: any, declaration?: PropertyDeclaration) => void;
-}
-interface CustomPropertyAccessor {
-    get: (key: string, fallback: () => any) => any;
-    set: (key: string, value: any) => void;
+interface CoreObjectEvents extends ReactivableEvents {
 }
 interface CoreObject {
-    on: (<K extends keyof CoreObjectEventMap>(type: K, listener: CoreObjectEventMap[K], options?: EventListenerOptions$1) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions$1) => this);
-    once: (<K extends keyof CoreObjectEventMap>(type: K, listener: CoreObjectEventMap[K], options?: EventListenerOptions$1) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions$1) => this);
-    off: (<K extends keyof CoreObjectEventMap>(type: K, listener?: CoreObjectEventMap[K], options?: EventListenerOptions$1) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions$1) => this);
-    emit: (<K extends keyof CoreObjectEventMap>(type: K, ...args: Parameters<CoreObjectEventMap[K]>) => boolean) & ((type: string, ...args: any[]) => boolean);
+    on: <K extends keyof CoreObjectEvents & string>(event: K, listener: CoreObjectEvents[K]) => this;
+    once: <K extends keyof CoreObjectEvents & string>(event: K, listener: CoreObjectEvents[K]) => this;
+    off: <K extends keyof CoreObjectEvents & string>(event: K, listener: CoreObjectEvents[K]) => this;
+    emit: <K extends keyof CoreObjectEvents & string>(event: K, ...args: Parameters<CoreObjectEvents[K]>) => this;
 }
-declare class CoreObject extends EventEmitter implements Required<ReactiveObject> {
+declare class CoreObject extends Reactivable {
     readonly instanceId: number;
-    protected _propertyAccessor?: CustomPropertyAccessor;
-    protected _properties: Map<string, unknown>;
-    protected _updatedProperties: Map<string, unknown>;
-    protected _changedProperties: Set<string>;
-    protected _updatingPromise: Promise<void>;
-    protected _updating: boolean;
-    useCustomPropertyAccessor(accessor: CustomPropertyAccessor): this;
-    getter(key: string, context?: ReactiveObjectPropertyAccessorContext): any;
-    setter(key: string, value: any, context?: ReactiveObjectPropertyAccessorContext): void;
+    protected _nextTick(): Promise<void>;
     equal(target: CoreObject | undefined | null): boolean;
-    protected _enqueueUpdate(): Promise<void>;
-    update(): void;
-    protected _update(changed: Map<string, any>): void;
-    protected _updateProperty(key: string, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
-    isDirty(key: string): boolean;
-    getPropertyDeclarations(): Map<string, PropertyDeclaration>;
-    getPropertyDeclaration(key: string): PropertyDeclaration | undefined;
-    getProperty(key: string): any | undefined;
-    setProperty(key: string, value: any): this;
-    getProperties(keys?: string[]): Record<string, any>;
-    setProperties(properties?: any): this;
-    resetProperties(): this;
-    onUpdateProperty(key: string, newValue: unknown, oldValue: unknown, declaration: PropertyDeclaration): void;
-    requestUpdate(key?: string, newValue?: unknown, oldValue?: unknown, declaration?: PropertyDeclaration): void;
-    toJSON(): Record<string, any>;
-    clone(): this;
-    free(): void;
 }
 
-interface RefCountedEventMap extends CoreObjectEventMap {
+interface RefCountedEvents extends CoreObjectEvents {
 }
 interface RefCounted {
-    on: (<K extends keyof RefCountedEventMap>(type: K, listener: RefCountedEventMap[K], options?: EventListenerOptions$1) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions$1) => this);
-    once: (<K extends keyof RefCountedEventMap>(type: K, listener: RefCountedEventMap[K], options?: EventListenerOptions$1) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions$1) => this);
-    off: (<K extends keyof RefCountedEventMap>(type: K, listener?: RefCountedEventMap[K], options?: EventListenerOptions$1) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions$1) => this);
-    emit: (<K extends keyof RefCountedEventMap>(type: K, ...args: Parameters<RefCountedEventMap[K]>) => boolean) & ((type: string, ...args: any[]) => boolean);
+    on: <K extends keyof RefCountedEvents & string>(event: K, listener: RefCountedEvents[K]) => this;
+    once: <K extends keyof RefCountedEvents & string>(event: K, listener: RefCountedEvents[K]) => this;
+    off: <K extends keyof RefCountedEvents & string>(event: K, listener: RefCountedEvents[K]) => this;
+    emit: <K extends keyof RefCountedEvents & string>(event: K, ...args: Parameters<RefCountedEvents[K]>) => this;
 }
 declare class RefCounted extends CoreObject {
 }
 
-interface ResourceEventMap extends RefCountedEventMap {
+interface ResourceEvents extends RefCountedEvents {
 }
 interface Resource {
-    on: (<K extends keyof ResourceEventMap>(type: K, listener: ResourceEventMap[K], options?: EventListenerOptions$1) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions$1) => this);
-    once: (<K extends keyof ResourceEventMap>(type: K, listener: ResourceEventMap[K], options?: EventListenerOptions$1) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions$1) => this);
-    off: (<K extends keyof ResourceEventMap>(type: K, listener?: ResourceEventMap[K], options?: EventListenerOptions$1) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions$1) => this);
-    emit: (<K extends keyof ResourceEventMap>(type: K, ...args: Parameters<ResourceEventMap[K]>) => boolean) & ((type: string, ...args: any[]) => boolean);
+    on: <K extends keyof ResourceEvents & string>(event: K, listener: ResourceEvents[K]) => this;
+    once: <K extends keyof ResourceEvents & string>(event: K, listener: ResourceEvents[K]) => this;
+    off: <K extends keyof ResourceEvents & string>(event: K, listener: ResourceEvents[K]) => this;
+    emit: <K extends keyof ResourceEvents & string>(event: K, ...args: Parameters<ResourceEvents[K]>) => this;
 }
 declare class Resource extends RefCounted {
 }
@@ -341,7 +311,7 @@ declare class Color {
 
 type VectorLike = number | number[] | Matrix | Vector;
 type VectorOperateOutput = number[] | Vector;
-declare abstract class Vector extends EventEmitter {
+declare abstract class Vector extends Observable {
     readonly dim: number;
     protected _array: number[];
     get length(): number;
@@ -364,7 +334,7 @@ declare abstract class Vector extends EventEmitter {
 
 type MatrixLike = number | number[] | Matrix;
 type MatrixOperateOutput = number[] | Matrix | Vector;
-declare abstract class Matrix extends EventEmitter {
+declare abstract class Matrix extends Observable {
     readonly rows: number;
     readonly cols: number;
     protected _array: number[];
@@ -610,27 +580,28 @@ declare class Vector3 extends Vector {
     constructor();
 }
 
-interface MainLoopEventMap extends CoreObjectEventMap {
+interface MainLoopEvents extends CoreObjectEvents {
     process: (delta: number) => void;
 }
 interface MainLoop {
-    on: (<K extends keyof MainLoopEventMap>(type: K, listener: MainLoopEventMap[K], options?: EventListenerOptions$1) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions$1) => this);
-    once: (<K extends keyof MainLoopEventMap>(type: K, listener: MainLoopEventMap[K], options?: EventListenerOptions$1) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions$1) => this);
-    off: (<K extends keyof MainLoopEventMap>(type: K, listener?: MainLoopEventMap[K], options?: EventListenerOptions$1) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions$1) => this);
-    emit: (<K extends keyof EventListenerOptions$1>(type: K, ...args: Parameters<EventListenerOptions$1[K]>) => boolean) & ((type: string, ...args: any[]) => boolean);
+    on: <K extends keyof MainLoopEvents & string>(event: K, listener: MainLoopEvents[K]) => this;
+    once: <K extends keyof MainLoopEvents & string>(event: K, listener: MainLoopEvents[K]) => this;
+    off: <K extends keyof MainLoopEvents & string>(event: K, listener: MainLoopEvents[K]) => this;
+    emit: <K extends keyof MainLoopEvents & string>(event: K, ...args: Parameters<MainLoopEvents[K]>) => this;
 }
 declare class MainLoop extends CoreObject {
     fps: number;
     speed: number;
     protected _starting: boolean;
     protected _nextDeltaTime: number;
+    protected _startedProcess?: (delta: number) => void;
     get starting(): boolean;
     get spf(): number;
     constructor();
     start(process: (delta: number) => void): void;
     stop(): void;
     protected _onNextTick(): void;
-    free(): void;
+    destroy(): void;
 }
 
 interface CssFunctionArg {
@@ -893,7 +864,7 @@ declare class WebGLRenderer extends Renderer {
     draw(options?: WebGLDrawOptions): void;
     reset(): void;
     flush(): void;
-    free(): void;
+    destroy(): void;
     toPixels(x?: number, y?: number, width?: number, height?: number): Uint8ClampedArray<ArrayBuffer>;
 }
 
@@ -929,7 +900,7 @@ declare abstract class WebGLModule {
     onUpdateContext(): void;
     flush(): void;
     reset(): void;
-    free(): void;
+    destroy(): void;
 }
 
 interface WebGLState {
@@ -1117,7 +1088,7 @@ declare class WebGLProgramModule extends WebGLModule {
     updateUniforms(program: WebGLProgram, uniforms: Record<string, any>): void;
     updateUniforms(uniforms: Record<string, any>): void;
     reset(): void;
-    free(): void;
+    destroy(): void;
 }
 
 declare class WebGLScissorModule extends WebGLModule {
@@ -1200,11 +1171,11 @@ declare class Material extends Resource {
 }
 
 interface IndexBufferOptions {
-    data?: Uint16Array | null;
+    data?: Uint16Array<ArrayBuffer> | null;
     dynamic?: boolean;
 }
 declare class IndexBuffer extends Resource {
-    data: Uint16Array | null;
+    data: Uint16Array<ArrayBuffer> | null;
     dynamic: boolean;
     needsUpload: boolean;
     constructor(options?: IndexBufferOptions);
@@ -1212,7 +1183,7 @@ declare class IndexBuffer extends Resource {
     _glBufferOptions(): WebGLBufferOptions;
     /** @internal */
     _glBuffer(renderer: WebGLRenderer): WebGLBuffer;
-    protected _updateProperty(key: string, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
+    protected _updateProperty(key: string, value: any, oldValue: any): void;
     upload(renderer: WebGLRenderer): boolean;
 }
 
@@ -1229,7 +1200,7 @@ declare class VertexBuffer extends Resource {
     _glBufferOptions(): WebGLBufferOptions;
     /** @internal */
     _glBuffer(renderer: WebGLRenderer): WebGLBuffer;
-    protected _updateProperty(key: string, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
+    protected _updateProperty(key: string, value: any, oldValue: any): void;
     upload(renderer: WebGLRenderer): boolean;
 }
 
@@ -1252,7 +1223,7 @@ declare class VertexAttribute extends Resource {
     divisor: number | undefined;
     needsUpload: boolean;
     constructor(options?: VertexAttributeOptions);
-    protected _updateProperty(key: string, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
+    protected _updateProperty(key: string, value: any, oldValue: any): void;
     upload(): boolean;
 }
 
@@ -1350,14 +1321,14 @@ declare class Texture2D<T extends Texture2DSource = Texture2DSource> extends Res
     _glTextureOptions(renderer: WebGLRenderer, options?: Partial<WebGLTextureOptions>): WebGLTextureOptions;
     /** @internal */
     _glTexture(renderer: WebGLRenderer, options?: Partial<WebGLTextureOptions>): WebGLTexture;
-    protected _updateProperty(key: string, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
+    protected _updateProperty(key: string, value: any, oldValue: any): void;
     protected _updatePOT(): void;
     protected _updateSize(): void;
     requestUpload(): void;
     upload(renderer: WebGLRenderer, options?: Partial<WebGLTextureOptions>): boolean;
     activate(renderer: WebGLRenderer, location?: number): boolean;
     inactivate(renderer: WebGLRenderer): void;
-    free(): void;
+    destroy(): void;
 }
 
 interface ImageFrame {
@@ -1369,13 +1340,13 @@ declare class AnimatedTexture extends Resource {
     duration: number;
     constructor(source: Texture2D | ImageFrame[]);
     updateDuration(): this;
-    free(): void;
+    destroy(): void;
 }
 
 declare class CanvasTexture extends Texture2D<HTMLCanvasElement> {
     pixelRatio: number;
     constructor(source?: HTMLCanvasElement);
-    protected _updateProperty(key: string, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
+    protected _updateProperty(key: string, value: any, oldValue: any): void;
 }
 
 declare class ColorTexture extends Texture2D {
@@ -1411,7 +1382,7 @@ declare class ImageTexture extends Texture2D<HTMLImageElement> {
 
 declare class PixelsTexture extends Texture2D<Texture2DPixelsSource> {
     constructor(pixels?: number[] | ArrayBufferLike | ArrayBufferView | null, width?: number, height?: number);
-    protected _updateProperty(key: string, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
+    protected _updateProperty(key: string, value: any, oldValue: any): void;
 }
 
 interface VideoTextureOptions {
@@ -1446,7 +1417,7 @@ declare class VideoTexture extends Texture2D<HTMLVideoElement> {
     protected _resolve?: (val: this) => void;
     protected _reject?: (event: ErrorEvent) => void;
     constructor(source: HTMLVideoElement | (string | VideoTextureSource)[] | string, options?: VideoTextureOptions);
-    protected _updateProperty(key: string, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
+    protected _updateProperty(key: string, value: any, oldValue: any): void;
     protected _onPlayStart: () => void;
     protected _onPlayStop: () => void;
     protected _onCanPlay: () => void;
@@ -1457,7 +1428,7 @@ declare class VideoTexture extends Texture2D<HTMLVideoElement> {
     protected _videoFrameRequestCallback: () => void;
     requestUpload: () => void;
     load(): Promise<this>;
-    free(): void;
+    destroy(): void;
 }
 
 declare class ViewportTexture extends PixelsTexture {
@@ -1507,30 +1478,30 @@ declare class CanvasContext extends Path2D {
     toBatchables(): CanvasBatchable[];
 }
 
-interface RectangulableEventMap {
+interface RectangulableEvents {
     updateRect: () => void;
 }
 interface Rectangulable {
-    on: (<K extends keyof RectangulableEventMap>(type: K, listener: RectangulableEventMap[K], options?: EventListenerOptions$1) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions$1) => this);
-    once: (<K extends keyof RectangulableEventMap>(type: K, listener: RectangulableEventMap[K], options?: EventListenerOptions$1) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions$1) => this);
-    off: (<K extends keyof RectangulableEventMap>(type: K, listener?: RectangulableEventMap[K], options?: EventListenerOptions$1) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions$1) => this);
-    emit: (<K extends keyof RectangulableEventMap>(type: K, ...args: Parameters<RectangulableEventMap[K]>) => boolean) & ((type: string, ...args: any[]) => boolean);
+    on: <K extends keyof RectangulableEvents & string>(event: K, listener: RectangulableEvents[K]) => this;
+    once: <K extends keyof RectangulableEvents & string>(event: K, listener: RectangulableEvents[K]) => this;
+    off: <K extends keyof RectangulableEvents & string>(event: K, listener: RectangulableEvents[K]) => this;
+    emit: <K extends keyof RectangulableEvents & string>(event: K, ...args: Parameters<RectangulableEvents[K]>) => this;
 }
 interface Rectangulable {
     getRect: () => Rect2;
 }
 
-interface ViewportEventMap extends NodeEventMap, RectangulableEventMap {
+interface ViewportEvents extends NodeEvents, RectangulableEvents {
 }
 interface ViewportFramebuffer {
     texture: ViewportTexture;
     needsUpload: boolean;
 }
 interface Viewport {
-    on: (<K extends keyof ViewportEventMap>(type: K, listener: ViewportEventMap[K], options?: EventListenerOptions$1) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions$1) => this);
-    once: (<K extends keyof ViewportEventMap>(type: K, listener: ViewportEventMap[K], options?: EventListenerOptions$1) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions$1) => this);
-    off: (<K extends keyof ViewportEventMap>(type: K, listener?: ViewportEventMap[K], options?: EventListenerOptions$1) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions$1) => this);
-    emit: (<K extends keyof ViewportEventMap>(type: K, ...args: Parameters<ViewportEventMap[K]>) => boolean) & ((type: string, ...args: any[]) => boolean);
+    on: <K extends keyof ViewportEvents & string>(event: K, listener: ViewportEvents[K]) => this;
+    once: <K extends keyof ViewportEvents & string>(event: K, listener: ViewportEvents[K]) => this;
+    off: <K extends keyof ViewportEvents & string>(event: K, listener: ViewportEvents[K]) => this;
+    emit: <K extends keyof ViewportEvents & string>(event: K, ...args: Parameters<ViewportEvents[K]>) => this;
 }
 declare class Viewport extends Node implements Rectangulable {
     flipY: boolean;
@@ -1551,7 +1522,7 @@ declare class Viewport extends Node implements Rectangulable {
     _glFramebufferOptions(renderer: WebGLRenderer): WebGLFramebufferOptions;
     /** @internal */
     _glFramebuffer(renderer: WebGLRenderer): WebGLFramebuffer;
-    protected _updateProperty(key: string, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
+    protected _updateProperty(key: string, value: any, oldValue: any): void;
     requestUpload(): void;
     resize(width: number, height: number): void;
     upload(renderer: WebGLRenderer): boolean;
@@ -1578,7 +1549,7 @@ declare class RenderStack {
     render(renderer: WebGLRenderer): void;
 }
 
-interface TimelineEventMap extends NodeEventMap {
+interface TimelineEvents extends NodeEvents {
     updateCurrentTime: (current: number, delta: number) => void;
 }
 interface TimelineProperties extends NodeProperties {
@@ -1588,10 +1559,10 @@ interface TimelineProperties extends NodeProperties {
     loop: boolean;
 }
 interface Timeline {
-    on: (<K extends keyof TimelineEventMap>(type: K, listener: TimelineEventMap[K], options?: EventListenerOptions$1) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions$1) => this);
-    once: (<K extends keyof TimelineEventMap>(type: K, listener: TimelineEventMap[K], options?: EventListenerOptions$1) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions$1) => this);
-    off: (<K extends keyof TimelineEventMap>(type: K, listener?: TimelineEventMap[K], options?: EventListenerOptions$1) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions$1) => this);
-    emit: (<K extends keyof TimelineEventMap>(type: K, ...args: Parameters<TimelineEventMap[K]>) => boolean) & ((type: string, ...args: any[]) => boolean);
+    on: <K extends keyof TimelineEvents & string>(event: K, listener: TimelineEvents[K]) => this;
+    once: <K extends keyof TimelineEvents & string>(event: K, listener: TimelineEvents[K]) => this;
+    off: <K extends keyof TimelineEvents & string>(event: K, listener: TimelineEvents[K]) => this;
+    emit: <K extends keyof TimelineEvents & string>(event: K, ...args: Parameters<TimelineEvents[K]>) => this;
 }
 declare class Timeline extends Node {
     startTime: number;
@@ -1608,7 +1579,7 @@ declare class Timeline extends Node {
 declare class Window extends Viewport {
 }
 
-interface SceneTreeEventMap extends MainLoopEventMap {
+interface SceneTreeEvents extends MainLoopEvents {
     processing: () => void;
     processed: () => void;
     rendering: () => void;
@@ -1617,10 +1588,10 @@ interface SceneTreeEventMap extends MainLoopEventMap {
     nodeProcessed: (node: Node) => void;
 }
 interface SceneTree {
-    on: (<K extends keyof SceneTreeEventMap>(type: K, listener: SceneTreeEventMap[K], options?: EventListenerOptions$1) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions$1) => this);
-    once: (<K extends keyof SceneTreeEventMap>(type: K, listener: SceneTreeEventMap[K], options?: EventListenerOptions$1) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions$1) => this);
-    off: (<K extends keyof SceneTreeEventMap>(type: K, listener?: SceneTreeEventMap[K], options?: EventListenerOptions$1) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions$1) => this);
-    emit: (<K extends keyof SceneTreeEventMap>(type: K, ...args: Parameters<SceneTreeEventMap[K]>) => boolean) & ((type: string, ...args: any[]) => boolean);
+    on: <K extends keyof SceneTreeEvents & string>(event: K, listener: SceneTreeEvents[K]) => this;
+    once: <K extends keyof SceneTreeEvents & string>(event: K, listener: SceneTreeEvents[K]) => this;
+    off: <K extends keyof SceneTreeEvents & string>(event: K, listener: SceneTreeEvents[K]) => this;
+    emit: <K extends keyof SceneTreeEvents & string>(event: K, ...args: Parameters<SceneTreeEvents[K]>) => this;
 }
 declare class SceneTree extends MainLoop {
     processPaused: boolean;
@@ -1635,25 +1606,26 @@ declare class SceneTree extends MainLoop {
     getCurrentViewport(): Viewport | undefined;
     setCurrentViewport(viewport: Viewport | undefined): void;
     constructor(timeline?: Timeline);
-    protected _updateProperty(key: string, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
+    protected _updateProperty(key: string, value: any, oldValue: any): void;
     log(...args: any[]): void;
     protected _process(delta?: number): void;
     protected _render(renderer: WebGLRenderer): void;
     protected _renderScreen(renderer: WebGLRenderer): void;
-    free(): void;
+    destroy(): void;
 }
 
-declare class Children<T extends Node = Node> extends Array<T> {
-    readonly front: T[];
-    readonly back: T[];
+declare class Children<T extends Node = Node> {
+    front: T[];
+    default: T[];
+    back: T[];
     get internal(): T[];
     constructor(...items: T[]);
     set(items: T[]): this;
-    getInternal(includeInternal: InternalMode): T[];
+    getInternal(includeInternal?: InternalMode): T[];
     toJSON(): T[];
 }
 
-interface NodeEventMap extends CoreObjectEventMap, InputEventMap {
+interface NodeEvents extends CoreObjectEvents, InputEvents {
     treeEnter: (tree: SceneTree) => void;
     treeEntered: (tree: SceneTree) => void;
     treePostEnter: (tree: SceneTree) => void;
@@ -1688,10 +1660,10 @@ interface NodeProperties {
     meta: Record<string, any>;
 }
 interface Node {
-    on: (<K extends keyof NodeEventMap>(type: K, listener: NodeEventMap[K], options?: EventListenerOptions$1) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions$1) => this);
-    once: (<K extends keyof NodeEventMap>(type: K, listener?: NodeEventMap[K], options?: EventListenerOptions$1) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions$1) => this);
-    off: (<K extends keyof NodeEventMap>(type: K, listener: NodeEventMap[K], options?: EventListenerOptions$1) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions$1) => this);
-    emit: (<K extends keyof NodeEventMap>(type: K, ...args: Parameters<NodeEventMap[K]>) => boolean) & ((type: string, ...args: any[]) => boolean);
+    on: <K extends keyof NodeEvents & string>(event: K, listener: NodeEvents[K]) => this;
+    once: <K extends keyof NodeEvents & string>(event: K, listener: NodeEvents[K]) => this;
+    off: <K extends keyof NodeEvents & string>(event: K, listener: NodeEvents[K]) => this;
+    emit: <K extends keyof NodeEvents & string>(event: K, ...args: Parameters<NodeEvents[K]>) => this;
 }
 declare class Node extends CoreObject {
     readonly is: string;
@@ -1729,8 +1701,9 @@ declare class Node extends CoreObject {
     setParent<T extends Node = Node>(parent: T | undefined): this;
     /** Children */
     protected _children: Children<Node>;
-    get children(): Children;
-    set children(value: Node[] | Children);
+    get children(): Node[];
+    set children(value: Node[]);
+    getChildren(internalMode?: InternalMode | true): Node[];
     getChild<T extends Node = Node>(index?: number): T | undefined;
     get siblingIndex(): number;
     set siblingIndex(toIndex: number);
@@ -1741,7 +1714,6 @@ declare class Node extends CoreObject {
     canProcess(): boolean;
     canInput(): boolean;
     canRender(): boolean;
-    protected _updateProperty(key: string, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
     protected _onTreeEnter(tree: SceneTree): void;
     protected _onTreeExit(oldTree: SceneTree): void;
     protected _onParented(parent: Node): void;
@@ -1780,6 +1752,7 @@ declare class Node extends CoreObject {
     protected _process(delta: number): void;
     protected _input(event: InputEvent, key: InputEventKey): void;
     protected _render(renderer: WebGLRenderer): void;
+    destroy(): void;
     clone(): this;
     toJSON(): Record<string, any>;
     static parse(value: any): any;
@@ -1790,14 +1763,14 @@ interface TimelineNodeProperties extends NodeProperties {
     duration: number;
     paused: boolean;
 }
-interface TimelineNodeEventMap extends NodeEventMap {
+interface TimelineNodeEvents extends NodeEvents {
     updateCurrentTime: (currentTime: number) => void;
 }
 interface TimelineNode {
-    on: (<K extends keyof TimelineNodeEventMap>(type: K, listener: TimelineNodeEventMap[K], options?: EventListenerOptions$1) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions$1) => this);
-    once: (<K extends keyof TimelineNodeEventMap>(type: K, listener: TimelineNodeEventMap[K], options?: EventListenerOptions$1) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions$1) => this);
-    off: (<K extends keyof TimelineNodeEventMap>(type: K, listener?: TimelineNodeEventMap[K], options?: EventListenerOptions$1) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions$1) => this);
-    emit: (<K extends keyof TimelineNodeEventMap>(type: K, ...args: Parameters<TimelineNodeEventMap[K]>) => boolean) & ((type: string, ...args: any[]) => boolean);
+    on: <K extends keyof TimelineNodeEvents & string>(event: K, listener: TimelineNodeEvents[K]) => this;
+    once: <K extends keyof TimelineNodeEvents & string>(event: K, listener: TimelineNodeEvents[K]) => this;
+    off: <K extends keyof TimelineNodeEvents & string>(event: K, listener: TimelineNodeEvents[K]) => this;
+    emit: <K extends keyof TimelineNodeEvents & string>(event: K, ...args: Parameters<TimelineNodeEvents[K]>) => this;
 }
 declare class TimelineNode extends Node {
     delay: number;
@@ -1826,14 +1799,14 @@ interface CanvasItemProperties extends TimelineNodeProperties {
     modulate: Color$1;
     blendMode: WebGLBlendMode;
 }
-interface CanvasItemEventMap extends TimelineNodeEventMap {
+interface CanvasItemEvents extends TimelineNodeEvents {
     draw: () => void;
 }
 interface CanvasItem {
-    on: (<K extends keyof CanvasItemEventMap>(type: K, listener: CanvasItemEventMap[K], options?: EventListenerOptions$1) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions$1) => this);
-    once: (<K extends keyof CanvasItemEventMap>(type: K, listener: CanvasItemEventMap[K], options?: EventListenerOptions$1) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions$1) => this);
-    off: (<K extends keyof CanvasItemEventMap>(type: K, listener?: CanvasItemEventMap[K], options?: EventListenerOptions$1) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions$1) => this);
-    emit: (<K extends keyof CanvasItemEventMap>(type: K, ...args: Parameters<CanvasItemEventMap[K]>) => boolean) & ((type: string, ...args: any[]) => boolean);
+    on: <K extends keyof CanvasItemEvents & string>(event: K, listener: CanvasItemEvents[K]) => this;
+    once: <K extends keyof CanvasItemEvents & string>(event: K, listener: CanvasItemEvents[K]) => this;
+    off: <K extends keyof CanvasItemEvents & string>(event: K, listener: CanvasItemEvents[K]) => this;
+    emit: <K extends keyof CanvasItemEvents & string>(event: K, ...args: Parameters<CanvasItemEvents[K]>) => this;
 }
 declare class CanvasItem extends TimelineNode {
     modulate: Color$1 | undefined;
@@ -1856,7 +1829,7 @@ declare class CanvasItem extends TimelineNode {
     protected _layoutedBatchables: CanvasBatchable[];
     protected _batchables: CanvasBatchable[];
     constructor(properties?: Partial<CanvasItemProperties>, nodes?: Node[]);
-    protected _updateProperty(key: string, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
+    protected _updateProperty(key: string, value: any, oldValue: any): void;
     show(): void;
     hide(): void;
     isVisibleInTree(): boolean;
@@ -1907,7 +1880,7 @@ declare class Effect extends TimelineNode {
     protected _previousSibling?: Node;
     protected _nextSibling?: Node;
     constructor(properties?: Partial<EffectProperties>, children?: Node[]);
-    protected _updateProperty(key: string, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
+    protected _updateProperty(key: string, value: any, oldValue: any): void;
     protected _treeEnter(tree: SceneTree): void;
     protected _treeExit(oldTree: SceneTree): void;
     protected _onProcessing(): void;
@@ -1931,13 +1904,13 @@ declare class Transition extends Effect {
 
 interface Node2DProperties extends CanvasItemProperties {
 }
-interface Node2DEventMap extends CanvasItemEventMap {
+interface Node2DEvents extends CanvasItemEvents {
 }
 interface Node2D {
-    on: (<K extends keyof Node2DEventMap>(type: K, listener: Node2DEventMap[K], options?: EventListenerOptions) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions) => this);
-    once: (<K extends keyof Node2DEventMap>(type: K, listener: Node2DEventMap[K], options?: EventListenerOptions) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions) => this);
-    off: (<K extends keyof Node2DEventMap>(type: K, listener?: Node2DEventMap[K], options?: EventListenerOptions) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions) => this);
-    emit: (<K extends keyof Node2DEventMap>(type: K, ...args: Parameters<Node2DEventMap[K]>) => boolean) & ((type: string, ...args: any[]) => boolean);
+    on: <K extends keyof Node2DEvents & string>(event: K, listener: Node2DEvents[K]) => this;
+    once: <K extends keyof Node2DEvents & string>(event: K, listener: Node2DEvents[K]) => this;
+    off: <K extends keyof Node2DEvents & string>(event: K, listener: Node2DEvents[K]) => this;
+    emit: <K extends keyof Node2DEvents & string>(event: K, ...args: Parameters<Node2DEvents[K]>) => this;
 }
 declare class Node2D extends CanvasItem {
     rotation: number;
@@ -1952,7 +1925,7 @@ declare class Node2D extends CanvasItem {
     readonly globalTransform: Transform2D;
     protected _parentTransformDirtyId?: number;
     constructor(properties?: Partial<Node2DProperties>, nodes?: Node[]);
-    protected _updateProperty(key: string, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
+    protected _updateProperty(key: string, value: any, oldValue: any): void;
     getTransformOrigin(): Vector2;
     updateTransform(cb?: (transform: Transform2D) => void): void;
     updateGlobalTransform(): void;
@@ -1965,14 +1938,14 @@ declare class Node2D extends CanvasItem {
 
 interface Camera2DProperties extends Node2DProperties {
 }
-interface Camera2DEventMap extends Node2DEventMap {
+interface Camera2DEvents extends Node2DEvents {
     updateCanvasTransform: () => void;
 }
 interface Camera2D {
-    on: (<K extends keyof Camera2DEventMap>(type: K, listener: Camera2DEventMap[K], options?: EventListenerOptions) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions) => this);
-    once: (<K extends keyof Camera2DEventMap>(type: K, listener: Camera2DEventMap[K], options?: EventListenerOptions) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions) => this);
-    off: (<K extends keyof Camera2DEventMap>(type: K, listener?: Camera2DEventMap[K], options?: EventListenerOptions) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions) => this);
-    emit: (<K extends keyof Camera2DEventMap>(type: K, ...args: Parameters<Camera2DEventMap[K]>) => boolean) & ((type: string, ...args: any[]) => boolean);
+    on: <K extends keyof Camera2DEvents & string>(event: K, listener: Camera2DEvents[K]) => this;
+    once: <K extends keyof Camera2DEvents & string>(event: K, listener: Camera2DEvents[K]) => this;
+    off: <K extends keyof Camera2DEvents & string>(event: K, listener: Camera2DEvents[K]) => this;
+    emit: <K extends keyof Camera2DEvents & string>(event: K, ...args: Parameters<Camera2DEvents[K]>) => this;
 }
 declare class Camera2D extends Node2D {
     readonly zoom: Vector2;
@@ -2014,7 +1987,7 @@ declare class BaseElement2DFill extends CoreObject {
     constructor(parent: BaseElement2D);
     protected _setProperties(properties?: Fill): this;
     setProperties(properties?: Fill): this;
-    protected _updateProperty(key: string, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
+    protected _updateProperty(key: string, value: any, oldValue: any): void;
     loadTexture(): Promise<Texture2D | undefined>;
     protected _updateTexture(): Promise<void>;
     canDraw(): boolean;
@@ -2024,13 +1997,13 @@ declare class BaseElement2DFill extends CoreObject {
 declare class BaseElement2DBackground extends BaseElement2DFill {
     fillWithShape: NormalizedBackground['fillWithShape'];
     setProperties(properties?: Background): this;
-    protected _updateProperty(key: string, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
+    protected _updateProperty(key: string, value: any, oldValue: any): void;
 }
 
 declare class BaseElement2DForeground extends BaseElement2DFill {
     fillWithShape: NormalizedForeground['fillWithShape'];
     setProperties(properties?: Foreground): this;
-    protected _updateProperty(key: string, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
+    protected _updateProperty(key: string, value: any, oldValue: any): void;
 }
 
 declare class BaseElement2DOutline extends BaseElement2DFill {
@@ -2040,7 +2013,7 @@ declare class BaseElement2DOutline extends BaseElement2DFill {
     lineCap: NormalizedOutline['lineCap'];
     lineJoin: NormalizedOutline['lineJoin'];
     setProperties(properties?: Outline): this;
-    protected _updateProperty(key: string, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
+    protected _updateProperty(key: string, value: any, oldValue: any): void;
     canDraw(): boolean;
     draw(): void;
 }
@@ -2054,7 +2027,7 @@ declare class BaseElement2DShadow extends CoreObject {
     offsetX: NormalizedShadow['offsetY'];
     constructor(parent: BaseElement2D);
     setProperties(properties?: Shadow): this;
-    protected _updateProperty(key: string, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
+    protected _updateProperty(key: string, value: any, oldValue: any): void;
     updateEffect(): void;
 }
 
@@ -2068,7 +2041,7 @@ declare class BaseElement2DShape extends CoreObject {
     protected _path2DSet: Path2DSet;
     constructor(parent: BaseElement2D);
     setProperties(properties?: Shape): this;
-    protected _updateProperty(key: string, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
+    protected _updateProperty(key: string, value: any, oldValue: any): void;
     protected _updatePath2DSet(): void;
     draw(): void;
     drawRect(): void;
@@ -2103,7 +2076,7 @@ declare class BaseElement2DText extends CoreObject {
     }>;
     constructor(parent: BaseElement2D);
     setProperties(properties?: Text$1): this;
-    protected _updateProperty(key: string, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
+    protected _updateProperty(key: string, value: any, oldValue: any): void;
     protected _update(): void;
     protected _updateTextureMap(): void;
     protected _updateTexture(key: string, fill: NormalizedFill | undefined, box: any): Promise<void>;
@@ -2116,8 +2089,8 @@ declare class BaseElement2DText extends CoreObject {
     draw(): void;
 }
 
-interface BaseElement2DEventMap extends CanvasItemEventMap {
-    updateStyleProperty: (key: string, value: any, oldValue: any, declaration?: PropertyDeclaration) => void;
+interface BaseElement2DEvents extends Node2DEvents {
+    updateStyleProperty: (key: string, value: any, oldValue: any) => void;
 }
 interface BaseElement2DProperties extends Node2DProperties {
     modulate: Color$1;
@@ -2132,10 +2105,10 @@ interface BaseElement2DProperties extends Node2DProperties {
     shadow: Shadow;
 }
 interface BaseElement2D {
-    on: (<K extends keyof BaseElement2DEventMap>(type: K, listener: BaseElement2DEventMap[K], options?: EventListenerOptions$1) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions$1) => this);
-    once: (<K extends keyof BaseElement2DEventMap>(type: K, listener: BaseElement2DEventMap[K], options?: EventListenerOptions$1) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions$1) => this);
-    off: (<K extends keyof BaseElement2DEventMap>(type: K, listener?: BaseElement2DEventMap[K], options?: EventListenerOptions$1) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions$1) => this);
-    emit: (<K extends keyof BaseElement2DEventMap>(type: K, ...args: Parameters<BaseElement2DEventMap[K]>) => boolean) & ((type: string, ...args: any[]) => boolean);
+    on: <K extends keyof BaseElement2DEvents & string>(event: K, listener: BaseElement2DEvents[K]) => this;
+    once: <K extends keyof BaseElement2DEvents & string>(event: K, listener: BaseElement2DEvents[K]) => this;
+    off: <K extends keyof BaseElement2DEvents & string>(event: K, listener: BaseElement2DEvents[K]) => this;
+    emit: <K extends keyof BaseElement2DEvents & string>(event: K, ...args: Parameters<BaseElement2DEvents[K]>) => this;
 }
 declare class BaseElement2D extends Node2D implements Rectangulable {
     readonly size: Vector2;
@@ -2165,7 +2138,7 @@ declare class BaseElement2D extends Node2D implements Rectangulable {
     set shadow(value: Shadow);
     constructor(properties?: Partial<BaseElement2DProperties>, nodes?: Node[]);
     setProperties(properties?: Record<string, any>): this;
-    protected _updateStyleProperty(key: string, value: any, oldValue: any, _declaration?: PropertyDeclaration): void;
+    protected _updateStyleProperty(key: string, value: any, oldValue: any): void;
     protected _updateMaskImage(): void;
     getTransformOrigin(): Vector2;
     updateTransform(cb?: (transform: Transform2D) => void): void;
@@ -2213,23 +2186,23 @@ declare class FlexElement2DStyle extends BaseElement2DStyle {
     constructor(properties?: Partial<FlexElement2DStyleProperties>);
 }
 
-interface Element2DEventMap extends BaseElement2DEventMap {
+interface Element2DEvents extends BaseElement2DEvents {
 }
 interface Element2DProperties extends BaseElement2DProperties {
     style: Partial<Element2DStyleProperties>;
 }
 interface Element2D {
-    on: (<K extends keyof Element2DEventMap>(type: K, listener: Element2DEventMap[K], options?: EventListenerOptions$1) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions$1) => this);
-    once: (<K extends keyof Element2DEventMap>(type: K, listener: Element2DEventMap[K], options?: EventListenerOptions$1) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions$1) => this);
-    off: (<K extends keyof Element2DEventMap>(type: K, listener?: Element2DEventMap[K], options?: EventListenerOptions$1) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions$1) => this);
-    emit: (<K extends keyof Element2DEventMap>(type: K, ...args: Parameters<Element2DEventMap[K]>) => boolean) & ((type: string, ...args: any[]) => boolean);
+    on: <K extends keyof Element2DEvents & string>(event: K, listener: Element2DEvents[K]) => this;
+    once: <K extends keyof Element2DEvents & string>(event: K, listener: Element2DEvents[K]) => this;
+    off: <K extends keyof Element2DEvents & string>(event: K, listener: Element2DEvents[K]) => this;
+    emit: <K extends keyof Element2DEvents & string>(event: K, ...args: Parameters<Element2DEvents[K]>) => this;
 }
 declare class Element2D extends BaseElement2D {
     protected _style: Element2DStyle;
     get style(): Element2DStyle;
     set style(style: Element2DStyle);
     constructor(properties?: Partial<Element2DProperties>, nodes?: Node[]);
-    protected _updateStyleProperty(key: string, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
+    protected _updateStyleProperty(key: string, value: any, oldValue: any): void;
 }
 
 declare const edgeMap: {
@@ -2323,20 +2296,20 @@ declare class FlexLayout {
     constructor(_element: FlexElement2D);
     calculateLayout(width?: number | 'auto', height?: number | 'auto', direction?: typeof displayMap[keyof typeof displayMap]): void;
     getComputedLayout(): ComputedLayout;
-    updateStyleProperty(key: string, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
+    updateStyleProperty(key: string, value: any, oldValue: any): void;
 }
 
-interface FlexBaseElement2DEventMap extends BaseElement2DEventMap {
-    updateStyleProperty: (key: string, value: any, oldValue: any, declaration?: PropertyDeclaration) => void;
+interface FlexBaseElement2DEvents extends BaseElement2DEvents {
+    updateStyleProperty: (key: string, value: any, oldValue: any) => void;
 }
 interface FlexElement2DProperties extends BaseElement2DProperties {
     style: Partial<FlexElement2DStyleProperties>;
 }
 interface FlexElement2D {
-    on: (<K extends keyof FlexBaseElement2DEventMap>(type: K, listener: FlexBaseElement2DEventMap[K], options?: EventListenerOptions$1) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions$1) => this);
-    once: (<K extends keyof FlexBaseElement2DEventMap>(type: K, listener: FlexBaseElement2DEventMap[K], options?: EventListenerOptions$1) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions$1) => this);
-    off: (<K extends keyof FlexBaseElement2DEventMap>(type: K, listener?: FlexBaseElement2DEventMap[K], options?: EventListenerOptions$1) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions$1) => this);
-    emit: (<K extends keyof FlexBaseElement2DEventMap>(type: K, ...args: Parameters<FlexBaseElement2DEventMap[K]>) => boolean) & ((type: string, ...args: any[]) => boolean);
+    on: <K extends keyof FlexBaseElement2DEvents & string>(event: K, listener: FlexBaseElement2DEvents[K]) => this;
+    once: <K extends keyof FlexBaseElement2DEvents & string>(event: K, listener: FlexBaseElement2DEvents[K]) => this;
+    off: <K extends keyof FlexBaseElement2DEvents & string>(event: K, listener: FlexBaseElement2DEvents[K]) => this;
+    emit: <K extends keyof FlexBaseElement2DEvents & string>(event: K, ...args: Parameters<FlexBaseElement2DEvents[K]>) => this;
 }
 declare class FlexElement2D extends BaseElement2D implements Rectangulable {
     protected _style: FlexElement2DStyle;
@@ -2350,7 +2323,7 @@ declare class FlexElement2D extends BaseElement2D implements Rectangulable {
     constructor(properties?: Partial<FlexElement2DProperties>, nodes?: Node[]);
     protected _parented(parent: Node): void;
     protected _unparented(oldParent: Node): void;
-    protected _updateStyleProperty(key: string, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
+    protected _updateStyleProperty(key: string, value: any, oldValue: any): void;
     updateTransform(): void;
     calculateLayout(width?: number | 'auto', height?: number | 'auto', direction?: typeof directionMap[keyof typeof directionMap]): void;
 }
@@ -2374,7 +2347,7 @@ declare class Image2D extends Element2D {
     protected _complete: boolean;
     protected _wait: Promise<void>;
     constructor(properties?: Partial<Image2DProperties>, children?: Node[]);
-    protected _updateProperty(key: string, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
+    protected _updateProperty(key: string, value: any, oldValue: any): void;
     decode(): Promise<void>;
     setResource(source: Texture2D | ImageFrame[] | AnimatedTexture): this;
     protected _load(src: string): Promise<void>;
@@ -2401,7 +2374,7 @@ declare class Lottie2D extends TextureRect2D {
     readonly texture: CanvasTexture;
     animation?: AnimationItem;
     constructor(properties?: Partial<Lottie2DProperties>, children?: Node[]);
-    protected _updateProperty(key: string, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
+    protected _updateProperty(key: string, value: any, oldValue: any): void;
     protected _updateStyleProperty(key: string, value: any, oldValue: any): void;
     protected _load(): Promise<void>;
     protected _process(delta: number): void;
@@ -2412,7 +2385,7 @@ interface TransformRect2DProperties extends BaseElement2DProperties {
 declare class TransformRect2D extends Element2D {
     handleSize: number;
     constructor(properties?: Partial<TransformRect2DProperties>, nodes?: Node[]);
-    protected _updateStyleProperty(key: string, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
+    protected _updateStyleProperty(key: string, value: any, oldValue: any): void;
     protected _drawCircle(x: number, y: number): void;
     protected _drawEllipse(x: number, y: number): void;
     protected _draw(): void;
@@ -2426,7 +2399,7 @@ declare class Video2D extends TextureRect2D<VideoTexture> {
     get videoDuration(): number;
     protected _wait: Promise<void>;
     constructor(properties?: Partial<Video2DProperties>, children?: Node[]);
-    protected _updateProperty(key: string, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
+    protected _updateProperty(key: string, value: any, oldValue: any): void;
     waitLoad(): Promise<void>;
     protected _load(src: string): Promise<void>;
     protected _updateVideoCurrentTime(): void;
@@ -2477,7 +2450,7 @@ declare class Animation extends TimelineNode {
     protected _parented(parent: Node): void;
     protected _unparented(oldParent: Node): void;
     protected _process(): void;
-    protected _updateProperty(key: string, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
+    protected _updateProperty(key: string, value: any, oldValue: any): void;
     protected _getTargets(): any[];
     protected _updateKeyframes(): void;
     commitStyles(): void;
@@ -2501,7 +2474,7 @@ declare abstract class AudioProcessor {
     disconnect(): void;
 }
 
-declare class AudioPipeline extends EventEmitter {
+declare class AudioPipeline extends Observable {
     protected _input: IAudioNode;
     protected _output: IAudioNode;
     protected _processers: AudioProcessor[];
@@ -2538,7 +2511,7 @@ interface IPlayOptions {
     multiple?: boolean;
 }
 
-declare class HTMLAudioContext extends EventEmitter implements IAudioContext {
+declare class HTMLAudioContext extends Observable implements IAudioContext {
     protected static _instance?: HTMLAudioContext;
     static get instance(): HTMLAudioContext;
     playbackRate: number;
@@ -2552,10 +2525,9 @@ declare class HTMLAudioContext extends EventEmitter implements IAudioContext {
     get audioContext(): AudioContext;
     toggleMute(): boolean;
     togglePause(): boolean;
-    free(): void;
 }
 
-declare class HTMLSound extends EventEmitter {
+declare class HTMLSound extends Observable {
     static readonly PADDING = 0.1;
     protected _source: HTMLAudioElement | null;
     protected _audio: HTMLAudio | null;
@@ -2598,7 +2570,7 @@ declare class HTMLSound extends EventEmitter {
     play(options?: IPlayOptions): void;
     protected _onUpdate: () => void;
     protected _onComplete(): void;
-    free(): void;
+    destroy(): void;
 }
 
 declare class HTMLAudio {
@@ -2654,7 +2626,7 @@ declare class WebAudioContext extends AudioPipeline implements IAudioContext {
     setParamValue(param: AudioParam, value: number): void;
 }
 
-declare class WebSound extends EventEmitter {
+declare class WebSound extends Observable {
     protected _audio: WebAudio | null;
     protected _sourceNode: AudioBufferSourceNode | null;
     protected _gain: GainNode | null;
@@ -2700,7 +2672,7 @@ declare class WebSound extends EventEmitter {
     protected _onComplete: () => void;
     protected _updateListener: () => void;
     protected _enableTicker(enabled: boolean): void;
-    free(): void;
+    destroy(): void;
 }
 
 declare class WebAudio extends AudioPipeline {
@@ -2767,7 +2739,7 @@ declare class Audio extends TimelineNode {
     start: number;
     end: number;
     constructor(src?: string);
-    protected _updateProperty(key: string, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
+    protected _updateProperty(key: string, value: any, oldValue: any): void;
     load(): Promise<this>;
     pause(): this;
     resume(): this;
@@ -2801,7 +2773,7 @@ declare class AudioWaveform extends Element2D {
     protected _src: Texture2D<HTMLCanvasElement> | undefined;
     protected _needsUpdateTexture: boolean;
     constructor(options?: Partial<AudioWaveformProperties>);
-    protected _updateProperty(key: string, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
+    protected _updateProperty(key: string, value: any, oldValue: any): void;
     _loadSrc(src: string): Promise<void>;
     syncTexture(force?: boolean): void;
     protected _process(delta: number): void;
@@ -2994,7 +2966,7 @@ declare class KawaseBlurEffect extends Effect {
     pixelSize: [number, number];
     protected _kernels: number[];
     constructor(properties?: Partial<KawaseBlurEffectProperties>, children?: Node[]);
-    protected _updateProperty(key: string, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
+    protected _updateProperty(key: string, value: any, oldValue: any): void;
     /** Auto generate kernels by blur & quality */
     protected _generateKernels(): void;
     apply(renderer: WebGLRenderer, source: Viewport): void;
@@ -3009,7 +2981,7 @@ declare class MaskEffect extends Effect {
     src: string;
     constructor(properties?: Partial<MaskEffectProperties>, children?: Node[]);
     load(): Promise<void>;
-    protected _updateProperty(key: string, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
+    protected _updateProperty(key: string, value: any, oldValue: any): void;
     apply(renderer: WebGLRenderer, source: Viewport, context: EffectContext): void;
 }
 
@@ -3064,15 +3036,15 @@ declare class ZoomBlurEffect extends Effect {
     apply(renderer: WebGLRenderer, source: Viewport, context: EffectContext): void;
 }
 
-interface ControlEventMap extends CanvasItemEventMap, RectangulableEventMap {
+interface ControlEvents extends CanvasItemEvents, RectangulableEvents {
 }
 interface ControlProperties extends BaseElement2DProperties {
 }
 interface Control {
-    on: (<K extends keyof ControlEventMap>(type: K, listener: ControlEventMap[K], options?: EventListenerOptions$1) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions$1) => this);
-    once: (<K extends keyof ControlEventMap>(type: K, listener: ControlEventMap[K], options?: EventListenerOptions$1) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions$1) => this);
-    off: (<K extends keyof ControlEventMap>(type: K, listener?: ControlEventMap[K], options?: EventListenerOptions$1) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions$1) => this);
-    emit: (<K extends keyof ControlEventMap>(type: K, ...args: Parameters<ControlEventMap[K]>) => boolean) & ((type: string, ...args: any[]) => boolean);
+    on: <K extends keyof ControlEvents & string>(event: K, listener: ControlEvents[K]) => this;
+    once: <K extends keyof ControlEvents & string>(event: K, listener: ControlEvents[K]) => this;
+    off: <K extends keyof ControlEvents & string>(event: K, listener: ControlEvents[K]) => this;
+    emit: <K extends keyof ControlEvents & string>(event: K, ...args: Parameters<ControlEvents[K]>) => this;
 }
 declare class Control extends Element2D implements Rectangulable {
     constructor(properties?: Partial<ControlProperties>, children?: Node[]);
@@ -3080,7 +3052,7 @@ declare class Control extends Element2D implements Rectangulable {
     protected _unparented(oldParent: any): void;
     protected _parentUpdateRect(): void;
     protected _input(event: InputEvent, key: InputEventKey): void;
-    protected _updateStyleProperty(key: string, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
+    protected _updateStyleProperty(key: string, value: any, oldValue: any): void;
     protected _guiInput(event: InputEvent, key: InputEventKey): void;
 }
 
@@ -3102,7 +3074,7 @@ declare class Range extends Control {
     step: number;
     value: number;
     constructor(properties?: Partial<RangeProperties>, children?: Node[]);
-    protected _updateProperty(key: string, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
+    protected _updateProperty(key: string, value: any, oldValue: any): void;
 }
 
 interface RulerProperties extends ControlProperties {
@@ -3128,8 +3100,8 @@ declare class Ruler extends Control {
     gapScale: number;
     texture: CanvasTexture;
     constructor(properties?: Partial<RulerProperties>, children?: Node[]);
-    protected _updateProperty(key: string, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
-    protected _updateStyleProperty(key: string, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
+    protected _updateProperty(key: string, value: any, oldValue: any): void;
+    protected _updateStyleProperty(key: string, value: any, oldValue: any): void;
     protected _drawTexture(): void;
     protected _draw(): void;
 }
@@ -3140,7 +3112,7 @@ interface ScrollBarProperties extends RangeProperties {
 declare class ScrollBar extends Range {
     direction: 'vertical' | 'horizontal';
     constructor(properties?: Partial<ScrollBarProperties>, children?: Node[]);
-    protected _updateStyleProperty(key: string, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
+    protected _updateStyleProperty(key: string, value: any, oldValue: any): void;
     protected _rect(): {
         left: number;
         top: number;
@@ -3167,7 +3139,7 @@ declare class YScrollBar extends ScrollBar {
     constructor(properties?: Partial<YScrollBarProperties>, children?: Node[]);
 }
 
-interface ScalerEventMap extends NodeEventMap {
+interface ScalerEvents extends NodeEvents {
     updateScale: (scale: number) => void;
 }
 interface ScalerProperties extends NodeProperties {
@@ -3176,10 +3148,10 @@ interface ScalerProperties extends NodeProperties {
     maxScale: number;
 }
 interface Scaler {
-    on: (<K extends keyof ScalerEventMap>(type: K, listener: ScalerEventMap[K], options?: EventListenerOptions$1) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions$1) => this);
-    once: (<K extends keyof ScalerEventMap>(type: K, listener: ScalerEventMap[K], options?: EventListenerOptions$1) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions$1) => this);
-    off: (<K extends keyof ScalerEventMap>(type: K, listener?: ScalerEventMap[K], options?: EventListenerOptions$1) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions$1) => this);
-    emit: (<K extends keyof ScalerEventMap>(type: K, ...args: Parameters<ScalerEventMap[K]>) => boolean) & ((type: string, ...args: any[]) => boolean);
+    on: <K extends keyof ScalerEvents & string>(event: K, listener: ScalerEvents[K]) => this;
+    once: <K extends keyof ScalerEvents & string>(event: K, listener: ScalerEvents[K]) => this;
+    off: <K extends keyof ScalerEvents & string>(event: K, listener: ScalerEvents[K]) => this;
+    emit: <K extends keyof ScalerEvents & string>(event: K, ...args: Parameters<ScalerEvents[K]>) => this;
 }
 declare class Scaler extends Node {
     translateX: number;
@@ -3189,7 +3161,7 @@ declare class Scaler extends Node {
     maxScale: number;
     get target(): Element2D | undefined;
     constructor(properties?: Partial<ScalerProperties>, children?: Node[]);
-    protected _updateProperty(key: string, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
+    protected _updateProperty(key: string, value: any, oldValue: any): void;
     protected _updateTarget(): void;
     protected _onWheel(e: WheelInputEvent): void;
     protected _input(event: InputEvent, key: InputEventKey): void;
@@ -3309,7 +3281,7 @@ declare class CanvasItemEditor extends Control {
     drawboard: Element2D;
     ruler: Ruler;
     constructor();
-    protected _updateStyleProperty(key: string, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
+    protected _updateStyleProperty(key: string, value: any, oldValue: any): void;
     protected _guiInput(event: InputEvent, key: InputEventKey): void;
     protected _onPointerdown(e: PointerInputEvent): void;
     protected _onPointermove(e: PointerInputEvent): void;
@@ -3331,7 +3303,7 @@ interface EngineOptions extends WebGLContextAttributes {
     autoStart?: boolean;
     timeline?: Timeline;
 }
-interface EngineEventMap extends SceneTreeEventMap {
+interface EngineEvents extends SceneTreeEvents {
     pointerdown: (ev: PointerInputEvent) => void;
     pointerover: (ev: PointerInputEvent) => void;
     pointermove: (ev: PointerInputEvent) => void;
@@ -3347,10 +3319,10 @@ declare const defaultOptions: {
     readonly powerPreference: "default";
 };
 interface Engine {
-    on: (<K extends keyof EngineEventMap>(type: K, listener: EngineEventMap[K], options?: EventListenerOptions$1) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions$1) => this);
-    once: (<K extends keyof EngineEventMap>(type: K, listener: EngineEventMap[K], options?: EventListenerOptions$1) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions$1) => this);
-    off: (<K extends keyof EngineEventMap>(type: K, listener?: EngineEventMap[K], options?: EventListenerOptions$1) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions$1) => this);
-    emit: (<K extends keyof EngineEventMap>(type: K, ...args: Parameters<EngineEventMap[K]>) => boolean) & ((type: string, ...args: any[]) => boolean);
+    on: <K extends keyof EngineEvents>(event: K, listener: EngineEvents[K]) => this;
+    once: <K extends keyof EngineEvents>(event: K, listener: EngineEvents[K]) => this;
+    off: <K extends keyof EngineEvents>(event: K, listener: EngineEvents[K]) => this;
+    emit: <K extends keyof EngineEvents>(event: K, ...args: Parameters<EngineEvents[K]>) => this;
 }
 declare class Engine extends SceneTree {
     readonly renderer: WebGLRenderer;
@@ -3376,7 +3348,7 @@ declare class Engine extends SceneTree {
     waitAndRender(delta?: number): Promise<void>;
     render(delta?: number): void;
     start(): Promise<void>;
-    free(): void;
+    destroy(): void;
     toPixels(): Uint8ClampedArray<ArrayBuffer>;
     toImageData(): ImageData;
     toCanvas2D(): HTMLCanvasElement;
@@ -3393,4 +3365,4 @@ interface RenderOptions {
 declare function render(options: RenderOptions): Promise<HTMLCanvasElement>;
 
 export { AnimatedTexture, Animation, Assets, Audio, AudioPipeline, AudioProcessor, AudioSpectrum, AudioWaveform, BaseElement2D, BaseElement2DBackground, BaseElement2DFill, BaseElement2DForeground, BaseElement2DOutline, BaseElement2DShadow, BaseElement2DShape, BaseElement2DStyle, BaseElement2DText, Camera2D, CanvasContext, CanvasItem, CanvasItemEditor, CanvasTexture, Color, ColorAdjustEffect, ColorFilterEffect, ColorMatrix, ColorOverlayEffect, ColorRemoveEffect, ColorReplaceEffect, ColorTexture, Control, CoreObject, DEG_TO_RAD, DEVICE_PIXEL_RATIO, DropShadowEffect, Effect, EffectMaterial, Element2D, Element2DStyle, EmbossEffect, Engine, FlexElement2D, FlexElement2DStyle, FlexLayout, FontLoader, GaussianBlurEffect, Geometry, GifLoader, GlitchEffect, GodrayEffect, GradientTexture, HTMLAudio, HTMLAudioContext, HTMLSound, IN_BROWSER, Image2D, ImageTexture, IndexBuffer, Input, InputEvent, JsonLoader, KawaseBlurEffect, KawaseTransition, KeyboardInputEvent, LeftEraseTransition, Loader, Lottie2D, LottieLoader, MainLoop, MaskEffect, Material, Matrix, Matrix2, Matrix3, Matrix4, MouseInputEvent, Node, Node2D, OutlineEffect, PI, PI_2, PixelateEffect, PixelsTexture, PointerInputEvent, Projection2D, QuadGeometry, QuadUvGeometry, RAD_TO_DEG, Range, RawWeakMap, Rect2, RefCounted, Renderer, Resource, Ruler, SUPPORTS_AUDIO_CONTEXT, SUPPORTS_CLICK_EVENTS, SUPPORTS_CREATE_IMAGE_BITMAP, SUPPORTS_IMAGE_BITMAP, SUPPORTS_MOUSE_EVENTS, SUPPORTS_OFFLINE_AUDIO_CONTEXT, SUPPORTS_POINTER_EVENTS, SUPPORTS_RESIZE_OBSERVER, SUPPORTS_TOUCH_EVENTS, SUPPORTS_WEBGL2, SUPPORTS_WEBKIT_AUDIO_CONTEXT, SUPPORTS_WEBKIT_OFFLINE_AUDIO_CONTEXT, SUPPORTS_WEB_AUDIO, SUPPORTS_WHEEL_EVENTS, Scaler, SceneTree, ScrollBar, TextLoader, Texture2D, TextureLoader, TextureRect2D, Ticker, TiltShiftTransition, Timeline, TimelineNode, Transform2D, TransformRect2D, Transition, TwistTransition, UvGeometry, UvMaterial, Vector, Vector2, Vector3, Vector4, VertexAttribute, VertexBuffer, Video2D, VideoLoader, VideoTexture, Viewport, ViewportTexture, WebAudio, WebAudioContext, WebGLBatch2DModule, WebGLBlendMode, WebGLBufferModule, WebGLFramebufferModule, WebGLMaskModule, WebGLModule, WebGLProgramModule, WebGLRenderer, WebGLScissorModule, WebGLState, WebGLStateModule, WebGLStencilModule, WebGLTextureModule, WebGLVertexArrayModule, WebGLViewportModule, WebSound, WheelInputEvent, Window, XScrollBar, YScrollBar, ZoomBlurEffect, alignMap, assets, boxSizingMap, clamp, clampFrag, createHTMLCanvas, createNode, crossOrigin, cubicBezier, curves, customNode, customNodes, defaultOptions, determineCrossOrigin, directionMap, displayMap, ease, easeIn, easeInOut, easeOut, edgeMap, flexDirectionMap, flexWrapMap, frag, getDefaultCssPropertyValue, gutterMap, isCanvasElement, isElementNode, isImageElement, isPow2, isVideoElement, isWebgl2, justifyMap, lerp, linear, log2, mapWebGLBlendModes, nextPow2, nextTick, overflowMap, parseCSSFilter, parseCSSTransform, parseCSSTransformOrigin, parseCssFunctions, parseCssProperty, positionTypeMap, render, timingFunctions, uid };
-export type { AnimationEffectMode, AnimationProperties, AssetHandler, AudioWaveformProperties, BaseElement2DEventMap, BaseElement2DProperties, BaseElement2DStyleProperties, Batchable2D, CSSFilterKey, CSSFilters, Camera2DEventMap, Camera2DProperties, CanvasBatchable, CanvasItemEventMap, CanvasItemProperties, ColorAdjustEffectProperties, ColorFilterEffectProperties, ColorOverlayEffectProperties, ColorRemoveEffectProperties, ColorReplaceEffectProperties, ComputedLayout, ControlEventMap, ControlProperties, CoreObjectEventMap, CssFunction, CssFunctionArg, Cursor, CustomPropertyAccessor, DropShadowEffectProperties, Easing, EffectContext, EffectMode, EffectProperties, Element2DEventMap, Element2DProperties, Element2DStyleProperties, EmbossEffectProperties, EngineOptions, FillDraw, FlexBaseElement2DEventMap, FlexElement2DProperties, FlexElement2DStyleProperties, GaussianBlurEffectProperties, GeometryOptions, GlitchEffectProperties, GodrayEffectProperties, IAudioContext, IAudioNode, IPlayOptions, Image2DProperties, ImageFrame, ImageTextureOptions, IndexBufferOptions, InputEventKey, InputEventMap, InputMode, InternalMode, KawaseBlurEffectProperties, Keyframe, Lottie2DProperties, MainLoopEventMap, MaskColor, MaskData, MaskEffectProperties, MaskObject, MaskRect, Maskable, MaterialOptions, MatrixLike, MatrixOperateOutput, Node2DEventMap, Node2DProperties, NodeEventMap, NodeProperties, NormalizedKeyframe, OutlineEffectProperties, PixelateEffectProperties, PlatformAudio, PlatformSound, ProcessMode, ProcessSortMode, RangeProperties, Rectangulable, RectangulableEventMap, RefCountedEventMap, RenderMode, RenderOptions, Renderable, ResourceEventMap, RulerProperties, ScalerEventMap, ScalerProperties, SceneTreeEventMap, ScrollBarProperties, StrokeDraw, Texture2DFilterMode, Texture2DPixelsSource, Texture2DSource, Texture2DWrapMode, TextureRect2DProperties, TimelineEventMap, TimelineNodeEventMap, TimelineNodeProperties, TimelineProperties, TimingFunctions, TransformObject, TransformRect2DProperties, TransformableObject, TransitionProperties, UvTransform, Vector2Data, VectorLike, VectorOperateOutput, VertTransform, VertexAttributeOptions, VertexBufferOptions, Video2DProperties, VideoTextureOptions, VideoTextureSource, ViewportEventMap, ViewportFramebuffer, WebGLBufferMeta, WebGLBufferOptions, WebGLBufferTarget, WebGLBufferUsage, WebGLDrawMode, WebGLDrawOptions, WebGLExtensions, WebGLFramebufferMeta, WebGLFramebufferOptions, WebGLProgramMeta, WebGLProgramOptions, WebGLTarget, WebGLTextureFilterMode, WebGLTextureLocation, WebGLTextureMeta, WebGLTextureOptions, WebGLTextureSource, WebGLTextureTarget, WebGLTextureWrapMode, WebGLVertexArrayObjectMeta, WebGLVertexArrayObjectOptions, WebGLVertexAttrib, WebGLVertexAttribType, WebGLViewport, XScrollBarProperties, YScrollBarProperties, ZoomBlurEffectProperties };
+export type { AnimationEffectMode, AnimationProperties, AssetHandler, AudioWaveformProperties, BaseElement2DEvents, BaseElement2DProperties, BaseElement2DStyleProperties, Batchable2D, CSSFilterKey, CSSFilters, Camera2DEvents, Camera2DProperties, CanvasBatchable, CanvasItemEvents, CanvasItemProperties, ColorAdjustEffectProperties, ColorFilterEffectProperties, ColorOverlayEffectProperties, ColorRemoveEffectProperties, ColorReplaceEffectProperties, ComputedLayout, ControlEvents, ControlProperties, CoreObjectEvents, CssFunction, CssFunctionArg, Cursor, DropShadowEffectProperties, Easing, EffectContext, EffectMode, EffectProperties, Element2DEvents, Element2DProperties, Element2DStyleProperties, EmbossEffectProperties, EngineOptions, FillDraw, FlexBaseElement2DEvents, FlexElement2DProperties, FlexElement2DStyleProperties, GaussianBlurEffectProperties, GeometryOptions, GlitchEffectProperties, GodrayEffectProperties, IAudioContext, IAudioNode, IPlayOptions, Image2DProperties, ImageFrame, ImageTextureOptions, IndexBufferOptions, InputEventKey, InputEvents, InputMode, InternalMode, KawaseBlurEffectProperties, Keyframe, Lottie2DProperties, MainLoopEvents, MaskColor, MaskData, MaskEffectProperties, MaskObject, MaskRect, Maskable, MaterialOptions, MatrixLike, MatrixOperateOutput, Node2DEvents, Node2DProperties, NodeEvents, NodeProperties, NormalizedKeyframe, OutlineEffectProperties, PixelateEffectProperties, PlatformAudio, PlatformSound, ProcessMode, ProcessSortMode, RangeProperties, Rectangulable, RectangulableEvents, RefCountedEvents, RenderMode, RenderOptions, Renderable, ResourceEvents, RulerProperties, ScalerEvents, ScalerProperties, SceneTreeEvents, ScrollBarProperties, StrokeDraw, Texture2DFilterMode, Texture2DPixelsSource, Texture2DSource, Texture2DWrapMode, TextureRect2DProperties, TimelineEvents, TimelineNodeEvents, TimelineNodeProperties, TimelineProperties, TimingFunctions, TransformObject, TransformRect2DProperties, TransformableObject, TransitionProperties, UvTransform, Vector2Data, VectorLike, VectorOperateOutput, VertTransform, VertexAttributeOptions, VertexBufferOptions, Video2DProperties, VideoTextureOptions, VideoTextureSource, ViewportEvents, ViewportFramebuffer, WebGLBufferMeta, WebGLBufferOptions, WebGLBufferTarget, WebGLBufferUsage, WebGLDrawMode, WebGLDrawOptions, WebGLExtensions, WebGLFramebufferMeta, WebGLFramebufferOptions, WebGLProgramMeta, WebGLProgramOptions, WebGLTarget, WebGLTextureFilterMode, WebGLTextureLocation, WebGLTextureMeta, WebGLTextureOptions, WebGLTextureSource, WebGLTextureTarget, WebGLTextureWrapMode, WebGLVertexArrayObjectMeta, WebGLVertexArrayObjectOptions, WebGLVertexAttrib, WebGLVertexAttribType, WebGLViewport, XScrollBarProperties, YScrollBarProperties, ZoomBlurEffectProperties };