@galacean/engine-core 2.0.0-alpha.44 → 2.0.0-alpha.46

package/types/RenderPipeline/MaskManager.d.ts

@@ -1 +1,36 @@
-export {};
+import { SpriteMask } from "../2d";
+import { SpriteMaskLayer } from "../enums/SpriteMaskLayer";
+import { Material } from "../material";
+import { RenderContext } from "./RenderContext";
+import { RenderQueue } from "./RenderQueue";
+/**
+ * @internal
+ */
+export declare class MaskManager {
+    private static _stencilEnabledProp;
+    private static _stencilWriteMaskProp;
+    private static _stencilMaskProp;
+    private static _stencilCompareFunctionFrontProp;
+    private static _stencilCompareFunctionBackProp;
+    private static _stencilPassOperationFrontProp;
+    private static _stencilPassOperationBackProp;
+    private static _stencilFailOperationFrontProp;
+    private static _stencilFailOperationBackProp;
+    private static _stencilZFailOperationFrontProp;
+    private static _stencilZFailOperationBackProp;
+    private static _maskIncrementRenderQueue;
+    private static _maskDecrementRenderQueue;
+    static getMaskIncrementRenderQueue(): RenderQueue;
+    static getMaskDecrementRenderQueue(): RenderQueue;
+    hasStencilWritten: boolean;
+    private _preMaskLayer;
+    private _allSpriteMasks;
+    addSpriteMask(mask: SpriteMask): void;
+    removeSpriteMask(mask: SpriteMask): void;
+    drawMask(context: RenderContext, pipelineStageTagValue: string, maskLayer: SpriteMaskLayer): void;
+    clearMask(context: RenderContext, pipelineStageTagValue: string): void;
+    isStencilWritten(material: Material): boolean;
+    isReadStencil(material: Material): boolean;
+    destroy(): void;
+    private _buildMaskRenderElement;
+}

package/types/RenderPipeline/OpaqueTexturePass.d.ts

@@ -1 +1,16 @@
-export {};
+import { Camera } from "../Camera";
+import { Engine } from "../Engine";
+import { Texture } from "../texture";
+import { PipelinePass } from "./PipelinePass";
+import { RenderContext } from "./RenderContext";
+/**
+ * @internal
+ * Opaque texture pass.
+ */
+export declare class OpaqueTexturePass extends PipelinePass {
+    private _cameraColorTexture;
+    private _renderTarget;
+    constructor(engine: Engine);
+    onConfig(camera: Camera, cameraColorTexture: Texture): void;
+    onRender(context: RenderContext): void;
+}

package/types/RenderPipeline/PipelineUtils.d.ts

@@ -1 +1,11 @@
-export {};
+import { Vector4 } from "@galacean/engine-math";
+import { Engine } from "../Engine";
+import { RenderTarget, Texture2D, TextureFilterMode, TextureFormat, TextureWrapMode } from "../texture";
+/**
+ * @internal
+ */
+export declare class PipelineUtils {
+    static readonly defaultViewport: Vector4;
+    static recreateTextureIfNeeded(engine: Engine, currentTexture: Texture2D | null, width: number, height: number, format: TextureFormat, mipmap: boolean, isSRGBColorSpace: boolean, textureWrapMode: TextureWrapMode, textureFilterMode: TextureFilterMode): Texture2D;
+    static recreateRenderTargetIfNeeded(engine: Engine, currentRenderTarget: RenderTarget | null, width: number, height: number, colorFormat: TextureFormat | null, depthFormat: TextureFormat | null, needDepthTexture: boolean, mipmap: boolean, isSRGBColorSpace: boolean, antiAliasing: number, textureWrapMode: TextureWrapMode, textureFilterMode: TextureFilterMode): RenderTarget;
+}

package/types/RenderPipeline/PrimitiveChunk.d.ts

