@galacean/engine-loader 2.0.0-alpha.28 → 2.0.0-alpha.30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@galacean/engine-loader",
-  "version": "2.0.0-alpha.28",
+  "version": "2.0.0-alpha.30",
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org"
@@ -19,9 +19,9 @@
     "libs/**/*"
   ],
   "dependencies": {
-    "@galacean/engine-core": "2.0.0-alpha.28",
-    "@galacean/engine-rhi-webgl": "2.0.0-alpha.28",
-    "@galacean/engine-math": "2.0.0-alpha.28"
+    "@galacean/engine-core": "2.0.0-alpha.30",
+    "@galacean/engine-math": "2.0.0-alpha.30",
+    "@galacean/engine-rhi-webgl": "2.0.0-alpha.30"
   },
   "scripts": {
     "b:types": "tsc"

package/types/SceneLoader.d.ts

@@ -1 +1,8 @@
-export {};
+import { ResourceManager, Scene } from "@galacean/engine-core";
+import type { RefItem } from "./schema/CommonSchema";
+import { type SceneFile } from "./schema/SceneSchema";
+/**
+ * Apply scene-level data (ambient, background, shadow, fog, AO) to a Scene.
+ * @internal
+ */
+export declare function applySceneData(scene: Scene, sceneData: SceneFile["scene"], resourceManager: ResourceManager, refs: RefItem[]): Promise<void>;

package/types/gltf/extensions/GLTFExtensionSchema.d.ts

@@ -1,4 +1,5 @@
 import type { IMaterialNormalTextureInfo, ITextureInfo } from "../GLTFSchema";
+import type { RefItem } from "../../schema/CommonSchema";
 /**
  * Interfaces from the KHR_lights_punctual extension
  */
@@ -133,9 +134,7 @@ export interface IEXTMeshoptCompressionSchema {
     count: number;
     filter?: "NONE" | "OCTAHEDRAL" | "QUATERNION" | "EXPONENTIAL";
 }
-export interface IGalaceanMaterialRemap {
-    url: string;
-    key?: string;
+export interface IGalaceanMaterialRemap extends RefItem {
     isClone?: boolean;
 }
 export interface IGalaceanAnimation {

package/types/index.d.ts

@@ -25,7 +25,7 @@ import "./PhysicsMaterialLoader";
 import "./RenderTargetLoader";
 export { GLTFLoader } from "./GLTFLoader";
 export type { GLTFParams } from "./GLTFLoader";
-export * from "./SceneLoader";
+import "./SceneLoader";
 export type { TextureParams } from "./TextureLoader";
 export { parseSingleKTX } from "./compressed-texture";
 export * from "./gltf";

package/types/prefab/PrefabParser.d.ts

@@ -1,12 +1,15 @@
 import { Engine, Entity } from "@galacean/engine-core";
-import { IEntity, IHierarchyFile, ParserContext } from "../resource-deserialize";
+import type { HierarchyFile } from "../schema/HierarchySchema";
+import type { PrefabFile } from "../schema/PrefabSchema";
 import { HierarchyParser } from "../resource-deserialize/resources/parser/HierarchyParser";
+import { ParserContext } from "../resource-deserialize/resources/parser/ParserContext";
 import { PrefabResource } from "./PrefabResource";
-export declare class PrefabParser extends HierarchyParser<PrefabResource, ParserContext<IHierarchyFile, Entity>> {
+export declare class PrefabParser extends HierarchyParser<PrefabResource, ParserContext> {
     readonly prefabResource: PrefabResource;
-    static parse(engine: Engine, url: string, data: IHierarchyFile): Promise<PrefabResource>;
-    constructor(data: IHierarchyFile, context: ParserContext<IHierarchyFile, Entity>, prefabResource: PrefabResource);
-    protected _applyEntityData(entity: Entity, entityConfig?: IEntity): Entity;
-    protected _handleRootEntity(id: string): void;
+    static parse(engine: Engine, url: string, data: PrefabFile): Promise<PrefabResource>;
+    constructor(data: HierarchyFile, context: ParserContext, prefabResource: PrefabResource);
+    protected _onEntityCreated(entity: Entity): void;
+    protected _getRootIndices(): number[];
+    protected _handleRootEntity(index: number): void;
     protected _clearAndResolve(): PrefabResource;
 }

package/types/resource-deserialize/index.d.ts

@@ -15,7 +15,7 @@ export declare function decode<T>(arrayBuffer: ArrayBuffer, engine: Engine, ...a
 export * from "./resources/parser/HierarchyParser";
 export * from "./resources/parser/ParserContext";
 export * from "./resources/scene/SceneParser";
-export * from "./resources/schema";
+export * from "../schema";
 export * from "./utils/BufferReader";
 export * from "./utils/Decorator";
 export * from "./utils/FileHeader";

package/types/resource-deserialize/resources/parser/HierarchyParser.d.ts

@@ -1,43 +1,38 @@
 import { Engine, Entity, Scene } from "@galacean/engine-core";
 import { PrefabResource } from "../../../prefab/PrefabResource";
-import type { IEntity, IHierarchyFile } from "../schema";
+import type { HierarchyFile } from "../../../schema/HierarchySchema";
 import { ParserContext } from "./ParserContext";
 import { ReflectionParser } from "./ReflectionParser";
 /** @Internal */
-export declare abstract class HierarchyParser<T extends Scene | PrefabResource, V extends ParserContext<IHierarchyFile, T>> {
-    readonly data: IHierarchyFile;
+export declare abstract class HierarchyParser<T extends Scene | PrefabResource, V extends ParserContext> {
+    readonly data: HierarchyFile;
     readonly context: V;
-    /**
-     * The promise of parsed object.
-     */
     readonly promise: Promise<T>;
     protected _resolve: (item: T) => void;
     protected _reject: (reason: any) => void;
     protected _engine: Engine;
     protected _reflectionParser: ReflectionParser;
-    private _prefabContextMap;
-    private _prefabPromiseMap;
-    constructor(data: IHierarchyFile, context: V);
-    /** start parse the scene or prefab or others */
+    constructor(data: HierarchyFile, context: V);
     start(): void;
-    protected _applyEntityData(entity: Entity, entityConfig?: IEntity): Entity;
-    protected abstract _handleRootEntity(id: string): void;
+    /** Root entity indices for this hierarchy (scene.entities or [prefab.root]). */
+    protected abstract _getRootIndices(): number[];
+    protected abstract _handleRootEntity(index: number): void;
     protected abstract _clearAndResolve(): Scene | PrefabResource;
+    protected _onEntityCreated(_entity: Entity): void;
     private _parseEntities;
-    private _parseComponents;
-    private _parsePrefabModification;
-    private _parseAddedComponents;
-    private _parsePrefabRemovedEntities;
-    private _parsePrefabRemovedComponents;
     private _organizeEntities;
-    private _getEntityByConfig;
-    private _parseEntity;
-    private _parsePrefab;
-    private _parseStrippedEntity;
-    private _parseChildren;
-    private _addComponents;
-    private _generateInstanceContext;
-    private _parseComponentsPropsAndMethods;
-    private _addComponentPlugin;
-    private _addEntityPlugin;
+    private _parseComponents;
+    private _parseComponentsPropsAndCalls;
+    private _parsePrefabOverrides;
+    private _applyOverrides;
+    private _loadPrefabInstance;
+    /** Resolve an entity inside a prefab instance by walking the child-index path from root */
+    private static _resolveEntity;
+    /** Resolve a component on an entity by type name + per-type index */
+    private static _resolveComponent;
+    /** Resolve component class from config and add to entity. Throws if class is not registered. */
+    private static _addComponentFromConfig;
+    private static _isPrefabInstanceEntity;
+    /** Apply entity-level props (name, isActive, layer, transform) to an entity. */
+    private static _applyEntityProps;
 }

package/types/resource-deserialize/resources/parser/ParserContext.d.ts

@@ -1,5 +1,5 @@
-import { AssetPromise, Component, Engine, EngineObject, Entity, ReferResource, ResourceManager, Scene } from "@galacean/engine-core";
-import type { IEntity, IHierarchyFile } from "../schema";
+import { AssetPromise, Component, Engine, Entity, ReferResource, ResourceManager, Scene } from "@galacean/engine-core";
+import type { ComponentSchema } from "../../../schema/HierarchySchema";
 export declare enum ParserType {
     Prefab = 0,
     Scene = 1
@@ -7,18 +7,18 @@ export declare enum ParserType {
 /**
  * @internal
  */
-export declare class ParserContext<T extends IHierarchyFile, I extends EngineObject> {
+export declare class ParserContext {
     readonly engine: Engine;
     readonly type: ParserType;
     readonly resource: ReferResource | Scene;
-    entityMap: Map<string, Entity>;
-    entityConfigMap: Map<string, IEntity>;
-    components: Map<string, Component>;
-    componentConfigMap: Map<string, any>;
-    rootIds: string[];
-    strippedIds: string[];
+    /** Runtime Entity instances, indexed by the flat entities[] position. */
+    entityInstances: Entity[];
+    /** Components waiting for props/calls application (Stage 4). */
+    pendingComponents: Array<{
+        instance: Component;
+        config: ComponentSchema;
+    }>;
     readonly resourceManager: ResourceManager;
-    private _tasks;
     private _loaded;
     private _total;
     constructor(engine: Engine, type: ParserType, resource: ReferResource | Scene);
@@ -26,5 +26,5 @@ export declare class ParserContext<T extends IHierarchyFile, I extends EngineObj
     /** @internal */
     _setTaskCompleteProgress: (loaded: number, total: number) => void;
     /** @internal */
-    _addDependentAsset(url: string, promise: AssetPromise<any>): void;
+    _addDependentAsset(promise: AssetPromise<any>): void;
 }

package/types/resource-deserialize/resources/parser/ReflectionParser.d.ts

@@ -1,22 +1,41 @@
-import { EngineObject, Entity, Signal } from "@galacean/engine-core";
-import type { IBasicType, IClass, IEntity, IHierarchyFile, IMethodParams, ISignalRef } from "../schema";
+import { Component } from "@galacean/engine-core";
+import type { CallSpec, MutationBlock, RefItem } from "../../../schema/CommonSchema";
 import { ParserContext } from "./ParserContext";
 export declare class ReflectionParser {
     private readonly _context;
-    constructor(_context: ParserContext<IHierarchyFile, EngineObject>);
-    parseEntity(entityConfig: IEntity): Promise<Entity>;
-    parseClassObject(item: IClass): Promise<any>;
-    parsePropsAndMethods(instance: any, item: Omit<IClass, "class">): Promise<any>;
-    parseMethod(instance: any, methodName: string, methodParams: IMethodParams): Promise<any>;
-    parseSignal(signalRef: ISignalRef): Promise<Signal>;
-    parseBasicType(value: IBasicType, originValue?: any): Promise<any>;
-    private _getEntityByConfig;
-    private _resolveEntityByPath;
-    private static _isClass;
-    private static _isClassType;
-    private static _isAssetRef;
-    private static _isEntityRef;
-    private static _isComponentRef;
-    private static _isSignalRef;
-    private static _isMethodObject;
+    private readonly _refs;
+    /** @internal shared with HierarchyParser; each use must length=0 -> getComponents -> read -> length=0 synchronously. */
+    static _componentBuffer: Component[];
+    constructor(_context: ParserContext, _refs: RefItem[]);
+    /**
+     * Apply v2 props to a component/object instance.
+     * Each prop value is resolved recursively (handling $ref, $type, $entity, $component, $signal).
+     */
+    parseProps(instance: any, props?: Record<string, unknown>): Promise<any>;
+    /**
+     * Execute calls sequentially on a target instance.
+     * Call args are resolved with the same v2 value rules as props.
+     */
+    parseCalls(instance: any, calls?: CallSpec[]): Promise<any>;
+    /**
+     * Apply props and calls from the same mutation block without imposing ordering between them.
+     */
+    parseMutationBlock(target: any, block?: MutationBlock): Promise<any>;
+    /**
+     * Resolve a v2 value with $ prefix detection.
+     *
+     * Priority:
+     * 1. null/undefined/primitive → passthrough
+     * 2. Array → recurse each element
+     * 3. { $ref }       → asset reference
+     * 4. { $type }      → polymorphic type construct
+     * 5. { $entity }    → entity reference by path (flat index + optional children descent)
+     * 6. { $component } → component reference
+     * 7. { $signal }    → signal binding
+     * 8. plain object   → recurse values (modify originValue in place if exists)
+     */
+    private _resolveValue;
+    private _resolveSignal;
+    private _resolveComponent;
+    private _resolveEntityRef;
 }

package/types/resource-deserialize/resources/scene/SceneParser.d.ts

@@ -1,17 +1,16 @@
 import { Scene } from "@galacean/engine-core";
+import type { SceneFile } from "../../../schema/SceneSchema";
 import { HierarchyParser } from "../parser/HierarchyParser";
 import { ParserContext } from "../parser/ParserContext";
-import { type IScene } from "../schema";
 /** @Internal */
-export declare class SceneParser extends HierarchyParser<Scene, ParserContext<IScene, Scene>> {
+export declare class SceneParser extends HierarchyParser<Scene, ParserContext> {
     readonly scene: Scene;
-    constructor(data: IScene, context: ParserContext<IScene, Scene>, scene: Scene);
+    constructor(data: SceneFile, context: ParserContext, scene: Scene);
     /**
      * @internal
      */
-    _collectDependentAssets(data: IScene): void;
-    protected _handleRootEntity(id: string): void;
+    _collectDependentAssets(data: SceneFile): void;
+    protected _getRootIndices(): number[];
+    protected _handleRootEntity(index: number): void;
     protected _clearAndResolve(): Scene;
-    private _parseDependentAssets;
-    private _searchDependentAssets;
 }

package/types/schema/BasicSchema.d.ts

@@ -0,0 +1,21 @@
+export interface IVector3 {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface IVector2 {
+    x: number;
+    y: number;
+}
+export interface IVector4 {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+}
+export interface IColor {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+}

package/types/schema/CommonSchema.d.ts

@@ -0,0 +1,29 @@
+export type Vec3Tuple = [number, number, number];
+export type Vec4Tuple = [number, number, number, number];
+export interface RefItem {
+    url: string;
+    key?: string;
+}
+/** path[0] = flat index into top-level entities[]; subsequent indices descend via children. */
+export type EntityRef = number[];
+export interface ComponentRef {
+    entity: EntityRef;
+    type: string;
+    index: number;
+}
+export interface SignalListener {
+    target: {
+        $component: ComponentRef;
+    };
+    methodName: string;
+    args?: unknown[];
+}
+export interface CallSpec {
+    method: string;
+    args?: unknown[];
+    result?: MutationBlock;
+}
+export interface MutationBlock {
+    props?: Record<string, unknown>;
+    calls?: CallSpec[];
+}

package/types/schema/HierarchySchema.d.ts

@@ -0,0 +1,71 @@
+import type { MutationBlock, RefItem, Vec3Tuple } from "./CommonSchema";
+export interface ComponentSchema extends MutationBlock {
+    type: string;
+    script?: number;
+}
+export interface EntityOverrideProps {
+    name?: string;
+    isActive?: boolean;
+    layer?: number;
+    position?: Vec3Tuple;
+    rotation?: Vec3Tuple;
+    scale?: Vec3Tuple;
+}
+export interface AddedEntityOverride {
+    /** Parent path from prefab instance root via children indices. `[]` = instance root. */
+    parent: number[];
+    /** Index into the top-level entities[] array. */
+    entity: number;
+}
+export interface AddedComponentOverride {
+    /** Target entity path from prefab instance root via children indices. `[]` = instance root. */
+    target: number[];
+    /** Index into the top-level components[] array. */
+    component: number;
+}
+export interface EntityPropOverride extends EntityOverrideProps {
+    /** Path from prefab instance root via children indices. `[]` = instance root. */
+    path: number[];
+}
+export interface ComponentSelector {
+    type: string;
+    index: number;
+}
+export interface ComponentOverride extends MutationBlock {
+    /** Path from prefab instance root via children indices. `[]` = instance root. */
+    path: number[];
+    selector: ComponentSelector;
+}
+export interface RemovedComponentOverride {
+    /** Path from prefab instance root via children indices. `[]` = instance root. */
+    path: number[];
+    selectors: ComponentSelector[];
+}
+export interface InstanceOverrides {
+    entityProps?: EntityPropOverride[];
+    componentProps?: ComponentOverride[];
+    /** Each element is a path from prefab instance root via children indices. */
+    removedEntities?: number[][];
+    removedComponents?: RemovedComponentOverride[];
+    addedEntities?: AddedEntityOverride[];
+    addedComponents?: AddedComponentOverride[];
+}
+export interface InstanceSchema {
+    asset: number;
+    overrides?: InstanceOverrides;
+}
+export interface NormalEntitySchema extends EntityOverrideProps {
+    children?: number[];
+    components?: number[];
+}
+export interface PrefabInstanceEntitySchema {
+    instance: InstanceSchema;
+}
+export type EntitySchema = NormalEntitySchema | PrefabInstanceEntitySchema;
+/** Common base for v2 scene and prefab files. */
+export interface HierarchyFile {
+    version: "2.0";
+    refs: RefItem[];
+    entities: EntitySchema[];
+    components: ComponentSchema[];
+}

package/types/schema/MaterialSchema.d.ts

@@ -0,0 +1,70 @@
+import { BlendFactor, BlendOperation, ColorWriteMask, CompareFunction, CullMode, RenderQueueType, StencilOperation } from "@galacean/engine-core";
+import type { RefItem } from "./CommonSchema";
+import type { IColor, IVector2, IVector3 } from "./BasicSchema";
+export interface IRenderState {
+    blendState: {
+        targetBlendState: {
+            enabled: boolean;
+            colorBlendOperation: BlendOperation;
+            alphaBlendOperation: BlendOperation;
+            sourceColorBlendFactor: BlendFactor;
+            sourceAlphaBlendFactor: BlendFactor;
+            destinationColorBlendFactor: BlendFactor;
+            destinationAlphaBlendFactor: BlendFactor;
+            colorWriteMask: ColorWriteMask;
+        };
+        blendColor: IColor;
+        alphaToCoverage: boolean;
+    };
+    depthState: {
+        enabled: boolean;
+        writeEnabled: boolean;
+        compareFunction: CompareFunction;
+    };
+    stencilState: {
+        enabled: boolean;
+        referenceValue: number;
+        mask: number;
+        writeMask: number;
+        compareFunctionFront: CompareFunction;
+        compareFunctionBack: CompareFunction;
+        passOperationFront: StencilOperation;
+        passOperationBack: StencilOperation;
+        failOperationFront: StencilOperation;
+        failOperationBack: StencilOperation;
+        zFailOperationFront: StencilOperation;
+        zFailOperationBack: StencilOperation;
+    };
+    rasterState: {
+        cullMode: CullMode;
+        depthBias: number;
+        slopeScaledDepthBias: number;
+    };
+    renderQueueType: RenderQueueType;
+}
+export interface IMaterialSchema {
+    name: string;
+    shader: string;
+    shaderData: {
+        [key: string]: {
+            type: MaterialLoaderType;
+            value: IVector3 | IVector2 | IColor | number | RefItem;
+        };
+    };
+    macros: Array<{
+        name: string;
+        value?: string;
+    }>;
+    renderState: IRenderState;
+    shaderRef: RefItem;
+}
+export declare enum MaterialLoaderType {
+    Vector2 = "Vector2",
+    Vector3 = "Vector3",
+    Vector4 = "Vector4",
+    Color = "Color",
+    Float = "Float",
+    Texture = "Texture",
+    Boolean = "Boolean",
+    Integer = "Integer"
+}

package/types/schema/PrefabSchema.d.ts

@@ -0,0 +1,4 @@
+import type { HierarchyFile } from "./HierarchySchema";
+export interface PrefabFile extends HierarchyFile {
+    root: number;
+}

package/types/schema/SceneSchema.d.ts

@@ -0,0 +1,59 @@
+import { BackgroundMode, BackgroundTextureFillMode, DiffuseMode, FogMode, ShadowCascadesMode, ShadowResolution } from "@galacean/engine-core";
+import type { HierarchyFile } from "./HierarchySchema";
+import type { Vec3Tuple, Vec4Tuple } from "./CommonSchema";
+export declare enum SpecularMode {
+    Sky = "Sky",
+    Custom = "Custom"
+}
+export interface SceneFile extends HierarchyFile {
+    scene: {
+        name?: string;
+        entities: number[];
+        background: {
+            mode: BackgroundMode;
+            color: Vec4Tuple;
+            texture?: number;
+            textureFillMode?: BackgroundTextureFillMode;
+            skyMesh?: number;
+            skyMaterial?: number;
+        };
+        ambient?: {
+            diffuseMode: DiffuseMode;
+            ambientLight?: number;
+            customAmbientLight?: number;
+            diffuseSolidColor?: Vec4Tuple;
+            diffuseIntensity: number;
+            specularIntensity: number;
+            specularMode: SpecularMode;
+        };
+        shadow?: {
+            castShadows?: boolean;
+            enableTransparentShadow?: boolean;
+            shadowResolution?: ShadowResolution;
+            shadowDistance?: number;
+            shadowCascades?: ShadowCascadesMode;
+            shadowTwoCascadeSplits?: number;
+            shadowFourCascadeSplits?: Vec3Tuple;
+            shadowFadeBorder?: number;
+        };
+        fog?: {
+            fogMode?: FogMode;
+            fogStart?: number;
+            fogEnd?: number;
+            fogDensity?: number;
+            fogColor?: Vec4Tuple;
+        };
+        ambientOcclusion?: {
+            enabledAmbientOcclusion?: boolean;
+            quality?: number;
+            intensity?: number;
+            radius?: number;
+            bias?: number;
+            power?: number;
+            bilateralThreshold?: number;
+            minHorizonAngle?: number;
+        };
+        /** Not supported in scene yet; presence triggers a warning. */
+        postProcess?: unknown;
+    };
+}

package/types/{resource-deserialize/resources/schema → schema}/index.d.ts

@@ -1,4 +1,7 @@
+export * from "./CommonSchema";
+export * from "./HierarchySchema";
+export * from "./SceneSchema";
+export * from "./PrefabSchema";
 export * from "./BasicSchema";
 export * from "./MaterialSchema";
 export * from "./ProjectSchema";
-export * from "./SceneSchema";

package/types/schema/refs.d.ts

@@ -0,0 +1,2 @@
+import type { RefItem } from "./CommonSchema";
+export declare function resolveRefItem(refs: RefItem[], index: number, owner: string, label: string): RefItem;

package/types/resource-deserialize/resources/schema/BasicSchema.d.ts

@@ -1,105 +0,0 @@
-import { Layer } from "@galacean/engine-core";
-export interface IVector3 {
-    x: number;
-    y: number;
-    z: number;
-}
-export interface IVector2 {
-    x: number;
-    y: number;
-}
-export interface IVector4 {
-    x: number;
-    y: number;
-    z: number;
-    w: number;
-}
-export interface IColor {
-    r: number;
-    g: number;
-    b: number;
-    a: number;
-}
-export interface IHierarchyFile {
-    entities: Array<IEntity>;
-}
-export type IMethod = {
-    params: Array<IBasicType>;
-    result?: IInstance;
-};
-export type IMethodParams = Array<IBasicType> | IMethod;
-export interface IBasicEntity {
-    name?: string;
-    id?: string;
-    transform?: IComponent;
-    components?: Array<IComponent>;
-    isActive?: boolean;
-    position?: IVector3;
-    rotation?: IVector3;
-    scale?: IVector3;
-    children?: Array<string>;
-    parent?: string;
-    layer?: Layer;
-}
-export type IEntity = IBasicEntity | IRefEntity | IStrippedEntity;
-export interface IRefEntity extends IBasicEntity {
-    assetUrl: string;
-    key?: string;
-    isClone?: boolean;
-    modifications: (IInstance & {
-        target: IPrefabModifyTarget;
-    })[];
-    removedEntities: IPrefabModifyTarget[];
-    removedComponents: IPrefabModifyTarget[];
-}
-export interface IPrefabModifyTarget {
-    entityId?: string;
-    componentId?: string;
-}
-export interface IStrippedEntity extends IBasicEntity {
-    strippedId: string;
-    prefabInstanceId: string;
-    prefabSource: {
-        assetId: string;
-        entityId: string;
-    };
-}
-export type IComponent = {
-    id: string;
-    url?: string;
-} & IClass;
-export type IClass = {
-    class: string;
-    constructParams?: Array<IBasicType>;
-} & IInstance;
-export interface IInstance {
-    methods?: {
-        [methodName: string]: Array<IMethodParams>;
-    };
-    props?: {
-        [key: string]: IBasicType | IMethodParams;
-    };
-}
-export type IClassType = {
-    classType: string;
-};
-export type IBasicType = string | number | boolean | null | undefined | IAssetRef | IClass | IClassType | IMethodParams | IEntityRef | IComponentRef | ISignalRef;
-export type IAssetRef = {
-    key?: string;
-    url: string;
-};
-export type IEntityRef = {
-    entityPath: number[];
-};
-export type IComponentRef = {
-    entityPath: number[];
-    componentType: string;
-    componentIndex: number;
-};
-export type ISignalRef = {
-    listeners: Array<{
-        target: IComponentRef;
-        methodName: string;
-        arguments?: Array<IBasicType>;
-    }>;
-};