@flowgram-vue/variable-core 0.2.0

package/dist/index.d.ts

@@ -0,0 +1,2293 @@
+import { ContainerModule, interfaces } from 'inversify';
+import * as _flowgram_vue_utils from '@flowgram-vue/utils';
+import { Disposable, Emitter, DisposableCollection, Event } from '@flowgram-vue/utils';
+import { Subject, Observable, BehaviorSubject, Observer as Observer$1 } from 'rxjs';
+export { Observer } from 'rxjs';
+import * as vue from 'vue';
+import { InjectionKey, ComputedRef, PropType } from 'vue';
+
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+/**
+ * An InversifyJS container module that binds all the necessary services for the variable engine.
+ * This module sets up the dependency injection for the core components of the variable engine.
+ */
+declare const VariableContainerModule: ContainerModule;
+
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+/**
+ * A provider for dynamically obtaining the `VariableEngine` instance.
+ * This is used to prevent circular dependencies when injecting `VariableEngine`.
+ */
+declare const VariableEngineProvider: unique symbol;
+type VariableEngineProvider = () => VariableEngine;
+
+/**
+ * Manages the output variables of a scope.
+ */
+declare class ScopeOutputData {
+    readonly scope: Scope;
+    protected variableTable: IVariableTable;
+    protected memo: {
+        <T>(key: string | symbol, fn: () => T): T;
+        clear: (key?: string | symbol) => void;
+    };
+    /**
+     * The variable engine instance.
+     */
+    get variableEngine(): VariableEngine;
+    /**
+     * The global variable table from the variable engine.
+     */
+    get globalVariableTable(): IVariableTable;
+    /**
+     * The current version of the output data, which increments on each change.
+     */
+    get version(): number;
+    /**
+     * @deprecated use onListOrAnyVarChange instead
+     */
+    get onDataChange(): _flowgram_vue_utils.Event<void>;
+    /**
+     * An event that fires when the list of output variables changes.
+     */
+    get onVariableListChange(): (observer: (variables: VariableDeclaration[]) => void) => _flowgram_vue_utils.Disposable;
+    /**
+     * An event that fires when any output variable's value changes.
+     */
+    get onAnyVariableChange(): (observer: (changedVariable: VariableDeclaration) => void) => _flowgram_vue_utils.Disposable;
+    /**
+     * An event that fires when the output variable list changes or any variable's value is updated.
+     */
+    get onListOrAnyVarChange(): (observer: () => void) => _flowgram_vue_utils.Disposable;
+    protected _hasChanges: boolean;
+    constructor(scope: Scope);
+    /**
+     * The output variable declarations of the scope, sorted by order.
+     */
+    get variables(): VariableDeclaration[];
+    /**
+     * The keys of the output variables.
+     */
+    get variableKeys(): string[];
+    protected addVariableToTable(variable: VariableDeclaration): void;
+    protected removeVariableFromTable(key: string): void;
+    /**
+     * Retrieves a variable declaration by its key.
+     * @param key The key of the variable.
+     * @returns The `VariableDeclaration` or `undefined` if not found.
+     */
+    getVariableByKey(key: string): VariableDeclaration<any> | undefined;
+    /**
+     * Notifies the covering scopes that the available variables have changed.
+     */
+    notifyCoversChange(): void;
+}
+
+/**
+ * Manages the available variables within a scope.
+ */
+declare class ScopeAvailableData {
+    readonly scope: Scope;
+    protected memo: {
+        <T>(key: string | symbol, fn: () => T): T;
+        clear: (key?: string | symbol) => void;
+    };
+    /**
+     * The global variable table from the variable engine.
+     */
+    get globalVariableTable(): IVariableTable;
+    protected _version: number;
+    protected refresh$: Subject<void>;
+    protected _variables: VariableDeclaration[];
+    /**
+     * The current version of the available data, which increments on each change.
+     */
+    get version(): number;
+    protected bumpVersion(): void;
+    /**
+     * Refreshes the list of available variables.
+     * This should be called when the dependencies of the scope change.
+     */
+    refresh(): void;
+    /**
+     * An observable that emits when the list of available variables changes.
+     */
+    protected variables$: Observable<VariableDeclaration[]>;
+    /**
+     * An observable that emits when any variable in the available list changes its value.
+     */
+    protected anyVariableChange$: Observable<VariableDeclaration>;
+    /**
+     * Subscribes to changes in any variable's value in the available list.
+     * @param observer A function to be called with the changed variable.
+     * @returns A disposable to unsubscribe from the changes.
+     */
+    onAnyVariableChange(observer: (changedVariable: VariableDeclaration) => void): Disposable;
+    /**
+     * Subscribes to changes in the list of available variables.
+     * @param observer A function to be called with the new list of variables.
+     * @returns A disposable to unsubscribe from the changes.
+     */
+    onVariableListChange(observer: (variables: VariableDeclaration[]) => void): Disposable;
+    /**
+     * @deprecated
+     */
+    protected onDataChangeEmitter: Emitter<VariableDeclaration<any>[]>;
+    protected onListOrAnyVarChangeEmitter: Emitter<VariableDeclaration<any>[]>;
+    /**
+     * @deprecated use available.onListOrAnyVarChange instead
+     */
+    onDataChange: _flowgram_vue_utils.Event<VariableDeclaration<any>[]>;
+    /**
+     * An event that fires when the variable list changes or any variable's value is updated.
+     */
+    onListOrAnyVarChange: _flowgram_vue_utils.Event<VariableDeclaration<any>[]>;
+    constructor(scope: Scope);
+    /**
+     * Gets the list of available variables.
+     */
+    get variables(): VariableDeclaration[];
+    /**
+     * Gets the keys of the available variables.
+     */
+    get variableKeys(): string[];
+    /**
+     * Gets the dependency scopes.
+     */
+    get depScopes(): Scope[];
+    /**
+     * Retrieves a variable field by its key path from the available variables.
+     * @param keyPath The key path to the variable field.
+     * @returns The found `BaseVariableField` or `undefined`.
+     */
+    getByKeyPath(keyPath?: string[]): BaseVariableField | undefined;
+    /**
+     * Tracks changes to a variable field by its key path.
+     * This includes changes to its type, value, or any nested properties.
+     * @param keyPath The key path to the variable field to track.
+     * @param cb The callback to execute when the variable changes.
+     * @param opts Configuration options for the subscription.
+     * @returns A disposable to unsubscribe from the tracking.
+     */
+    trackByKeyPath<Data = BaseVariableField | undefined>(keyPath: string[] | undefined, cb: (variable?: Data) => void, opts?: SubscribeConfig<BaseVariableField | undefined, Data>): Disposable;
+}
+
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+type Observer<ActionType extends GlobalEventActionType = GlobalEventActionType> = (action: ActionType) => void;
+/**
+ * Manages global events within a scope.
+ */
+declare class ScopeEventData {
+    readonly scope: Scope;
+    event$: Subject<GlobalEventActionType>;
+    /**
+     * Dispatches a global event.
+     * @param action The event action to dispatch.
+     */
+    dispatch<ActionType extends GlobalEventActionType = GlobalEventActionType>(action: ActionType): void;
+    /**
+     * Subscribes to all global events.
+     * @param observer The observer function to call with the event action.
+     * @returns A disposable to unsubscribe from the events.
+     */
+    subscribe<ActionType extends GlobalEventActionType = GlobalEventActionType>(observer: Observer<ActionType>): Disposable;
+    /**
+     * Subscribes to a specific type of global event.
+     * @param type The type of the event to subscribe to.
+     * @param observer The observer function to call with the event action.
+     * @returns A disposable to unsubscribe from the event.
+     */
+    on<ActionType extends GlobalEventActionType = GlobalEventActionType>(type: ActionType['type'], observer: Observer<ActionType>): Disposable;
+    constructor(scope: Scope);
+}
+
+/**
+ * Interface for the Scope constructor.
+ */
+interface IScopeConstructor {
+    new (options: {
+        id: string | symbol;
+        variableEngine: VariableEngine;
+        meta?: Record<string, any>;
+    }): Scope;
+}
+/**
+ * Represents a variable scope, which manages its own set of variables and their lifecycle.
+ * - `scope.output` represents the variables declared within this scope.
+ * - `scope.available` represents all variables accessible from this scope, including those from parent scopes.
+ */
+declare class Scope<ScopeMeta extends Record<string, any> = Record<string, any>> {
+    /**
+     * A unique identifier for the scope.
+     */
+    readonly id: string | symbol;
+    /**
+     * The variable engine instance this scope belongs to.
+     */
+    readonly variableEngine: VariableEngine;
+    /**
+     * Metadata associated with the scope, which can be extended by higher-level business logic.
+     */
+    readonly meta: ScopeMeta;
+    /**
+     * The root AST node for this scope, which is a MapNode.
+     * It stores various data related to the scope, such as `outputs`.
+     */
+    readonly ast: MapNode;
+    /**
+     * Manages the available variables for this scope.
+     */
+    readonly available: ScopeAvailableData;
+    /**
+     * Manages the output variables for this scope.
+     */
+    readonly output: ScopeOutputData;
+    /**
+     * Manages event dispatching and handling for this scope.
+     */
+    readonly event: ScopeEventData;
+    /**
+     * A memoization utility for caching computed values.
+     */
+    protected memo: {
+        <T>(key: string | symbol, fn: () => T): T;
+        clear: (key?: string | symbol) => void;
+    };
+    toDispose: DisposableCollection;
+    constructor(options: {
+        id: string | symbol;
+        variableEngine: VariableEngine;
+        meta?: ScopeMeta;
+    });
+    /**
+     * Refreshes the covering scopes.
+     */
+    refreshCovers(): void;
+    /**
+     * Refreshes the dependency scopes and the available variables.
+     */
+    refreshDeps(): void;
+    /**
+     * Gets the scopes that this scope depends on.
+     */
+    get depScopes(): Scope[];
+    /**
+     * Gets the scopes that are covered by this scope.
+     */
+    get coverScopes(): Scope[];
+    /**
+     * Disposes of the scope and its resources.
+     * This will also trigger updates in dependent and covering scopes.
+     */
+    dispose(): void;
+    onDispose: _flowgram_vue_utils.Event<void>;
+    get disposed(): boolean;
+    /**
+     * Sets a variable in the scope with the default key 'outputs'.
+     *
+     * @param json The JSON representation of the AST node to set.
+     * @returns The created or updated AST node.
+     */
+    setVar<Node extends ASTNode = ASTNode>(json: ASTNodeJSON): Node;
+    /**
+     * Sets a variable in the scope with a specified key.
+     *
+     * @param key The key of the variable to set.
+     * @param json The JSON representation of the AST node to set.
+     * @returns The created or updated AST node.
+     */
+    setVar<Node extends ASTNode = ASTNode>(key: string, json: ASTNodeJSON): Node;
+    /**
+     * Retrieves a variable from the scope by its key.
+     *
+     * @param key The key of the variable to retrieve. Defaults to 'outputs'.
+     * @returns The AST node for the variable, or `undefined` if not found.
+     */
+    getVar<Node extends ASTNode = ASTNode>(key?: string): Node | undefined;
+    /**
+     * Clears a variable from the scope by its key.
+     *
+     * @param key The key of the variable to clear. Defaults to 'outputs'.
+     */
+    clearVar(key?: string): void;
+}
+
+/**
+ * Manages the dependency relationships between scopes.
+ * This is an abstract class, and specific implementations determine how the scope order is managed.
+ */
+declare abstract class ScopeChain {
+    readonly toDispose: DisposableCollection;
+    variableEngineProvider: VariableEngineProvider;
+    get variableEngine(): VariableEngine;
+    constructor();
+    /**
+     * Refreshes the dependency and coverage relationships for all scopes.
+     */
+    refreshAllChange(): void;
+    /**
+     * Gets the dependency scopes for a given scope.
+     * @param scope The scope to get dependencies for.
+     * @returns An array of dependency scopes.
+     */
+    abstract getDeps(scope: Scope): Scope[];
+    /**
+     * Gets the covering scopes for a given scope.
+     * @param scope The scope to get covers for.
+     * @returns An array of covering scopes.
+     */
+    abstract getCovers(scope: Scope): Scope[];
+    /**
+     * Sorts all scopes based on their dependency relationships.
+     * @returns A sorted array of all scopes.
+     */
+    abstract sortAll(): Scope[];
+    dispose(): void;
+    get disposed(): boolean;
+    get onDispose(): Event<void>;
+}
+
+interface ASTNodeRegistry<JSON extends ASTNodeJSON = any> {
+    kind: string;
+    new (params: CreateASTParams, injectOpts: any): ASTNode<JSON>;
+}
+/**
+ * An `ASTNode` represents a fundamental unit of variable information within the system's Abstract Syntax Tree.
+ * It can model various constructs, for example:
+ * - **Declarations**: `const a = 1`
+ * - **Expressions**: `a.b.c`
+ * - **Types**: `number`, `string`, `boolean`
+ *
+ * Here is some characteristic of ASTNode:
+ * - **Tree-like Structure**: ASTNodes can be nested to form a tree, representing complex variable structures.
+ * - **Extendable**: New features can be added by extending the base ASTNode class.
+ * - **Reactive**: Changes in an ASTNode's value trigger events, enabling reactive programming patterns.
+ * - **Serializable**: ASTNodes can be converted to and from a JSON format (ASTNodeJSON) for storage or transmission.
+ */
+declare abstract class ASTNode<JSON extends ASTNodeJSON = any> implements Disposable {
+    /**
+     * @deprecated
+     * Get the injected options for the ASTNode.
+     *
+     * Please use `@injectToAst(XXXService) declare xxxService: XXXService` to achieve external dependency injection.
+     */
+    readonly opts?: any;
+    /**
+     * The unique identifier of the ASTNode, which is **immutable**.
+     * - Immutable: Once assigned, the key cannot be changed.
+     * - Automatically generated if not specified, and cannot be changed as well.
+     * - If a new key needs to be generated, the current ASTNode should be destroyed and a new ASTNode should be generated.
+     */
+    readonly key: Identifier;
+    /**
+     * The kind of the ASTNode.
+     */
+    static readonly kind: ASTKindType;
+    /**
+     * Node flags, used to record some flag information.
+     */
+    readonly flags: number;
+    /**
+     * The scope in which the ASTNode is located.
+     */
+    readonly scope: Scope;
+    /**
+     * The parent ASTNode.
+     */
+    readonly parent: ASTNode | undefined;
+    /**
+     * The version number of the ASTNode, which increments by 1 each time `fireChange` is called.
+     */
+    protected _version: number;
+    /**
+     * Update lock.
+     * - When set to `true`, `fireChange` will not trigger any events.
+     * - This is useful when multiple updates are needed, and you want to avoid multiple triggers.
+     */
+    changeLocked: boolean;
+    /**
+     * Parameters related to batch updates.
+     */
+    private _batch;
+    /**
+     * AST node change Observable events, implemented based on RxJS.
+     * - Emits the current ASTNode value upon subscription.
+     * - Emits a new value whenever `fireChange` is called.
+     */
+    readonly value$: BehaviorSubject<ASTNode>;
+    /**
+     * Child ASTNodes.
+     */
+    protected _children: Set<ASTNode<any>>;
+    /**
+     * List of disposal handlers for the ASTNode.
+     */
+    readonly toDispose: DisposableCollection;
+    /**
+     * Callback triggered upon disposal.
+     */
+    onDispose: _flowgram_vue_utils.Event<void>;
+    /**
+     * Constructor.
+     * @param createParams Necessary parameters for creating an ASTNode.
+     * @param injectOptions Dependency injection for various modules.
+     */
+    constructor({ key, parent, scope }: CreateASTParams, opts?: any);
+    /**
+     * The type of the ASTNode.
+     */
+    get kind(): string;
+    /**
+     * Parses AST JSON data.
+     * @param json AST JSON data.
+     */
+    abstract fromJSON(json: JSON): void;
+    /**
+     * Gets all child ASTNodes of the current ASTNode.
+     */
+    get children(): ASTNode[];
+    /**
+     * Serializes the current ASTNode to ASTNodeJSON.
+     * @returns
+     */
+    abstract toJSON(): JSON;
+    /**
+     * Creates a child ASTNode.
+     * @param json The AST JSON of the child ASTNode.
+     * @returns
+     */
+    protected createChildNode<ChildNode extends ASTNode = ASTNode>(json: ASTNodeJSON): ChildNode;
+    /**
+     * Updates a child ASTNode, quickly implementing the consumption logic for child ASTNode updates.
+     * @param keyInThis The specified key on the current object.
+     */
+    protected updateChildNodeByKey(keyInThis: keyof this, nextJSON?: ASTNodeJSON): void;
+    /**
+     * Batch updates the ASTNode, merging all `fireChange` calls within the batch function into one.
+     * @param updater The batch function.
+     * @returns
+     */
+    protected withBatchUpdate<ParamTypes extends any[], ReturnType>(updater: (...args: ParamTypes) => ReturnType): (...args: ParamTypes) => ReturnType;
+    /**
+     * Triggers an update for the current node.
+     */
+    fireChange(): void;
+    /**
+     * The version value of the ASTNode.
+     * - You can used to check whether ASTNode are updated.
+     */
+    get version(): number;
+    /**
+     * The unique hash value of the ASTNode.
+     * - It will update when the ASTNode is updated.
+     * - You can used to check two ASTNode are equal.
+     */
+    get hash(): string;
+    /**
+     * Listens for changes to the ASTNode.
+     * @param observer The listener callback.
+     * @param selector Listens for specified data.
+     * @returns
+     */
+    subscribe<Data = this>(observer: ObserverOrNext<Data>, { selector, debounceAnimation, triggerOnInit }?: SubscribeConfig<this, Data>): Disposable;
+    /**
+     * Dispatches a global event for the current ASTNode.
+     * @param event The global event.
+     */
+    dispatchGlobalEvent<ActionType extends GlobalEventActionType = GlobalEventActionType>(event: Omit<ActionType, 'ast'>): void;
+    /**
+     * Disposes the ASTNode.
+     */
+    dispose(): void;
+    get disposed(): boolean;
+    /**
+     * Extended information of the ASTNode.
+     */
+    [key: string]: unknown;
+}
+
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+type ASTKindType = string;
+type Identifier = string;
+/**
+ * ASTNodeJSON is the JSON representation of an ASTNode.
+ */
+interface ASTNodeJSON {
+    /**
+     * Kind is the type of the AST node.
+     */
+    kind?: ASTKindType;
+    /**
+     * Key is the unique identifier of the node.
+     * If not provided, the node will generate a default key value.
+     */
+    key?: Identifier;
+    [key: string]: any;
+}
+/**
+ * Core AST node types.
+ */
+declare enum ASTKind {
+    /**
+     * # Type-related.
+     * - A set of type AST nodes based on JSON types is implemented internally by default.
+     */
+    /**
+     * String type.
+     */
+    String = "String",
+    /**
+     * Number type.
+     */
+    Number = "Number",
+    /**
+     * Integer type.
+     */
+    Integer = "Integer",
+    /**
+     * Boolean type.
+     */
+    Boolean = "Boolean",
+    /**
+     * Object type.
+     */
+    Object = "Object",
+    /**
+     * Array type.
+     */
+    Array = "Array",
+    /**
+     * Map type.
+     */
+    Map = "Map",
+    /**
+     * Union type.
+     * Commonly used for type checking, generally not exposed to the business.
+     */
+    Union = "Union",
+    /**
+     * Any type.
+     * Commonly used for business logic.
+     */
+    Any = "Any",
+    /**
+     * Custom type.
+     * For business-defined types.
+     */
+    CustomType = "CustomType",
+    /**
+     * # Declaration-related.
+     */
+    /**
+     * Field definition for Object drill-down.
+     */
+    Property = "Property",
+    /**
+     * Variable declaration.
+     */
+    VariableDeclaration = "VariableDeclaration",
+    /**
+     * Variable declaration list.
+     */
+    VariableDeclarationList = "VariableDeclarationList",
+    /**
+     * # Expression-related.
+     */
+    /**
+     * Access fields on variables through the path system.
+     */
+    KeyPathExpression = "KeyPathExpression",
+    /**
+     * Iterate over specified data.
+     */
+    EnumerateExpression = "EnumerateExpression",
+    /**
+     * Wrap with Array Type.
+     */
+    WrapArrayExpression = "WrapArrayExpression",
+    /**
+     * # General-purpose AST nodes.
+     */
+    /**
+     * General-purpose List<ASTNode> storage node.
+     */
+    ListNode = "ListNode",
+    /**
+     * General-purpose data storage node.
+     */
+    DataNode = "DataNode",
+    /**
+     * General-purpose Map<string, ASTNode> storage node.
+     */
+    MapNode = "MapNode"
+}
+interface CreateASTParams {
+    scope: Scope;
+    key?: Identifier;
+    parent?: ASTNode;
+}
+type ASTNodeJSONOrKind = string | ASTNodeJSON;
+type ObserverOrNext<T> = Partial<Observer$1<T>> | ((value: T) => void);
+interface SubscribeConfig<This, Data> {
+    debounceAnimation?: boolean;
+    triggerOnInit?: boolean;
+    selector?: (curr: This) => Data;
+}
+/**
+ * TypeUtils to get the JSON representation of an AST node with a specific kind.
+ */
+type GetKindJSON<KindType extends string, JSON extends ASTNodeJSON> = {
+    kind: KindType;
+    key?: Identifier;
+} & JSON;
+/**
+ * TypeUtils to get the JSON representation of an AST node with a specific kind or just the kind string.
+ */
+type GetKindJSONOrKind<KindType extends string, JSON extends ASTNodeJSON> = ({
+    kind: KindType;
+    key?: Identifier;
+} & JSON) | KindType;
+/**
+ * Global event action type.
+ * - Global event might be dispatched from `ASTNode` or `Scope`.
+ */
+interface GlobalEventActionType<Type = string, Payload = any, AST extends ASTNode = ASTNode> {
+    type: Type;
+    payload?: Payload;
+    ast?: AST;
+}
+
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+type DataInjector = () => Record<string, any>;
+/**
+ * Register the AST node to the engine.
+ */
+declare class ASTRegisters {
+    /**
+     * @deprecated Please use `@injectToAst(XXXService) declare xxxService: XXXService` to achieve external dependency injection.
+     */
+    protected injectors: Map<ASTKindType, DataInjector>;
+    protected astMap: Map<ASTKindType, ASTNodeRegistry>;
+    /**
+     * Core AST node registration.
+     */
+    constructor();
+    /**
+     * Creates an AST node.
+     * @param param Creation parameters.
+     * @returns
+     */
+    createAST<ReturnNode extends ASTNode = ASTNode>(json: ASTNodeJSON, { parent, scope }: CreateASTParams): ReturnNode;
+    /**
+     * Gets the node Registry by AST node type.
+     * @param kind
+     * @returns
+     */
+    getASTRegistryByKind(kind: ASTKindType): ASTNodeRegistry<any> | undefined;
+    /**
+     * Registers an AST node.
+     * @param ASTNode
+     */
+    registerAST(ASTNode: ASTNodeRegistry, 
+    /**
+     * @deprecated Please use `@injectToAst(XXXService) declare xxxService: XXXService` to achieve external dependency injection.
+     */
+    injector?: DataInjector): void;
+}
+
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+/**
+ * ASTNode flags. Stored in the `flags` property of the `ASTNode`.
+ */
+declare enum ASTNodeFlags {
+    /**
+     * None.
+     */
+    None = 0,
+    /**
+     * Variable Field.
+     */
+    VariableField = 1,
+    /**
+     * Expression.
+     */
+    Expression = 4,
+    /**
+     * # Variable Type Flags
+     */
+    /**
+     *  Basic type.
+     */
+    BasicType = 8,
+    /**
+     * Drillable variable type.
+     */
+    DrilldownType = 16,
+    /**
+     * Enumerable variable type.
+     */
+    EnumerateType = 32,
+    /**
+     * Composite type, currently not in use.
+     */
+    UnionType = 64,
+    /**
+     * Variable type.
+     */
+    VariableType = 120
+}
+
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+/**
+ * Represents a general data node with no child nodes.
+ */
+declare class DataNode<Data = any> extends ASTNode {
+    static kind: string;
+    protected _data: Data;
+    /**
+     * The data of the node.
+     */
+    get data(): Data;
+    /**
+     * Deserializes the `DataNodeJSON` to the `DataNode`.
+     * @param json The `DataNodeJSON` to deserialize.
+     */
+    fromJSON(json: Data): void;
+    /**
+     * Serialize the `DataNode` to `DataNodeJSON`.
+     * @returns The JSON representation of `DataNode`.
+     */
+    toJSON(): {
+        kind: ASTKind;
+    } & Data;
+    /**
+     * Partially update the data of the node.
+     * @param nextData The data to be updated.
+     */
+    partialUpdate(nextData: Data): void;
+}
+
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+/**
+ * ASTNodeJSON representation of `ListNode`
+ */
+interface ListNodeJSON {
+    /**
+     * The list of nodes.
+     */
+    list: ASTNodeJSON[];
+}
+/**
+ * Represents a list of nodes.
+ */
+declare class ListNode extends ASTNode<ListNodeJSON> {
+    static kind: string;
+    protected _list: ASTNode[];
+    /**
+     * The list of nodes.
+     */
+    get list(): ASTNode[];
+    /**
+     * Deserializes the `ListNodeJSON` to the `ListNode`.
+     * @param json The `ListNodeJSON` to deserialize.
+     */
+    fromJSON({ list }: ListNodeJSON): void;
+    /**
+     * Serialize the `ListNode` to `ListNodeJSON`.
+     * @returns The JSON representation of `ListNode`.
+     */
+    toJSON(): {
+        kind: ASTKind;
+        list: any[];
+    };
+}
+
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+/**
+ * ASTNodeJSON representation of `MapNode`
+ */
+interface MapNodeJSON {
+    /**
+     * The map of nodes.
+     */
+    map: [string, ASTNodeJSON][];
+}
+/**
+ * Represents a map of nodes.
+ */
+declare class MapNode extends ASTNode<MapNodeJSON> {
+    static kind: string;
+    protected map: Map<string, ASTNode>;
+    /**
+     * Deserializes the `MapNodeJSON` to the `MapNode`.
+     * @param json The `MapNodeJSON` to deserialize.
+     */
+    fromJSON({ map }: MapNodeJSON): void;
+    /**
+     * Serialize the `MapNode` to `MapNodeJSON`.
+     * @returns The JSON representation of `MapNode`.
+     */
+    toJSON(): {
+        kind: ASTKind;
+        map: [string, ASTNode<any>][];
+    };
+    /**
+     * Set a node in the map.
+     * @param key The key of the node.
+     * @param nextJSON The JSON representation of the node.
+     * @returns The node instance.
+     */
+    set<Node extends ASTNode = ASTNode>(key: string, nextJSON: ASTNodeJSON): Node;
+    /**
+     * Remove a node from the map.
+     * @param key The key of the node.
+     */
+    remove(key: string): void;
+    /**
+     * Get a node from the map.
+     * @param key The key of the node.
+     * @returns The node instance if found, otherwise `undefined`.
+     */
+    get<Node extends ASTNode = ASTNode>(key: string): Node | undefined;
+}
+
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+/**
+ * Base class for all types.
+ *
+ * All other types should extend this class.
+ */
+declare abstract class BaseType<JSON extends ASTNodeJSON = any> extends ASTNode<JSON> {
+    flags: number;
+    /**
+     * Check if the current type is equal to the target type.
+     * @param targetTypeJSONOrKind The type to compare with.
+     * @returns `true` if the types are equal, `false` otherwise.
+     */
+    isTypeEqual(targetTypeJSONOrKind?: ASTNodeJSONOrKind): boolean;
+    /**
+     * Get a variable field by key path.
+     *
+     * This method should be implemented by drillable types.
+     * @param keyPath The key path to search for.
+     * @returns The variable field if found, otherwise `undefined`.
+     */
+    getByKeyPath(keyPath?: string[]): BaseVariableField | undefined;
+}
+
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+/**
+ * ASTNodeJSON representation of the `StringType`.
+ */
+interface StringJSON {
+    /**
+     * see https://json-schema.org/understanding-json-schema/reference/type#format
+     */
+    format?: string;
+}
+declare class StringType extends BaseType<StringJSON> {
+    flags: ASTNodeFlags;
+    static kind: string;
+    protected _format?: string;
+    /**
+     * see https://json-schema.org/understanding-json-schema/reference/string#format
+     */
+    get format(): string | undefined;
+    /**
+     * Deserialize the `StringJSON` to the `StringType`.
+     *
+     * @param json StringJSON representation of the `StringType`.
+     */
+    fromJSON(json?: StringJSON): void;
+    /**
+     * Serialize the `StringType` to `StringJSON`.
+     * @returns The JSON representation of `StringType`.
+     */
+    toJSON(): {
+        format: string | undefined;
+    };
+}
+
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+/**
+ * Represents an integer type.
+ */
+declare class IntegerType extends BaseType {
+    flags: ASTNodeFlags;
+    static kind: string;
+    /**
+     * Deserializes the `IntegerJSON` to the `IntegerType`.
+     * @param json The `IntegerJSON` to deserialize.
+     */
+    fromJSON(): void;
+    toJSON(): {};
+}
+
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+/**
+ * Represents a boolean type.
+ */
+declare class BooleanType extends BaseType {
+    static kind: string;
+    /**
+     * Deserializes the `BooleanJSON` to the `BooleanType`.
+     * @param json The `BooleanJSON` to deserialize.
+     */
+    fromJSON(): void;
+    toJSON(): {};
+}
+
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+/**
+ * Represents a number type.
+ */
+declare class NumberType extends BaseType {
+    static kind: string;
+    /**
+     * Deserializes the `NumberJSON` to the `NumberType`.
+     * @param json The `NumberJSON` to deserialize.
+     */
+    fromJSON(): void;
+    toJSON(): {};
+}
+
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+/**
+ * ASTNodeJSON representation of `ArrayType`
+ */
+interface ArrayJSON {
+    /**
+     * The type of the items in the array.
+     */
+    items?: ASTNodeJSONOrKind;
+}
+/**
+ * Represents an array type.
+ */
+declare class ArrayType extends BaseType<ArrayJSON> {
+    flags: ASTNodeFlags;
+    static kind: string;
+    /**
+     * The type of the items in the array.
+     */
+    items: BaseType;
+    /**
+     * Deserializes the `ArrayJSON` to the `ArrayType`.
+     * @param json The `ArrayJSON` to deserialize.
+     */
+    fromJSON({ items }: ArrayJSON): void;
+    /**
+     * Whether the items type can be drilled down.
+     */
+    get canDrilldownItems(): boolean;
+    /**
+     * Get a variable field by key path.
+     * @param keyPath The key path to search for.
+     * @returns The variable field if found, otherwise `undefined`.
+     */
+    getByKeyPath(keyPath: string[]): BaseVariableField | undefined;
+    /**
+     * Check if the current type is equal to the target type.
+     * @param targetTypeJSONOrKind The type to compare with.
+     * @returns `true` if the types are equal, `false` otherwise.
+     */
+    isTypeEqual(targetTypeJSONOrKind?: ASTNodeJSONOrKind): boolean;
+    /**
+     * Array strong comparison.
+     * @param targetTypeJSON The type to compare with.
+     * @returns `true` if the types are equal, `false` otherwise.
+     */
+    protected customStrongEqual(targetTypeJSON: ASTNodeJSON): boolean;
+    /**
+     * Serialize the `ArrayType` to `ArrayJSON`
+     * @returns The JSON representation of `ArrayType`.
+     */
+    toJSON(): {
+        kind: ASTKind;
+        items: any;
+    };
+}
+
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+/**
+ * ASTNodeJSON representation of `MapType`
+ */
+interface MapJSON {
+    /**
+     * The type of the keys in the map.
+     */
+    keyType?: ASTNodeJSONOrKind;
+    /**
+     * The type of the values in the map.
+     */
+    valueType?: ASTNodeJSONOrKind;
+}
+/**
+ * Represents a map type.
+ */
+declare class MapType extends BaseType<MapJSON> {
+    static kind: string;
+    /**
+     * The type of the keys in the map.
+     */
+    keyType: BaseType;
+    /**
+     * The type of the values in the map.
+     */
+    valueType: BaseType;
+    /**
+     * Deserializes the `MapJSON` to the `MapType`.
+     * @param json The `MapJSON` to deserialize.
+     */
+    fromJSON({ keyType, valueType }: MapJSON): void;
+    /**
+     * Check if the current type is equal to the target type.
+     * @param targetTypeJSONOrKind The type to compare with.
+     * @returns `true` if the types are equal, `false` otherwise.
+     */
+    isTypeEqual(targetTypeJSONOrKind?: ASTNodeJSONOrKind): boolean;
+    /**
+     * Map strong comparison.
+     * @param targetTypeJSON The type to compare with.
+     * @returns `true` if the types are equal, `false` otherwise.
+     */
+    protected customStrongEqual(targetTypeJSON: ASTNodeJSON): boolean;
+    /**
+     * Serialize the node to a JSON object.
+     * @returns The JSON representation of the node.
+     */
+    toJSON(): {
+        kind: ASTKind;
+        keyType: any;
+        valueType: any;
+    };
+}
+
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+/**
+ * ASTNodeJSON representation of the `Property`.
+ */
+type PropertyJSON<VariableMeta = any> = BaseVariableFieldJSON<VariableMeta>;
+/**
+ * `Property` is a variable field that represents a property of a `ObjectType`.
+ */
+declare class Property<VariableMeta = any> extends BaseVariableField<VariableMeta> {
+    static kind: string;
+}
+
+/**
+ * ASTNodeJSON representation of `ObjectType`
+ */
+interface ObjectJSON<VariableMeta = any> {
+    /**
+     * The properties of the object.
+     *
+     * The `properties` of an Object must be of type `Property`, so the business can omit the `kind` field.
+     */
+    properties?: PropertyJSON<VariableMeta>[];
+}
+/**
+ * Action type for object properties change.
+ */
+type ObjectPropertiesChangeAction = GlobalEventActionType<'ObjectPropertiesChange', {
+    prev: Property[];
+    next: Property[];
+}, ObjectType>;
+/**
+ * Represents an object type.
+ */
+declare class ObjectType extends BaseType<ObjectJSON> {
+    flags: ASTNodeFlags;
+    static kind: string;
+    /**
+     * A map of property keys to `Property` instances.
+     */
+    propertyTable: Map<string, Property>;
+    /**
+     * An array of `Property` instances.
+     */
+    properties: Property[];
+    /**
+     * Deserializes the `ObjectJSON` to the `ObjectType`.
+     * @param json The `ObjectJSON` to deserialize.
+     */
+    fromJSON({ properties }: ObjectJSON): void;
+    /**
+     * Serialize the `ObjectType` to `ObjectJSON`.
+     * @returns The JSON representation of `ObjectType`.
+     */
+    toJSON(): {
+        properties: BaseVariableFieldJSON<any>[];
+    };
+    /**
+     * Get a variable field by key path.
+     * @param keyPath The key path to search for.
+     * @returns The variable field if found, otherwise `undefined`.
+     */
+    getByKeyPath(keyPath: string[]): Property | undefined;
+    /**
+     * Check if the current type is equal to the target type.
+     * @param targetTypeJSONOrKind The type to compare with.
+     * @returns `true` if the types are equal, `false` otherwise.
+     */
+    isTypeEqual(targetTypeJSONOrKind?: ASTNodeJSONOrKind): boolean;
+    /**
+     * Object type strong comparison.
+     * @param targetTypeJSON The type to compare with.
+     * @returns `true` if the types are equal, `false` otherwise.
+     */
+    protected customStrongEqual(targetTypeJSON: ASTNodeJSON): boolean;
+}
+
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+/**
+ * ASTNodeJSON representation of `UnionType`, which union multiple `BaseType`.
+ */
+interface UnionJSON {
+    types?: ASTNodeJSONOrKind[];
+}
+
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+/**
+ * ASTNodeJSON representation of `CustomType`
+ */
+interface CustomTypeJSON {
+    /**
+     * The name of the custom type.
+     */
+    typeName: string;
+}
+/**
+ * Represents a custom type.
+ */
+declare class CustomType extends BaseType<CustomTypeJSON> {
+    static kind: string;
+    protected _typeName: string;
+    /**
+     * The name of the custom type.
+     */
+    get typeName(): string;
+    /**
+     * Deserializes the `CustomTypeJSON` to the `CustomType`.
+     * @param json The `CustomTypeJSON` to deserialize.
+     */
+    fromJSON(json: CustomTypeJSON): void;
+    /**
+     * Check if the current type is equal to the target type.
+     * @param targetTypeJSONOrKind The type to compare with.
+     * @returns `true` if the types are equal, `false` otherwise.
+     */
+    isTypeEqual(targetTypeJSONOrKind?: ASTNodeJSONOrKind): boolean;
+    toJSON(): {
+        typeName: string;
+    };
+}
+
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+type ExpressionRefs = (BaseVariableField | undefined)[];
+/**
+ * Base class for all expressions.
+ *
+ * All other expressions should extend this class.
+ */
+declare abstract class BaseExpression<JSON extends ASTNodeJSON = any> extends ASTNode<JSON> {
+    flags: ASTNodeFlags;
+    /**
+     * Get the global variable table, which is used to access referenced variables.
+     */
+    get globalVariableTable(): IVariableTable;
+    /**
+     * Parent variable fields, sorted from closest to farthest.
+     */
+    get parentFields(): BaseVariableField[];
+    /**
+     * Get the variable fields referenced by the expression.
+     *
+     * This method should be implemented by subclasses.
+     * @returns An array of referenced variable fields.
+     */
+    abstract getRefFields(): ExpressionRefs;
+    /**
+     * The return type of the expression.
+     */
+    abstract returnType: BaseType | undefined;
+    /**
+     * The variable fields referenced by the expression.
+     */
+    protected _refs: ExpressionRefs;
+    /**
+     * The variable fields referenced by the expression.
+     */
+    get refs(): ExpressionRefs;
+    protected refreshRefs$: Subject<void>;
+    /**
+     * Refresh the variable references.
+     */
+    refreshRefs(): void;
+    /**
+     * An observable that emits the referenced variable fields when they change.
+     */
+    refs$: Observable<ExpressionRefs>;
+    constructor(params: CreateASTParams, opts?: any);
+}
+
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+/**
+ * ASTNodeJSON representation of `EnumerateExpression`
+ */
+interface EnumerateExpressionJSON {
+    /**
+     * The expression to be enumerated.
+     */
+    enumerateFor: ASTNodeJSON;
+}
+/**
+ * Represents an enumeration expression, which iterates over a list and returns the type of the enumerated variable.
+ */
+declare class EnumerateExpression extends BaseExpression<EnumerateExpressionJSON> {
+    static kind: string;
+    protected _enumerateFor: BaseExpression | undefined;
+    /**
+     * The expression to be enumerated.
+     */
+    get enumerateFor(): BaseExpression<any> | undefined;
+    /**
+     * The return type of the expression.
+     */
+    get returnType(): BaseType | undefined;
+    /**
+     * Get the variable fields referenced by the expression.
+     * @returns An empty array, as this expression does not reference any variables.
+     */
+    getRefFields(): [];
+    /**
+     * Deserializes the `EnumerateExpressionJSON` to the `EnumerateExpression`.
+     * @param json The `EnumerateExpressionJSON` to deserialize.
+     */
+    fromJSON({ enumerateFor: expression }: EnumerateExpressionJSON): void;
+    /**
+     * Serialize the `EnumerateExpression` to `EnumerateExpressionJSON`.
+     * @returns The JSON representation of `EnumerateExpression`.
+     */
+    toJSON(): {
+        kind: ASTKind;
+        enumerateFor: any;
+    };
+}
+
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+/**
+ * ASTNodeJSON representation of `KeyPathExpression`
+ */
+interface KeyPathExpressionJSON$1 {
+    /**
+     * The key path of the variable.
+     */
+    keyPath: string[];
+}
+/**
+ * Represents a key path expression, which is used to reference a variable by its key path.
+ *
+ * This is the V2 of `KeyPathExpression`, with the following improvements:
+ * - `returnType` is copied to a new instance to avoid reference issues.
+ * - Circular reference detection is introduced.
+ */
+declare class KeyPathExpression<CustomPathJSON extends ASTNodeJSON = KeyPathExpressionJSON$1> extends BaseExpression<CustomPathJSON> {
+    static kind: string;
+    protected _keyPath: string[];
+    protected _rawPathJson: CustomPathJSON;
+    /**
+     * The key path of the variable.
+     */
+    get keyPath(): string[];
+    /**
+     * Get the variable fields referenced by the expression.
+     * @returns An array of referenced variable fields.
+     */
+    getRefFields(): BaseVariableField[];
+    /**
+     * The return type of the expression.
+     *
+     * A new `returnType` node is generated directly, instead of reusing the existing one, to ensure that different key paths do not point to the same field.
+     */
+    _returnType: BaseType;
+    /**
+     * The return type of the expression.
+     */
+    get returnType(): BaseType<any>;
+    /**
+     * Parse the business-defined path expression into a key path.
+     *
+     * Businesses can quickly customize their own path expressions by modifying this method.
+     * @param json The path expression defined by the business.
+     * @returns The key path.
+     */
+    protected parseToKeyPath(json: CustomPathJSON): string[];
+    /**
+     * Deserializes the `KeyPathExpressionJSON` to the `KeyPathExpression`.
+     * @param json The `KeyPathExpressionJSON` to deserialize.
+     */
+    fromJSON(json: CustomPathJSON): void;
+    /**
+     * Get the return type JSON by reference.
+     * @param _ref The referenced variable field.
+     * @returns The JSON representation of the return type.
+     */
+    getReturnTypeJSONByRef(_ref: BaseVariableField | undefined): ASTNodeJSON | undefined;
+    constructor(params: CreateASTParams, opts: any);
+    /**
+     * Serialize the `KeyPathExpression` to `KeyPathExpressionJSON`.
+     * @returns The JSON representation of `KeyPathExpression`.
+     */
+    toJSON(): CustomPathJSON;
+}
+
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+/**
+ * ASTNodeJSON representation of `KeyPathExpression`
+ */
+interface KeyPathExpressionJSON {
+    /**
+     * The key path of the variable.
+     */
+    keyPath: string[];
+}
+/**
+ * @deprecated Use `KeyPathExpression` instead.
+ * Represents a key path expression, which is used to reference a variable by its key path.
+ */
+declare class LegacyKeyPathExpression<CustomPathJSON extends ASTNodeJSON = KeyPathExpressionJSON> extends BaseExpression<CustomPathJSON> {
+    static kind: string;
+    protected _keyPath: string[];
+    protected _rawPathJson: CustomPathJSON;
+    /**
+     * The key path of the variable.
+     */
+    get keyPath(): string[];
+    /**
+     * Get the variable fields referenced by the expression.
+     * @returns An array of referenced variable fields.
+     */
+    getRefFields(): BaseVariableField[];
+    /**
+     * The return type of the expression.
+     */
+    get returnType(): BaseType | undefined;
+    /**
+     * Parse the business-defined path expression into a key path.
+     *
+     * Businesses can quickly customize their own path expressions by modifying this method.
+     * @param json The path expression defined by the business.
+     * @returns The key path.
+     */
+    protected parseToKeyPath(json: CustomPathJSON): string[];
+    /**
+     * Deserializes the `KeyPathExpressionJSON` to the `KeyPathExpression`.
+     * @param json The `KeyPathExpressionJSON` to deserialize.
+     */
+    fromJSON(json: CustomPathJSON): void;
+    constructor(params: CreateASTParams, opts: any);
+    /**
+     * Serialize the `KeyPathExpression` to `KeyPathExpressionJSON`.
+     * @returns The JSON representation of `KeyPathExpression`.
+     */
+    toJSON(): CustomPathJSON;
+}
+
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+/**
+ * ASTNodeJSON representation of `WrapArrayExpression`
+ */
+interface WrapArrayExpressionJSON {
+    /**
+     * The expression to be wrapped.
+     */
+    wrapFor: ASTNodeJSON;
+}
+/**
+ * Represents a wrap expression, which wraps an expression with an array.
+ */
+declare class WrapArrayExpression extends BaseExpression<WrapArrayExpressionJSON> {
+    static kind: string;
+    protected _wrapFor: BaseExpression | undefined;
+    protected _returnType: BaseType | undefined;
+    /**
+     * The expression to be wrapped.
+     */
+    get wrapFor(): BaseExpression<any> | undefined;
+    /**
+     * The return type of the expression.
+     */
+    get returnType(): BaseType | undefined;
+    /**
+     * Refresh the return type of the expression.
+     */
+    refreshReturnType(): void;
+    /**
+     * Get the variable fields referenced by the expression.
+     * @returns An empty array, as this expression does not reference any variables.
+     */
+    getRefFields(): [];
+    /**
+     * Deserializes the `WrapArrayExpressionJSON` to the `WrapArrayExpression`.
+     * @param json The `WrapArrayExpressionJSON` to deserialize.
+     */
+    fromJSON({ wrapFor: expression }: WrapArrayExpressionJSON): void;
+    /**
+     * Serialize the `WrapArrayExpression` to `WrapArrayExpressionJSON`.
+     * @returns The JSON representation of `WrapArrayExpression`.
+     */
+    toJSON(): {
+        kind: ASTKind;
+        wrapFor: any;
+    };
+    protected init(): void;
+}
+
+/**
+ * ASTNodeJSON representation of `BaseVariableField`
+ */
+interface BaseVariableFieldJSON<VariableMeta = any> extends ASTNodeJSON {
+    /**
+     * key of the variable field
+     * - For `VariableDeclaration`, the key should be global unique.
+     * - For `Property`, the key is the property name.
+     */
+    key: Identifier;
+    /**
+     * type of the variable field, similar to js code:
+     * `const v: string`
+     */
+    type?: ASTNodeJSONOrKind;
+    /**
+     * initializer of the variable field, similar to js code:
+     * `const v = 'hello'`
+     *
+     * with initializer, the type of field will be inferred from the initializer.
+     */
+    initializer?: ASTNodeJSON;
+    /**
+     * meta data of the variable field, you cans store information like `title`, `icon`, etc.
+     */
+    meta?: VariableMeta;
+}
+/**
+ * Variable Field abstract class, which is the base class for `VariableDeclaration` and `Property`
+ *
+ * - `VariableDeclaration` is used to declare a variable in a block scope.
+ * - `Property` is used to declare a property in an object.
+ */
+declare abstract class BaseVariableField<VariableMeta = any> extends ASTNode<BaseVariableFieldJSON<VariableMeta>> {
+    flags: ASTNodeFlags;
+    protected _type?: BaseType;
+    protected _meta: VariableMeta;
+    protected _initializer?: BaseExpression;
+    /**
+     * Parent variable fields, sorted from closest to farthest
+     */
+    get parentFields(): BaseVariableField[];
+    /**
+     * KeyPath of the variable field, sorted from farthest to closest
+     */
+    get keyPath(): string[];
+    /**
+     * Metadata of the variable field, you cans store information like `title`, `icon`, etc.
+     */
+    get meta(): VariableMeta;
+    /**
+     * Type of the variable field, similar to js code:
+     * `const v: string`
+     */
+    get type(): BaseType;
+    /**
+     * Initializer of the variable field, similar to js code:
+     * `const v = 'hello'`
+     *
+     * with initializer, the type of field will be inferred from the initializer.
+     */
+    get initializer(): BaseExpression | undefined;
+    /**
+     * The global unique hash of the field, and will be changed when the field is updated.
+     */
+    get hash(): string;
+    /**
+     * Deserialize the `BaseVariableFieldJSON` to the `BaseVariableField`.
+     * @param json ASTJSON representation of `BaseVariableField`
+     */
+    fromJSON({ type, initializer, meta }: Omit<BaseVariableFieldJSON<VariableMeta>, 'key'>): void;
+    /**
+     * Update the type of the variable field
+     * @param type type ASTJSON representation of Type
+     */
+    updateType(type: BaseVariableFieldJSON['type']): void;
+    /**
+     * Update the initializer of the variable field
+     * @param nextInitializer initializer ASTJSON representation of Expression
+     */
+    updateInitializer(nextInitializer?: BaseVariableFieldJSON['initializer']): void;
+    /**
+     * Update the meta data of the variable field
+     * @param nextMeta meta data of the variable field
+     */
+    updateMeta(nextMeta: VariableMeta): void;
+    /**
+     * Get the variable field by keyPath, similar to js code:
+     * `v.a.b`
+     * @param keyPath
+     * @returns
+     */
+    getByKeyPath(keyPath: string[]): BaseVariableField | undefined;
+    /**
+     * Subscribe to type change of the variable field
+     * @param observer
+     * @returns
+     */
+    onTypeChange(observer: (type: ASTNode | undefined) => void): _flowgram_vue_utils.Disposable;
+    /**
+     * Serialize the variable field to JSON
+     * @returns ASTNodeJSON representation of `BaseVariableField`
+     */
+    toJSON(): BaseVariableFieldJSON<VariableMeta>;
+}
+
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+/**
+ * ASTNodeJSON representation of the `VariableDeclaration`.
+ */
+type VariableDeclarationJSON<VariableMeta = any> = BaseVariableFieldJSON<VariableMeta> & {
+    /**
+     * Variable sorting order, which is used to sort variables in `scope.outputs.variables`
+     */
+    order?: number;
+};
+/**
+ * `VariableDeclaration` is a variable field that represents a variable declaration.
+ */
+declare class VariableDeclaration<VariableMeta = any> extends BaseVariableField<VariableMeta> {
+    static kind: string;
+    protected _order: number;
+    /**
+     * Variable sorting order, which is used to sort variables in `scope.outputs.variables`
+     */
+    get order(): number;
+    constructor(params: CreateASTParams);
+    /**
+     * Deserialize the `VariableDeclarationJSON` to the `VariableDeclaration`.
+     */
+    fromJSON({ order, ...rest }: Omit<VariableDeclarationJSON<VariableMeta>, 'key'>): void;
+    /**
+     * Update the sorting order of the variable declaration.
+     * @param order Variable sorting order. Default is 0.
+     */
+    updateOrder(order?: number): void;
+    /**
+     * Serialize the `VariableDeclaration` to `VariableDeclarationJSON`.
+     * @returns The JSON representation of `VariableDeclaration`.
+     */
+    toJSON(): VariableDeclarationJSON<VariableMeta>;
+}
+
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+interface VariableDeclarationListJSON<VariableMeta = any> {
+    /**
+     * `declarations` must be of type `VariableDeclaration`, so the business can omit the `kind` field.
+     */
+    declarations?: VariableDeclarationJSON<VariableMeta>[];
+    /**
+     * The starting order number for variables.
+     */
+    startOrder?: number;
+}
+type VariableDeclarationListChangeAction = GlobalEventActionType<'VariableListChange', {
+    prev: VariableDeclaration[];
+    next: VariableDeclaration[];
+}, VariableDeclarationList>;
+declare class VariableDeclarationList extends ASTNode<VariableDeclarationListJSON> {
+    static kind: string;
+    /**
+     * Map of variable declarations, keyed by variable name.
+     */
+    declarationTable: Map<string, VariableDeclaration>;
+    /**
+     * Variable declarations, sorted by `order`.
+     */
+    declarations: VariableDeclaration[];
+    /**
+     * Deserialize the `VariableDeclarationListJSON` to the `VariableDeclarationList`.
+     * - VariableDeclarationListChangeAction will be dispatched after deserialization.
+     *
+     * @param declarations Variable declarations.
+     * @param startOrder The starting order number for variables. Default is 0.
+     */
+    fromJSON({ declarations, startOrder }: VariableDeclarationListJSON): void;
+    /**
+     * Serialize the `VariableDeclarationList` to the `VariableDeclarationListJSON`.
+     * @returns ASTJSON representation of `VariableDeclarationList`
+     */
+    toJSON(): {
+        kind: ASTKind;
+        declarations: VariableDeclarationJSON<any>[];
+    };
+}
+
+/**
+ * Variable-core ASTNode factories.
+ */
+declare namespace ASTFactory {
+    /**
+     * Type-related factories.
+     */
+    /**
+     * Creates a `String` type node.
+     */
+    const createString: (json?: StringJSON) => {
+        format?: string;
+        kind: ASTKind;
+    };
+    /**
+     * Creates a `Number` type node.
+     */
+    const createNumber: () => {
+        kind: ASTKind;
+    };
+    /**
+     * Creates a `Boolean` type node.
+     */
+    const createBoolean: () => {
+        kind: ASTKind;
+    };
+    /**
+     * Creates an `Integer` type node.
+     */
+    const createInteger: () => {
+        kind: ASTKind;
+    };
+    /**
+     * Creates an `Object` type node.
+     */
+    const createObject: (json: ObjectJSON) => {
+        properties?: PropertyJSON<any>[] | undefined;
+        kind: ASTKind;
+    };
+    /**
+     * Creates an `Array` type node.
+     */
+    const createArray: (json: ArrayJSON) => {
+        items?: ASTNodeJSONOrKind;
+        kind: ASTKind;
+    };
+    /**
+     * Creates a `Map` type node.
+     */
+    const createMap: (json: MapJSON) => {
+        keyType?: ASTNodeJSONOrKind;
+        valueType?: ASTNodeJSONOrKind;
+        kind: ASTKind;
+    };
+    /**
+     * Creates a `Union` type node.
+     */
+    const createUnion: (json: UnionJSON) => {
+        types?: ASTNodeJSONOrKind[];
+        kind: ASTKind;
+    };
+    /**
+     * Creates a `CustomType` node.
+     */
+    const createCustomType: (json: CustomTypeJSON) => {
+        typeName: string;
+        kind: ASTKind;
+    };
+    /**
+     * Declaration-related factories.
+     */
+    /**
+     * Creates a `VariableDeclaration` node.
+     */
+    const createVariableDeclaration: <VariableMeta = any>(json: VariableDeclarationJSON<VariableMeta>) => {
+        key: Identifier;
+        type?: ASTNodeJSONOrKind;
+        initializer?: ASTNodeJSON;
+        meta?: VariableMeta | undefined;
+        kind: ASTKindType;
+        order?: number;
+    };
+    /**
+     * Creates a `Property` node.
+     */
+    const createProperty: <VariableMeta = any>(json: PropertyJSON<VariableMeta>) => {
+        key: Identifier;
+        type?: ASTNodeJSONOrKind;
+        initializer?: ASTNodeJSON;
+        meta?: VariableMeta | undefined;
+        kind: ASTKindType;
+    };
+    /**
+     * Creates a `VariableDeclarationList` node.
+     */
+    const createVariableDeclarationList: (json: VariableDeclarationListJSON) => {
+        declarations?: VariableDeclarationJSON<any>[] | undefined;
+        startOrder?: number;
+        kind: ASTKind;
+    };
+    /**
+     * Expression-related factories.
+     */
+    /**
+     * Creates an `EnumerateExpression` node.
+     */
+    const createEnumerateExpression: (json: EnumerateExpressionJSON) => {
+        enumerateFor: ASTNodeJSON;
+        kind: ASTKind;
+    };
+    /**
+     * Creates a `KeyPathExpression` node.
+     */
+    const createKeyPathExpression: (json: KeyPathExpressionJSON$1) => {
+        keyPath: string[];
+        kind: ASTKind;
+    };
+    /**
+     * Creates a `WrapArrayExpression` node.
+     */
+    const createWrapArrayExpression: (json: WrapArrayExpressionJSON) => {
+        wrapFor: ASTNodeJSON;
+        kind: ASTKind;
+    };
+    /**
+     * Create by AST Class.
+     */
+    /**
+     * Creates Type-Safe ASTNodeJSON object based on the provided AST class.
+     *
+     * @param targetType Target ASTNode class.
+     * @param json The JSON data for the node.
+     * @returns The ASTNode JSON object.
+     */
+    const create: <JSON extends ASTNodeJSON>(targetType: {
+        kind: string;
+        new (...args: any[]): ASTNode<JSON>;
+    }, json: JSON) => {
+        kind: string;
+    } & JSON;
+}
+
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+/**
+ * Variable-core ASTNode matchers.
+ *
+ * - Typescript code inside if statement will be type guarded.
+ */
+declare namespace ASTMatch {
+    /**
+     * # Type-related matchers.
+     */
+    /**
+     * Check if the node is a `StringType`.
+     */
+    const isString: (node?: ASTNode) => node is StringType;
+    /**
+     * Check if the node is a `NumberType`.
+     */
+    const isNumber: (node?: ASTNode) => node is NumberType;
+    /**
+     * Check if the node is a `BooleanType`.
+     */
+    const isBoolean: (node?: ASTNode) => node is BooleanType;
+    /**
+     * Check if the node is a `IntegerType`.
+     */
+    const isInteger: (node?: ASTNode) => node is IntegerType;
+    /**
+     * Check if the node is a `ObjectType`.
+     */
+    const isObject: (node?: ASTNode) => node is ObjectType;
+    /**
+     * Check if the node is a `ArrayType`.
+     */
+    const isArray: (node?: ASTNode) => node is ArrayType;
+    /**
+     * Check if the node is a `MapType`.
+     */
+    const isMap: (node?: ASTNode) => node is MapType;
+    /**
+     * Check if the node is a `CustomType`.
+     */
+    const isCustomType: (node?: ASTNode) => node is CustomType;
+    /**
+     * # Declaration-related matchers.
+     */
+    /**
+     * Check if the node is a `VariableDeclaration`.
+     */
+    const isVariableDeclaration: <VariableMeta = any>(node?: ASTNode) => node is VariableDeclaration<VariableMeta>;
+    /**
+     * Check if the node is a `Property`.
+     */
+    const isProperty: <VariableMeta = any>(node?: ASTNode) => node is Property<VariableMeta>;
+    /**
+     * Check if the node is a `BaseVariableField`.
+     */
+    const isBaseVariableField: (node?: ASTNode) => node is BaseVariableField;
+    /**
+     * Check if the node is a `VariableDeclarationList`.
+     */
+    const isVariableDeclarationList: (node?: ASTNode) => node is VariableDeclarationList;
+    /**
+     * # Expression-related matchers.
+     */
+    /**
+     * Check if the node is a `EnumerateExpression`.
+     */
+    const isEnumerateExpression: (node?: ASTNode) => node is EnumerateExpression;
+    /**
+     * Check if the node is a `WrapArrayExpression`.
+     */
+    const isWrapArrayExpression: (node?: ASTNode) => node is WrapArrayExpression;
+    /**
+     * Check if the node is a `KeyPathExpression`.
+     */
+    const isKeyPathExpression: (node?: ASTNode) => node is KeyPathExpression;
+    /**
+     * Check ASTNode Match by ASTClass
+     *
+     * @param node ASTNode to be checked.
+     * @param targetType Target ASTNode class.
+     * @returns Whether the node is of the target type.
+     */
+    function is<TargetASTNode extends ASTNode>(node?: ASTNode, targetType?: {
+        kind: string;
+        new (...args: any[]): TargetASTNode;
+    }): node is TargetASTNode;
+}
+
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+declare const injectToAST: (serviceIdentifier: interfaces.ServiceIdentifier) => (target: any, propertyKey: string) => any;
+declare const postConstructAST: () => (target: any, propertyKey: string) => void;
+
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+/**
+ * isMatchAST is same as ASTMatch.is
+ * @param node
+ * @param targetType
+ * @returns
+ */
+declare function isMatchAST<TargetASTNode extends ASTNode>(node?: ASTNode, targetType?: {
+    kind: string;
+    new (...args: any[]): TargetASTNode;
+}): node is TargetASTNode;
+
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+/**
+ * Action type for scope changes.
+ */
+interface ScopeChangeAction {
+    type: 'add' | 'delete' | 'update' | 'available';
+    scope: Scope;
+}
+/**
+ * Interface for a variable table.
+ */
+interface IVariableTable extends Disposable {
+    /**
+     * The parent variable table.
+     */
+    parentTable?: IVariableTable;
+    /**
+     * @deprecated Use `onVariableListChange` or `onAnyVariableChange` instead.
+     */
+    onDataChange: Event<void>;
+    /**
+     * The current version of the variable table.
+     */
+    version: number;
+    /**
+     * The list of variables in the table.
+     */
+    variables: VariableDeclaration[];
+    /**
+     * The keys of the variables in the table.
+     */
+    variableKeys: string[];
+    /**
+     * Fires a change event.
+     */
+    fireChange(): void;
+    /**
+     * Gets a variable or property by its key path.
+     * @param keyPath The key path to the variable or property.
+     * @returns The found `BaseVariableField` or `undefined`.
+     */
+    getByKeyPath(keyPath: string[]): BaseVariableField | undefined;
+    /**
+     * Gets a variable by its key.
+     * @param key The key of the variable.
+     * @returns The found `VariableDeclaration` or `undefined`.
+     */
+    getVariableByKey(key: string): VariableDeclaration | undefined;
+    /**
+     * Disposes the variable table.
+     */
+    dispose(): void;
+    /**
+     * Subscribes to changes in the variable list.
+     * @param observer The observer function.
+     * @returns A disposable to unsubscribe.
+     */
+    onVariableListChange(observer: (variables: VariableDeclaration[]) => void): Disposable;
+    /**
+     * Subscribes to changes in any variable's value.
+     * @param observer The observer function.
+     * @returns A disposable to unsubscribe.
+     */
+    onAnyVariableChange(observer: (changedVariable: VariableDeclaration) => void): Disposable;
+    /**
+     * Subscribes to both variable list changes and any variable's value changes.
+     * @param observer The observer function.
+     * @returns A disposable to unsubscribe.
+     */
+    onListOrAnyVarChange(observer: () => void): Disposable;
+}
+
+/**
+ * The core of the variable engine system.
+ * It manages scopes, variables, and events within the system.
+ */
+declare class VariableEngine implements Disposable {
+    /**
+     * The scope chain, which manages the dependency relationships between scopes.
+     */
+    readonly chain: ScopeChain;
+    /**
+     * The registry for all AST node types.
+     */
+    readonly astRegisters: ASTRegisters;
+    protected toDispose: DisposableCollection;
+    protected memo: {
+        <T>(key: string | symbol, fn: () => T): T;
+        clear: (key?: string | symbol) => void;
+    };
+    protected scopeMap: Map<string | symbol, Scope<Record<string, any>>>;
+    /**
+     * A rxjs subject that emits global events occurring within the variable engine.
+     */
+    globalEvent$: Subject<GlobalEventActionType>;
+    protected onScopeChangeEmitter: Emitter<ScopeChangeAction>;
+    /**
+     * A table containing all global variables.
+     */
+    globalVariableTable: IVariableTable;
+    /**
+     * An event that fires whenever a scope is added, updated, or deleted.
+     */
+    onScopeChange: _flowgram_vue_utils.Event<ScopeChangeAction>;
+    private readonly containerProvider;
+    /**
+     * The Inversify container instance.
+     */
+    get container(): interfaces.Container;
+    constructor(
+    /**
+     * The scope chain, which manages the dependency relationships between scopes.
+     */
+    chain: ScopeChain, 
+    /**
+     * The registry for all AST node types.
+     */
+    astRegisters: ASTRegisters);
+    /**
+     * Disposes of all resources used by the variable engine.
+     */
+    dispose(): void;
+    /**
+     * Retrieves a scope by its unique identifier.
+     * @param scopeId The ID of the scope to retrieve.
+     * @returns The scope if found, otherwise undefined.
+     */
+    getScopeById(scopeId: string | symbol): Scope | undefined;
+    /**
+     * Removes a scope by its unique identifier and disposes of it.
+     * @param scopeId The ID of the scope to remove.
+     */
+    removeScopeById(scopeId: string | symbol): void;
+    /**
+     * Creates a new scope or retrieves an existing one if the ID and type match.
+     * @param id The unique identifier for the scope.
+     * @param meta Optional metadata for the scope, defined by the user.
+     * @param options Options for creating the scope.
+     * @param options.ScopeConstructor The constructor to use for creating the scope. Defaults to `Scope`.
+     * @returns The created or existing scope.
+     */
+    createScope(id: string | symbol, meta?: Record<string, any>, options?: {
+        ScopeConstructor?: IScopeConstructor;
+    }): Scope;
+    /**
+     * Retrieves all scopes currently managed by the engine.
+     * @param options Options for retrieving the scopes.
+     * @param options.sort Whether to sort the scopes based on their dependency chain.
+     * @returns An array of all scopes.
+     */
+    getAllScopes({ sort, }?: {
+        sort?: boolean;
+    }): Scope[];
+    /**
+     * Fires a global event to be broadcast to all listeners.
+     * @param event The global event to fire.
+     */
+    fireGlobalEvent(event: GlobalEventActionType): void;
+    /**
+     * Subscribes to a specific type of global event.
+     * @param type The type of the event to listen for.
+     * @param observer A function to be called when the event is observed.
+     * @returns A disposable object to unsubscribe from the event.
+     */
+    onGlobalEvent<ActionType extends GlobalEventActionType = GlobalEventActionType>(type: ActionType['type'], observer: (action: ActionType) => void): Disposable;
+}
+
+interface ScopeContextProps {
+    scope: Scope;
+}
+declare const ScopeKey: InjectionKey<Scope | ComputedRef<Scope>>;
+/**
+ * ScopeProvider provides the scope to its children via provide/inject.
+ */
+declare const ScopeProvider: vue.DefineComponent<vue.ExtractPropTypes<{
+    /**
+     * scope used in the context
+     */
+    scope: {
+        type: PropType<Scope>;
+    };
+    /**
+     * @deprecated use scope prop instead, this is kept for backward compatibility
+     */
+    value: {
+        type: PropType<ScopeContextProps>;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>[] | undefined, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    /**
+     * scope used in the context
+     */
+    scope: {
+        type: PropType<Scope>;
+    };
+    /**
+     * @deprecated use scope prop instead, this is kept for backward compatibility
+     */
+    value: {
+        type: PropType<ScopeContextProps>;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+/**
+ * useCurrentScope returns the scope provided by ScopeProvider.
+ */
+declare const useCurrentScope: <Strict extends boolean = false>(params?: {
+    /**
+     * whether to throw error when no scope in ScopeProvider is found
+     */
+    strict: Strict;
+}) => Strict extends true ? Scope : Scope | undefined;
+
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+/**
+ * Get the available variables in the current scope.
+ * 获取作用域的可访问变量
+ */
+declare function useScopeAvailable(params?: {
+    autoRefresh?: boolean;
+}): ComputedRef<ScopeAvailableData>;
+
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+/**
+ * Get available variable list in the current scope.
+ *
+ * - If no scope, return global variable list.
+ * - The composable is reactive to variable list or any variables change.
+ */
+declare function useAvailableVariables(): ComputedRef<VariableDeclaration[]>;
+
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+/**
+ * Get output variable list in the current scope.
+ *
+ * - The composable is reactive to variable list or any variables change.
+ */
+declare function useOutputVariables(): ComputedRef<VariableDeclaration[]>;
+
+interface RenameInfo {
+    before: BaseVariableField;
+    after: BaseVariableField;
+}
+/**
+ * This service is responsible for detecting when a variable field's key is renamed.
+ * It listens for changes in variable declaration lists and object properties, and
+ * determines if a change constitutes a rename operation.
+ */
+declare class VariableFieldKeyRenameService {
+    variableEngine: VariableEngine;
+    toDispose: DisposableCollection;
+    renameEmitter: Emitter<RenameInfo>;
+    /**
+     * Emits events for fields that are disposed of during a list change, but not renamed.
+     * This helps distinguish between a field that was truly removed and one that was renamed.
+     */
+    disposeInListEmitter: Emitter<BaseVariableField<any>>;
+    /**
+     * An event that fires when a variable field key is successfully renamed.
+     */
+    onRename: _flowgram_vue_utils.Event<RenameInfo>;
+    /**
+     * An event that fires when a field is removed from a list (and not part of a rename).
+     */
+    onDisposeInList: _flowgram_vue_utils.Event<BaseVariableField<any>>;
+    /**
+     * Handles changes in a list of fields to detect rename operations.
+     * @param ast The AST node where the change occurred.
+     * @param prev The list of fields before the change.
+     * @param next The list of fields after the change.
+     */
+    handleFieldListChange(ast?: ASTNode, prev?: BaseVariableField[], next?: BaseVariableField[]): void;
+    /**
+     * Notifies listeners about fields that were removed from a list.
+     * @param prev The list of fields before the change.
+     * @param next The list of fields after the change.
+     */
+    notifyFieldsDispose(prev?: BaseVariableField[], next?: BaseVariableField[]): void;
+    init(): void;
+    dispose(): void;
+}
+
+export { ASTFactory, ASTKind, ASTMatch, ASTNode, ASTNodeFlags, type ASTNodeJSON, type ASTNodeRegistry, ASTRegisters, ArrayType, BaseExpression, BaseType, BaseVariableField, BooleanType, type CreateASTParams, CustomType, type CustomTypeJSON, DataNode, EnumerateExpression, type EnumerateExpressionJSON, type GetKindJSON, type GetKindJSONOrKind, type GlobalEventActionType, type IVariableTable, IntegerType, KeyPathExpression, type KeyPathExpressionJSON$1 as KeyPathExpressionJSON, LegacyKeyPathExpression, ListNode, type ListNodeJSON, MapNode, type MapNodeJSON, MapType, NumberType, type ObjectJSON, type ObjectPropertiesChangeAction, ObjectType, Property, type PropertyJSON, Scope, ScopeChain, ScopeKey, ScopeOutputData, ScopeProvider, StringType, type UnionJSON, VariableContainerModule, VariableDeclaration, type VariableDeclarationJSON, VariableDeclarationList, type VariableDeclarationListChangeAction, type VariableDeclarationListJSON, VariableEngine, VariableEngineProvider, VariableFieldKeyRenameService, WrapArrayExpression, type WrapArrayExpressionJSON, injectToAST, isMatchAST, postConstructAST, useAvailableVariables, useCurrentScope, useOutputVariables, useScopeAvailable };