@@ -1 +1,27 @@
-export {};
+import { Engine } from "../Engine";
+import { Primitive, SubMesh } from "../graphic";
+import { ReturnableObjectPool } from "../utils/ReturnableObjectPool";
+import { SubPrimitiveChunk } from "./SubPrimitiveChunk";
+import { VertexArea } from "./VertexArea";
+/**
+ * @internal
+ */
+export declare class PrimitiveChunk {
+    static areaPool: ReturnableObjectPool<VertexArea>;
+    static subChunkPool: ReturnableObjectPool<SubPrimitiveChunk>;
+    static subMeshPool: ReturnableObjectPool<SubMesh>;
+    primitive: Primitive;
+    vertices: Float32Array;
+    indices: Uint16Array;
+    updateVertexStart: number;
+    updateVertexEnd: number;
+    updateIndexLength: number;
+    vertexFreeAreas: Array<VertexArea>;
+    constructor(engine: Engine, maxVertexCount: number);
+    allocateSubChunk(vertexCount: number): SubPrimitiveChunk | null;
+    freeSubChunk(subChunk: SubPrimitiveChunk): void;
+    uploadBuffer(): void;
+    destroy(): void;
+    private _allocateArea;
+    private _freeArea;
+}

package/types/RenderPipeline/PrimitiveChunkManager.d.ts

@@ -1 +1,16 @@
-export {};
+import { Engine } from "../Engine";
+import { PrimitiveChunk } from "./PrimitiveChunk";
+import { SubPrimitiveChunk } from "./SubPrimitiveChunk";
+/**
+ * @internal
+ */
+export declare class PrimitiveChunkManager {
+    engine: Engine;
+    maxVertexCount: number;
+    primitiveChunks: PrimitiveChunk[];
+    constructor(engine: Engine, maxVertexCount?: number);
+    allocateSubChunk(vertexCount: number): SubPrimitiveChunk;
+    freeSubChunk(subChunk: SubPrimitiveChunk): void;
+    uploadBuffer(): void;
+    destroy(): void;
+}

package/types/RenderPipeline/RenderContext.d.ts

@@ -1 +1,46 @@
-export {};
+import { Matrix, Vector4 } from "@galacean/engine-math";
+import { Camera } from "../Camera";
+import { VirtualCamera } from "../VirtualCamera";
+import { ReplacementFailureStrategy } from "../enums/ReplacementFailureStrategy";
+import { Shader, ShaderProperty } from "../shader";
+import { ShaderTagKey } from "../shader/ShaderTagKey";
+import { RenderTarget, TextureCubeFace } from "../texture";
+/**
+ * @internal
+ */
+export declare class RenderContext {
+    static vpMatrixProperty: ShaderProperty;
+    static pipelineStageKey: ShaderTagKey;
+    /** @internal */
+    static _flipYMatrix: Matrix;
+    private static _cameraProjectionProperty;
+    private static _viewMatrixProperty;
+    private static _projectionMatrixProperty;
+    private static _flipYProjectionMatrix;
+    private static _flipYViewProjectionMatrix;
+    private _projectionParams;
+    camera: Camera;
+    virtualCamera: VirtualCamera;
+    replacementShader: Shader;
+    replacementTag: ShaderTagKey;
+    replacementFailureStrategy: ReplacementFailureStrategy;
+    flipProjection: boolean;
+    viewMatrix: Matrix;
+    projectionMatrix: Matrix;
+    viewProjectionMatrix: Matrix;
+    applyVirtualCamera(virtualCamera: VirtualCamera, flipProjection: boolean): void;
+    setRenderTarget(destination: RenderTarget | null, viewport: Vector4, mipLevel?: number, faceIndex?: TextureCubeFace): void;
+    garbageCollection(): void;
+}
+/**
+ * @internal
+ */
+export declare enum ContextRendererUpdateFlag {
+    None = 0,
+    WorldMatrix = 1,
+    viewMatrix = 2,
+    ProjectionMatrix = 4,
+    WorldViewMatrix = 3,
+    viewProjectionMatrix = 6,
+    All = 7
+}

package/types/RenderPipeline/RenderElement.d.ts

@@ -16,8 +16,17 @@ export declare class RenderElement implements IPoolElement {
     shaderData?: ShaderData;
     instancedRenderers: Renderer[];
     subDistancePriority: number;
+    /** @internal Marks a batch leader — a self-contained draw range that must not be merged again downstream */
+    _isBatched: boolean;
     texture?: Texture2D;
     subChunk?: SubPrimitiveChunk;
     set(component: Renderer, material: Material, primitive: Primitive, subPrimitive: SubMesh, texture?: Texture2D, subChunk?: SubPrimitiveChunk): void;
+    /**
+     * @internal
+     * Copy identity fields from `source` and reset per-queue batch state, so the same
+     * logical element can live in multiple queues (e.g. an Opaque + Transparent multi-pass
+     * material) without one queue's batching corrupting another's `instancedRenderers`.
+     */
+    _cloneFrom(source: RenderElement): void;
     dispose(): void;
 }

package/types/RenderPipeline/RenderQueue.d.ts

@@ -1 +1,23 @@
-export {};
+import { RenderQueueType } from "../shader";
+import { BatcherManager } from "./BatcherManager";
+import { ContextRendererUpdateFlag, RenderContext } from "./RenderContext";
+import { RenderElement } from "./RenderElement";
+import { RenderQueueMaskType } from "./enums/RenderQueueMaskType";
+/**
+ * @internal
+ */
+export declare class RenderQueue {
+    renderQueueType: RenderQueueType;
+    static compareForOpaque(a: RenderElement, b: RenderElement): number;
+    static compareForTransparent(a: RenderElement, b: RenderElement): number;
+    readonly elements: RenderElement[];
+    readonly batchedElements: RenderElement[];
+    rendererUpdateFlag: ContextRendererUpdateFlag;
+    constructor(renderQueueType: RenderQueueType);
+    pushRenderElement(element: RenderElement): void;
+    sortBatch(compareFunc: Function, batcherManager: BatcherManager): void;
+    batch(batcherManager: BatcherManager): void;
+    render(context: RenderContext, pipelineStageTagValue: string, maskType?: RenderQueueMaskType): void;
+    clear(): void;
+    destroy(): void;
+}

package/types/RenderPipeline/RenderTargetPool.d.ts

@@ -1 +1,17 @@
-export {};
+import { Engine } from "../Engine";
+import { RenderTarget, Texture2D, TextureFilterMode, TextureFormat, TextureWrapMode } from "../texture";
+/**
+ * @internal
+ */
+export declare class RenderTargetPool {
+    private _freeRenderTargets;
+    private _freeTextures;
+    private _engine;
+    constructor(engine: Engine);
+    allocateRenderTarget(width: number, height: number, colorFormat: TextureFormat | null, depthFormat: TextureFormat | null, needDepthTexture: boolean, mipmap: boolean, isSRGBColorSpace: boolean, antiAliasing: number, wrapMode: TextureWrapMode, filterMode: TextureFilterMode): RenderTarget;
+    allocateTexture(width: number, height: number, format: TextureFormat, mipmap: boolean, isSRGBColorSpace: boolean, wrapMode: TextureWrapMode, filterMode: TextureFilterMode): Texture2D;
+    freeRenderTarget(renderTarget: RenderTarget): void;
+    freeTexture(texture: Texture2D): void;
+    gc(): void;
+    private static _matchRenderTarget;
+}

package/types/RenderPipeline/SubPrimitiveChunk.d.ts

@@ -1 +1,14 @@
-export {};
+import { SubMesh } from "../graphic";
+import { IPoolElement } from "../utils/ObjectPool";
+import { VertexArea } from "./VertexArea";
+import { PrimitiveChunk } from "./PrimitiveChunk";
+/**
+ * @internal
+ */
+export declare class SubPrimitiveChunk implements IPoolElement {
+    chunk: PrimitiveChunk;
+    vertexArea: VertexArea;
+    subMesh: SubMesh;
+    indices: number[];
+    dispose?(): void;
+}

package/types/RenderPipeline/VertexArea.d.ts

@@ -1 +1,10 @@
-export {};
+import { IPoolElement } from "../utils/ObjectPool";
+/**
+ * @internal
+ */
+export declare class VertexArea implements IPoolElement {
+    start?: number;
+    size?: number;
+    constructor(start?: number, size?: number);
+    dispose?(): void;
+}

package/types/RenderPipeline/VertexMergeBatcher.d.ts

@@ -1 +1,11 @@
-export {};
+import { ShaderTagKey } from "../shader";
+import { RenderElement } from "./RenderElement";
+/**
+ * @internal
+ */
+export declare class VertexMergeBatcher {
+    protected static _disableBatchTag: ShaderTagKey;
+    static canBatchSprite(preElement: RenderElement, curElement: RenderElement): boolean;
+    static canBatchSpriteMask(preElement: RenderElement, curElement: RenderElement): boolean;
+    static batch(preElement: RenderElement | null, curElement: RenderElement): void;
+}

package/types/RenderPipeline/enums/RenderQueueMaskType.d.ts

@@ -1 +1,9 @@
-export {};
+/**
+ * @internal
+ * Render queue mask type.
+ */
+export declare enum RenderQueueMaskType {
+    No = 0,
+    Increment = 1,
+    Decrement = 2
+}

package/types/RenderPipeline/index.d.ts

@@ -1,5 +1,7 @@
 export { BasicRenderPipeline, RenderQueueFlags } from "./BasicRenderPipeline";
 export { VertexMergeBatcher } from "./VertexMergeBatcher";
+/** @internal */
+export type { PrimitiveChunkManager } from "./PrimitiveChunkManager";
 export { Blitter } from "./Blitter";
 export { RenderElement } from "./RenderElement";
 export { RenderQueue } from "./RenderQueue";

package/types/Renderer.d.ts

@@ -1,23 +1,41 @@
 import { BoundingBox, Vector4 } from "@galacean/engine-math";
+import { SpriteMaskInteraction } from "./2d/enums/SpriteMaskInteraction";
 import { Component } from "./Component";
 import { Entity } from "./Entity";
 import { RenderContext } from "./RenderPipeline/RenderContext";
+import { RenderElement } from "./RenderPipeline/RenderElement";
 import { TransformModifyFlags } from "./Transform";
 import type { ICloneHook } from "./clone/ICloneHook";
 import { SpriteMaskLayer } from "./enums/SpriteMaskLayer";
 import { Material } from "./material";
+import { ShaderProperty } from "./shader";
 import { ShaderData } from "./shader/ShaderData";
+import { ShaderMacroCollection } from "./shader/ShaderMacroCollection";
 /**
  * Basis for all renderers.
  * @decorator `@dependentComponents(Transform, DependentMode.CheckOnly)`
  */
 export declare class Renderer extends Component implements ICloneHook<Renderer> {
     private static _tempVector0;
+    /** @internal */
+    static _worldMatrixProperty: ShaderProperty;
+    /** @internal */
+    static _rendererLayerProperty: ShaderProperty;
     private static _receiveShadowMacro;
     private static _mvMatrixProperty;
     private static _mvpMatrixProperty;
     private static _normalMatrixProperty;
+    /** @internal */
+    _distanceForSort: number;
+    /** @internal */
+    _onUpdateIndex: number;
+    /** @internal */
+    _rendererIndex: number;
+    /** @internal */
+    _globalShaderMacro: ShaderMacroCollection;
     _renderFrameCount: number;
+    /** @internal */
+    _maskInteraction: SpriteMaskInteraction;
     _maskLayer: SpriteMaskLayer;
     protected _overrideUpdate: boolean;
     protected _materials: Material[];
@@ -61,6 +79,10 @@ export declare class Renderer extends Component implements ICloneHook<Renderer>
      */
     get priority(): number;
     set priority(value: number);
+    /**
+     * @internal
+     */
+    constructor(entity: Entity);
     /**
      * Get the first instance material.
      * @returns The first instance material
@@ -112,10 +134,42 @@ export declare class Renderer extends Component implements ICloneHook<Renderer>
      */
     setMaterials(materials: Material[]): void;
     update(deltaTime: number): void;
+    /**
+     * @internal
+     */
+    _onEnableInScene(): void;
+    /**
+     * @internal
+     */
+    _onDisableInScene(): void;
+    /**
+     * @internal
+     */
+    _prepareRender(context: RenderContext): void;
     /**
      * @inheritdoc
      */
     _onClone(target: Renderer): void;
+    /**
+     * @internal
+     */
+    _isFrontFaceInvert(): boolean;
+    /**
+     * @internal
+     */
+    protected _onDestroy(): void;
+    /**
+     * @internal
+     */
+    _updateTransformShaderData(context: RenderContext, onlyMVP: boolean): void;
+    /**
+     * @internal
+     */
+    _canBatch(preElement: RenderElement, curElement: RenderElement): boolean;
+    /**
+     * @internal
+     */
+    _batch(preElement: RenderElement | null, curElement: RenderElement): void;
     /**
      * Update once per frame per renderer.
      */
@@ -125,6 +179,10 @@ export declare class Renderer extends Component implements ICloneHook<Renderer>
      * Vertices are already in world space, so model matrix is identity.
      */
     protected _updateWorldSpaceTransformShaderData(context: RenderContext, onlyMVP: boolean): void;
+    /**
+     * @internal
+     */
+    protected _setTransformEntity(entity: Entity): void;
     protected _updateBounds(worldBounds: BoundingBox): void;
     protected _render(context: RenderContext): void;
     private _createInstanceMaterial;

package/types/Scene.d.ts

@@ -1,11 +1,15 @@
 import { Color, Vector3 } from "@galacean/engine-math";
 import { Background } from "./Background";
+import { ComponentsManager } from "./ComponentsManager";
 import { Engine } from "./Engine";
 import { Entity } from "./Entity";
+import { MaskManager } from "./RenderPipeline/MaskManager";
+import { SceneManager } from "./SceneManager";
 import { EngineObject } from "./base";
 import { FogMode } from "./enums/FogMode";
 import { AmbientOcclusion, DirectLight } from "./lighting";
 import { AmbientLight } from "./lighting/AmbientLight";
+import { LightManager } from "./lighting/LightManager";
 import { PhysicsScene } from "./physics/PhysicsScene";
 import { PostProcessManager } from "./postProcess";
 import { ShaderData } from "./shader/ShaderData";
@@ -46,6 +50,18 @@ export declare class Scene extends EngineObject {
      * such as corners, crevices, and contact points between surfaces.
      */
     readonly ambientOcclusion: AmbientOcclusion;
+    /** @internal */
+    _lightManager: LightManager;
+    /** @internal */
+    _componentsManager: ComponentsManager;
+    /** @internal */
+    _maskManager: MaskManager;
+    /** @internal */
+    _isActiveInEngine: boolean;
+    /** @internal */
+    _sceneManager: SceneManager;
+    /** @internal */
+    _rootEntities: Entity[];
     private _background;
     private _shaderData;
     private _shadowCascades;
@@ -177,6 +193,18 @@ export declare class Scene extends EngineObject {
      * @returns Entity
      */
     findEntityByPath(path: string): Entity | null;
+    /**
+     * @internal
+     */
+    _processActive(active: boolean): void;
+    /**
+     * @internal
+     */
+    _updateShaderData(): void;
+    /**
+     * @internal
+     */
+    protected _onDestroy(): void;
     private _computeLinearFogParams;
     private _computeExponentialFogParams;
     private _getSunlight;

package/types/SceneManager.d.ts

@@ -1,15 +1,24 @@
 import { Engine } from "./Engine";
 import { Scene } from "./Scene";
 import { AssetPromise } from "./asset/AssetPromise";
+import { SafeLoopArray } from "./utils/SafeLoopArray";
 /**
  * Scene manager.
  */
 export declare class SceneManager {
     readonly engine: Engine;
+    /** @internal */
+    _allCreatedScenes: Scene[];
+    /** @internal */
+    _scenes: SafeLoopArray<Scene>;
     /**
      * Get the scene list.
      */
     get scenes(): ReadonlyArray<Scene>;
+    /**
+     * @internal
+     */
+    constructor(engine: Engine);
     /**
      * Add scene.
      * @param scene - The scene which want to be added
@@ -40,6 +49,10 @@ export declare class SceneManager {
      * @param destScene - target scene
      */
     mergeScenes(sourceScene: Scene, destScene: Scene): void;
+    /**
+     * @internal
+     */
+    _destroyAllScene(): void;
     /**
      * @deprecated
      * Please use `scenes` instead.

package/types/Script.d.ts

@@ -7,6 +7,22 @@ import { Collision } from "./physics/Collision";
  * Script class, used for logic writing.
  */
 export declare class Script extends Component {
+    /** @internal */
+    _started: boolean;
+    /** @internal */
+    _onStartIndex: number;
+    /** @internal */
+    _onUpdateIndex: number;
+    /** @internal */
+    _onLateUpdateIndex: number;
+    /** @internal */
+    _onPhysicsUpdateIndex: number;
+    /** @internal */
+    _onPreRenderIndex: number;
+    /** @internal */
+    _onPostRenderIndex: number;
+    /** @internal */
+    _entityScriptsIndex: number;
     /**
      * Called when be enabled first time, only once.
      */
@@ -130,6 +146,30 @@ export declare class Script extends Component {
      * Called at the end of the destroyed frame.
      */
     onDestroy(): void;
+    /**
+     * @internal
+     */
+    _onAwake(): void;
+    /**
+     * @internal
+     */
+    _onEnable(): void;
+    /**
+     * @internal
+     */
+    _onDisable(): void;
+    /**
+     * @internal
+     */
+    _onEnableInScene(): void;
+    /**
+     * @internal
+     */
+    _onDisableInScene(): void;
+    /**
+     * @internal
+     */
+    protected _onDestroy(): void;
     private _hasCollisionEventCallbacks;
 }
 export declare enum PointerMethods {

package/types/SystemInfo.d.ts

@@ -10,6 +10,8 @@ export declare class SystemInfo {
     static platform: Platform;
     /** The operating system is running on. */
     static operatingSystem: string;
+    /** @internal */
+    static _isBrowser: boolean;
     /** Whether the system support SIMD. */
     private static _simdSupported;
     private static _webpSupported;
@@ -18,6 +20,14 @@ export declare class SystemInfo {
      */
     static get devicePixelRatio(): number;
     private static _parseAppleMobileOSVersion;
+    /**
+     * @internal
+     */
+    static _initialize(): void;
+    /**
+     * @internal
+     */
+    static _detectSIMDSupported(): boolean;
     static _checkWebpSupported(): AssetPromise<boolean>;
     /**
      * Checks whether the system supports the given texture format.

package/types/Transform.d.ts

@@ -1,9 +1,11 @@
 import { Matrix, Quaternion, Vector3 } from "@galacean/engine-math";
 import { BoolUpdateFlag } from "./BoolUpdateFlag";
 import { Component } from "./Component";
+import { Entity } from "./Entity";
 import type { ICloneHook } from "./clone/ICloneHook";
 /**
  * Used to implement transformation related functions.
+ * @remarks A `Transform` subclass must not declare component dependencies.
  */
 export declare class Transform extends Component implements ICloneHook<Transform> {
     private static _tempQuat0;
@@ -88,6 +90,11 @@ export declare class Transform extends Component implements ICloneHook<Transform
      */
     get worldMatrix(): Matrix;
     set worldMatrix(value: Matrix);
+    /**
+     * @internal
+     */
+    constructor(entity: Entity);
+    destroy(): void;
     /**
      * Set local position by X, Y, Z value.
      * @param x - X coordinate
@@ -193,6 +200,18 @@ export declare class Transform extends Component implements ICloneHook<Transform
      * @param worldUp - Up direction in world space, default is Vector3(0, 1, 0)
      */
     lookAt(targetPosition: Vector3, worldUp?: Vector3): void;
+    /**
+     * @internal
+     */
+    _parentChange(): void;
+    /**
+     * @internal
+     */
+    _isFrontFaceInvert(): boolean;
+    /**
+     * @internal
+     */
+    _copyLocalPoseFrom(source: Transform): void;
     /**
      * @inheritdoc
      */

package/types/UpdateFlag.d.ts

@@ -1,7 +1,10 @@
+import { UpdateFlagManager } from "./UpdateFlagManager";
 /**
  * Used to update tags.
  */
 export declare abstract class UpdateFlag {
+    /** @internal */
+    _flagManagers: UpdateFlagManager[];
     /**
      * Dispatch.
      * @param bit - Bit

package/types/UpdateFlagManager.d.ts

@@ -1 +1,41 @@
-export {};
+import { UpdateFlag } from "./UpdateFlag";
+/**
+ * @internal
+ */
+export declare class UpdateFlagManager {
+    /** Monotonic counter bumped on every `dispatch`; consumers can snapshot it for lazy pull-style cache invalidation. */
+    version: number;
+    _updateFlags: UpdateFlag[];
+    private _listeners;
+    /**
+     * Create a UpdateFlag.
+     * @returns - The UpdateFlag.
+     */
+    createFlag<T extends UpdateFlag>(type: new () => T): T;
+    /**
+     * Add a UpdateFlag.
+     * @param flag - The UpdateFlag.
+     */
+    addFlag(flag: UpdateFlag): void;
+    /**
+     * Remove a UpdateFlag.
+     * @param flag - The UpdateFlag.
+     */
+    removeFlag(flag: UpdateFlag): void;
+    /**
+     * Add a listener.
+     * @param listener - The listener
+     */
+    addListener(listener: (type?: number, param?: unknown) => void): void;
+    /**
+     * Remove a listener.
+     * @param listener - The listener
+     */
+    removeListener(listener: (type?: number, param?: unknown) => void): void;
+    /**
+     * Dispatch a event.
+     * @param type - Event type, usually in the form of enumeration
+     * @param param - Event param
+     */
+    dispatch(type?: number, param?: unknown): void;
+}