@huanban/rulego-editor-core 1.3.18 → 1.4.0

package/dist/core/EditorCore.d.ts

@@ -1,67 +1,3 @@
-/**
- * @file core/EditorCore.ts
- * @description 编辑器核心引擎 — 整合所有子系统的主入口
- *
- * EditorCore 是整个编辑器的中枢, 它:
- * 1. 持有并协调所有子系统 (StateStore, EventBus, ComponentRegistry 等)
- * 2. 管理 LogicFlow 实例的生命周期 (初始化 / 数据加载 / 事件桥接)
- * 3. 提供统一的 API 供框架适配层 (Vue/React/原生 JS) 调用
- * 4. 不包含任何框架特定代码 (无 Vue ref, 无 React useState)
- *
- * 框架适配层职责:
- * - 将 EditorCore 的状态/事件桥接到框架的响应式系统
- * - 渲染 UI 组件 (工具栏、侧边栏、属性面板)
- * - 处理 DOM 挂载/卸载生命周期
- *
- * 使用方式 (原生 JS):
- * ```typescript
- * import { EditorCore } from '@huanban/rulego-editor-core'
- *
- * const editor = new EditorCore({
- *   container: document.getElementById('editor'),
- *   url: 'http://127.0.0.1:9090',  // 通过 url 参数传入实际地址
- * })
- *
- * // 初始化 (DOM 就绪后)
- * editor.init(lfInstance)
- *
- * // 加载规则链数据
- * editor.loadData(ruleChainData)
- *
- * // 导出数据
- * const data = editor.exportData(lfGraphData, getNodeModelById)
- *
- * // 监听事件
- * editor.on('node:click', (data) => { ... })
- *
- * // 销毁
- * editor.destroy()
- * ```
- *
- * 使用方式 (Vue 适配层):
- * ```typescript
- * // 在 @huanban/editor-vue 的 composable 中
- * import { EditorCore } from '@huanban/rulego-editor-core'
- *
- * export function useEditorCore(options) {
- *   const core = new EditorCore(options)
- *   // 将 core.store 桥接到 Vue 的 reactive/ref
- *   // 将 core.eventBus 桥接到 Vue 的 emit
- *   return core
- * }
- * ```
- *
- * @see StateStore 状态管理
- * @see EventBus 事件总线
- * @see ComponentRegistry 组件注册表
- * @see DataAdapter 数据格式转换
- * @see HistoryManager 撤销/重做
- * @see ValidationEngine 图验证
- * @see ThemeManager 主题管理
- * @see I18nManager 国际化
- *
- * @see 原版 RuleGoEditor.vue — 所有 initLf / save / deleteSelects 逻辑的来源
- */
 import { StateStore } from './StateStore';
 import { EventBus } from './EventBus';
 import { DataAdapter } from './DataAdapter';
@@ -75,199 +11,73 @@ import type { EditorOptions, EditorInternalData, EditorPlugin } from '../types/e
 import type { EditorEventMap, EditorEventName } from '../types/events';
 import type { RuleChainData, RuleChainConfig, RuleNodeConfig, RuleConnectionConfig } from '../types/rule-chain';
 import type { ComponentDefinition, ComponentGroup, RawComponentData } from '../types/component';
-/**
- * 编辑器内部使用的状态结构
- *
- * 使用 Record<string, unknown> 兼容的形式,
- * 区别于 types/editor.ts 中严格的 EditorState 接口。
- * 严格类型由框架适配层在包装时保证。
- */
+import { ActionRegistry } from './ActionRegistry';
+import type { EditorActionContext, EditorActionSource, EditorSelectionSnapshot } from './ActionRegistry';
+import { FieldCapabilityRegistry } from './FieldCapabilityRegistry';
+import { OptionSourceRegistry } from './OptionSourceRegistry';
+import { FieldChangeRegistry } from './FieldChangeRegistry';
+import { DiagnosticService } from './DiagnosticService';
+import type { DiagnosticItem } from './topology-rules';
+import { ComponentDocService } from './ComponentDocService';
+import { RuntimeFieldDictionary } from './runtime-field-dictionary';
 interface CoreState extends Record<string, unknown> {
-    /** 编辑器是否已就绪 */
     isReady: boolean;
-    /** 数据是否已修改 (有未保存的更改) */
     isDirty: boolean;
-    /** 是否正在加载 */
     isLoading: boolean;
-    /** 当前选中的节点数据 */
     selectedNode: RuleNodeConfig | null;
-    /** 当前选中的边数据 */
     selectedEdge: RuleConnectionConfig | null;
-    /** 规则链配置 */
     ruleChain: RuleChainConfig | null;
-    /** 组件注册表 (type => definition 映射) */
     nodeComponents: Record<string, ComponentDefinition>;
-    /** 按分类分组的组件列表 */
     componentGroups: ComponentGroup[];
-    /** 当前正在编辑的节点视图定义 */
     currentNodeView: ComponentDefinition | null;
-    /** 当前正在编辑的节点配置数据 */
     currentNodeModel: Record<string, unknown>;
-    /** 当前正在编辑的边配置数据 */
     currentEdgeModel: Record<string, unknown>;
-    /** 是否可以撤销 */
     canUndo: boolean;
-    /** 是否可以重做 */
     canRedo: boolean;
 }
-/**
- * 编辑器核心引擎
- *
- * 生命周期:
- * 1. constructor    — 创建所有子系统
- * 2. init()         — 初始化 LogicFlow, 加载组件, 注册事件
- * 3. loadData()     — 加载规则链数据并渲染
- * 4. exportData()   — 从画布导出数据
- * 5. destroy()      — 销毁所有资源
- */
 export declare class EditorCore {
-    /** 状态容器 — 编辑器的全局状态 */
     readonly store: StateStore<CoreState>;
-    /** 事件总线 — 编辑器级别的事件 */
     readonly eventBus: EventBus;
-    /** 数据适配器 — RuleGo JSON ↔ LogicFlow 格式转换 */
     readonly dataAdapter: DataAdapter;
-    /** 组件注册表 — 管理可用的节点组件 */
     readonly componentRegistry: ComponentRegistry;
-    /** 历史管理器 — 撤销/重做 */
     readonly history: HistoryManager;
-    /** 验证引擎 — 图合法性检查 */
     readonly validation: ValidationEngine;
-    /** 主题管理器 — 多主题切换 */
     readonly theme: ThemeManager;
-    /** 国际化 — 多语言支持 */
     readonly i18n: I18nManager;
-    /** 编辑器配置选项 */
+    readonly actions: ActionRegistry;
+    readonly fieldCapabilities: FieldCapabilityRegistry;
+    readonly optionSources: OptionSourceRegistry;
+    readonly fieldChanges: FieldChangeRegistry;
+    readonly diagnostics: DiagnosticService;
+    readonly documents: ComponentDocService;
+    readonly runtimeFields: RuntimeFieldDictionary;
     private options;
-    /** 内部运行时数据 (计数器、常量配置等) */
     private internalData;
-    /** LogicFlow 实例引用 (由外部传入或在 init 时创建) */
     private lfInstance;
-    /** 已安装的插件列表 */
     private plugins;
-    /** 是否已初始化 */
     private initialized;
-    /** 语言变更取消监听 */
     private disposeLocaleChange;
-    /**
-     * 创建编辑器核心实例
-     *
-     * @param options - 编辑器配置选项
-     * @see EditorOptions 完整的配置说明
-     */
+    private disposeThemeChange;
+    private fieldChangeContributionHandlers;
     constructor(options: EditorOptions);
-    /**
-     * 初始化编辑器
-     *
-     * 这个方法在 DOM 容器准备好之后调用 (框架适配层的 mounted/useEffect 中)。
-     * 它负责:
-     * 1. 保存 LogicFlow 实例引用
-     * 2. 应用初始主题
-     * 3. 通知插件
-     * 4. 触发 editor:ready 事件
-     *
-     * @param lfInstance - 外部创建的 LogicFlow 实例 (可选)
-     */
     init(lfInstance?: unknown): void;
-    /**
-     * 销毁编辑器, 释放所有资源
-     *
-     * 必须在组件卸载时调用 (框架适配层的 unmounted/useEffect cleanup 中)
-     */
     destroy(): void;
-    /**
-     * 加载组件定义并同步组件映射、分组状态。
-     *
-     * 框架适配层应优先使用该入口；直接操作 componentRegistry 只会更新注册表，
-     * 不会自动通知 React/Vue/DOM UI 订阅的 componentGroups。
-     *
-     * @param components - 组件定义列表，通常来自 /api/v1/components 或 options.components
-     * @returns 按分类分组后的组件列表
-     */
     loadComponents(components: RawComponentData): ComponentGroup[];
-    /**
-     * 增量注册组件定义并同步组件分组状态。
-     *
-     * @param components - 需要追加或覆盖的组件定义
-     * @param overwrite - 已存在 type 时是否覆盖
-     * @returns 按分类分组后的组件列表
-     */
     registerComponents(components: ComponentDefinition[], overwrite?: boolean): ComponentGroup[];
     private syncComponentState;
     private localizeComponentGroups;
-    /**
-     * 加载规则链数据并渲染到画布
-     *
-     * 转换流程:
-     * RuleChainData → DataAdapter.adapterIn → LogicFlow.render
-     *
-     * @param ruleChainData - RuleGo 规则链 JSON 数据
-     * @see DataAdapter.adapterIn 数据转换详情
-     */
     loadData(ruleChainData: RuleChainData): void;
-    /**
-     * 从画布导出 RuleGo 格式数据 (用于保存)
-     *
-     * 转换流程:
-     * LogicFlow.getGraphData → DataAdapter.adapterOut → RuleChainData
-     *
-     * @param lfGraphData - LogicFlow 当前图数据
-     * @param getNodeModelById - LogicFlow 节点查询函数
-     * @returns RuleGo 格式的规则链数据
-     * @see DataAdapter.adapterOut 数据转换详情
-     */
     exportData(lfGraphData: LFGraphData, getNodeModelById: (id: string) => LFNodeData | null): RuleChainData;
-    /**
-     * 验证当前图数据
-     *
-     * @param lfGraphData - LogicFlow 当前图数据
-     * @returns 验证结果
-     * @see ValidationEngine.validate
-     */
     validateGraph(lfGraphData: LFGraphData): import("./ValidationEngine").ValidationResult;
-    /**
-     * 监听编辑器事件
-     *
-     * @param event - 事件名
-     * @param handler - 事件处理函数
-     * @returns 取消监听函数
-     * @see EditorEventMap 所有可监听事件及其载荷类型
-     */
+    validateTopology(lfGraphData: LFGraphData): DiagnosticItem[];
+    invokeAction(id: string, runtime: EditorActionContext['runtime'], selection?: EditorSelectionSnapshot, source?: EditorActionSource, extra?: Record<string, unknown>): Promise<boolean>;
     on<K extends EditorEventName>(event: K, handler: (payload: EditorEventMap[K]) => void): () => void;
-    /**
-     * 触发编辑器事件
-     *
-     * @param event - 事件名
-     * @param args - 事件载荷
-     */
     emit<K extends EditorEventName>(event: K, ...args: EditorEventMap[K] extends void ? [] : [EditorEventMap[K]]): void;
-    /**
-     * 安装插件
-     *
-     * 插件可以在编辑器生命周期的各个阶段注入自定义逻辑:
-     * - onInit: 编辑器初始化后
-     * - beforeDataLoad: 数据加载前 (可修改数据)
-     * - beforeDataSave: 数据保存前 (可修改数据)
-     * - onDestroy: 编辑器销毁前
-     *
-     * @param plugin - 插件实例
-     * @see EditorPlugin 插件接口
-     */
     use(plugin: EditorPlugin): void;
-    /**
-     * 获取内部运行时数据 (只读)
-     * 主要供 DataAdapter 和框架适配层使用
-     */
     getInternalData(): Readonly<EditorInternalData>;
-    /**
-     * 获取 LogicFlow 实例引用
-     * 供框架适配层在需要直接操作 LogicFlow 时使用
-     */
     getLfInstance(): unknown;
-    /**
-     * 获取编辑器配置选项
-     */
     getOptions(): Readonly<EditorOptions>;
+    updateOptions(patch: Partial<Omit<EditorOptions, 'container'>>): void;
+    private toProviderFieldOptions;
 }
 export {};
-//# sourceMappingURL=EditorCore.d.ts.map

package/dist/core/EditorWorkspace.d.ts

@@ -0,0 +1,111 @@
+import type { RuleChainData } from '../types/rule-chain';
+export interface EditorWorkspaceTab {
+    id: string;
+    chainId: string;
+    title: string;
+    data: RuleChainData | null;
+    savedData: RuleChainData | null;
+    isDirty: boolean;
+    isLoading: boolean;
+    readonly: boolean;
+    pinned?: boolean;
+    metadata?: Record<string, unknown>;
+}
+export interface EditorWorkspaceState extends Record<string, unknown> {
+    tabs: EditorWorkspaceTab[];
+    activeTabId: string | null;
+}
+export interface OpenWorkspaceTabInput {
+    chainId?: string;
+    title?: string;
+    data?: RuleChainData | null;
+    savedData?: RuleChainData | null;
+    isLoading?: boolean;
+    readonly?: boolean;
+    pinned?: boolean;
+    metadata?: Record<string, unknown>;
+    allowDuplicate?: boolean;
+    activate?: boolean;
+}
+export type WorkspaceCloseDecision = 'save' | 'discard' | 'keep-editing' | 'cancel';
+export type WorkspaceCloseResultReason = 'decision-required' | 'cancelled' | 'discarded' | 'saved' | 'save-unavailable' | 'save-failed' | 'conflict' | 'readonly' | 'busy' | 'destroyed';
+export interface WorkspaceSaveResponse {
+    success: boolean;
+    data?: RuleChainData | null;
+    conflict?: boolean;
+    remoteData?: RuleChainData | null;
+    error?: unknown;
+}
+export type WorkspaceSaveOutcome = {
+    status: 'saved';
+    data?: RuleChainData | null;
+} | {
+    status: 'failed';
+    error?: unknown;
+} | {
+    status: 'conflict';
+    remoteData?: RuleChainData | null;
+    error?: unknown;
+};
+export type WorkspaceSaveHandlerResult = WorkspaceSaveOutcome | WorkspaceSaveResponse | boolean | void;
+export type WorkspaceSaveHandler = (data: RuleChainData | null, tab: EditorWorkspaceTab) => WorkspaceSaveHandlerResult | PromiseLike<WorkspaceSaveHandlerResult>;
+type WorkspaceSyncSaveHandler = (data: RuleChainData | null, tab: EditorWorkspaceTab) => WorkspaceSaveHandlerResult;
+export interface CloseWorkspaceTabOptions {
+    discard?: boolean;
+    decision?: WorkspaceCloseDecision;
+    save?: WorkspaceSyncSaveHandler;
+}
+export interface CloseWorkspaceTabDecisionOptions extends Omit<CloseWorkspaceTabOptions, 'save'> {
+    save?: WorkspaceSaveHandler;
+}
+export interface CloseWorkspaceTabResult {
+    closed: boolean;
+    requiresConfirmation: boolean;
+    tab: EditorWorkspaceTab | null;
+    decision?: WorkspaceCloseDecision;
+    reason?: WorkspaceCloseResultReason;
+    saveResult?: WorkspaceSaveOutcome;
+}
+export type WorkspaceConflictResolution = 'keep-local' | 'use-remote' | 'cancel';
+export interface WorkspaceConflictResult {
+    resolved: boolean;
+    tab: EditorWorkspaceTab | null;
+}
+export type WorkspaceListener = (state: Readonly<EditorWorkspaceState>, previousState: Readonly<EditorWorkspaceState>) => void;
+export declare class EditorWorkspace {
+    private readonly store;
+    private nextId;
+    private destroyed;
+    constructor(initial?: {
+        tabs?: OpenWorkspaceTabInput[];
+        activeTabId?: string | null;
+    });
+    getState(): Readonly<EditorWorkspaceState>;
+    getTabs(): EditorWorkspaceTab[];
+    getTab(tabId: string): EditorWorkspaceTab | null;
+    getActiveTab(): EditorWorkspaceTab | null;
+    subscribe(listener: WorkspaceListener): () => void;
+    openTab(input?: OpenWorkspaceTabInput): EditorWorkspaceTab;
+    activateTab(tabId: string): boolean;
+    renameTab(tabId: string, title: string): boolean;
+    togglePinned(tabId: string): boolean;
+    getCloseOtherTabIds(tabId: string): string[];
+    getCloseRightTabIds(tabId: string): string[];
+    setDraft(tabId: string, data: RuleChainData | null): EditorWorkspaceTab | null;
+    updateRuleChainLifecycle(tabId: string, disabled: boolean): EditorWorkspaceTab | null;
+    markSaved(tabId: string, data?: RuleChainData | null): EditorWorkspaceTab | null;
+    setLoading(tabId: string, isLoading: boolean): boolean;
+    closeTab(tabId: string, options?: CloseWorkspaceTabOptions): CloseWorkspaceTabResult;
+    closeTabWithDecision(tabId: string, options?: CloseWorkspaceTabDecisionOptions): Promise<CloseWorkspaceTabResult>;
+    private closeTabSync;
+    private resolveCloseDecision;
+    private prepareSave;
+    private saveAndClose;
+    private normalizeSaveResult;
+    private finishSave;
+    private saveFailure;
+    private removeTab;
+    resolveSaveConflict(tabId: string, resolution: WorkspaceConflictResolution, remoteData?: RuleChainData | null): WorkspaceConflictResult;
+    destroy(): void;
+}
+export {};

package/dist/core/EventBus.d.ts

@@ -1,101 +1,15 @@
-/**
- * @file EventBus.ts
- * @description 类型安全的事件总线
- *
- * 基于 EditorEventMap 提供强类型的事件发布/订阅。
- * 与 LogicFlow 的 eventCenter 分工:
- * - LogicFlow eventCenter: 处理画布级别的原生事件 (node:click, edge:add 等)
- * - EventBus: 处理编辑器业务级别的事件 (editor:save, history:change 等)
- *
- * 特性:
- * - 强类型: 事件名和负载类型在编译期绑定
- * - 一次性监听: once() 方法只触发一次
- * - 安全清理: destroy() 清除所有监听器
- * - 调试模式: 可选事件追踪日志
- */
 import type { EditorEventMap, EditorEventName } from '../types/events';
-/**
- * 事件监听器函数类型
- */
 type Listener<T> = (payload: T) => void;
-/**
- * 类型安全的事件总线
- *
- * @example
- * ```typescript
- * const bus = new EventBus()
- *
- * // 订阅事件 (有类型提示)
- * bus.on('node:click', (payload) => {
- *   // payload 的类型自动推断为 NodeEventPayload
- *   console.log(payload.id, payload.type)
- * })
- *
- * // 触发事件
- * bus.emit('node:click', { id: 'node_1', type: 'simple-node', ... })
- *
- * // 取消订阅
- * const off = bus.on('editor:save', handler)
- * off() // 取消
- * ```
- */
 export declare class EventBus {
-    /** 事件监听器映射: 事件名 => 监听器列表 */
     private listeners;
-    /** 是否启用调试模式 */
     private debug;
-    /**
-     * 创建事件总线
-     * @param debug - 是否启用调试日志 (默认: false)
-     */
     constructor(debug?: boolean);
-    /**
-     * 订阅事件
-     *
-     * @param event - 事件名称
-     * @param callback - 事件回调函数
-     * @returns 取消订阅的函数
-     */
     on<E extends EditorEventName>(event: E, callback: Listener<EditorEventMap[E]>): () => void;
-    /**
-     * 一次性订阅事件 (只触发一次后自动取消)
-     *
-     * @param event - 事件名称
-     * @param callback - 事件回调函数
-     * @returns 取消订阅的函数
-     */
     once<E extends EditorEventName>(event: E, callback: Listener<EditorEventMap[E]>): () => void;
-    /**
-     * 取消订阅事件
-     *
-     * @param event - 事件名称
-     * @param callback - 要移除的回调函数
-     */
     off<E extends EditorEventName>(event: E, callback: Listener<EditorEventMap[E]>): void;
-    /**
-     * 触发事件，通知所有订阅者
-     *
-     * @param event - 事件名称
-     * @param payload - 事件负载数据
-     */
     emit<E extends EditorEventName>(event: E, ...args: EditorEventMap[E] extends void ? [] : [EditorEventMap[E]]): void;
-    /**
-     * 移除指定事件的所有监听器
-     *
-     * @param event - 事件名称 (不传则移除所有事件的监听器)
-     */
     removeAll(event?: EditorEventName): void;
-    /**
-     * 获取指定事件的监听器数量 (用于调试)
-     *
-     * @param event - 事件名称
-     * @returns 监听器数量
-     */
     listenerCount(event: EditorEventName): number;
-    /**
-     * 销毁事件总线, 清除所有监听器
-     */
     destroy(): void;
 }
 export {};
-//# sourceMappingURL=EventBus.d.ts.map

package/dist/core/ExplorerTreeStore.d.ts

@@ -0,0 +1,43 @@
+import type { WorkflowItem } from '../api/types';
+import { type ExplorerTreeLabels, type ExplorerTreeNode } from './explorer-tree';
+import { type EditorStatePersistenceOptions } from './editor-dock';
+export interface ExplorerTreePersistenceState {
+    expandedKeys: string[];
+}
+export interface ExplorerTreeStoreOptions {
+    workflows?: readonly WorkflowItem[];
+    keyword?: string;
+    activeChainId?: string;
+    labels?: Partial<ExplorerTreeLabels>;
+    smallTreeMax?: number;
+    persistence?: EditorStatePersistenceOptions<ExplorerTreePersistenceState>;
+}
+export interface ExplorerTreeState extends Record<string, unknown> {
+    tree: ExplorerTreeNode[];
+    keyword: string;
+    activeChainId: string;
+    rememberedExpandedKeys: string[];
+    forcedExpandedKeys: string[];
+    expandedKeys: string[];
+}
+export declare class ExplorerTreeStore {
+    private readonly store;
+    private readonly labels?;
+    private readonly smallTreeMax;
+    private readonly persistence;
+    private workflows;
+    private seeded;
+    private destroyed;
+    constructor(options?: ExplorerTreeStoreOptions);
+    getState(): ExplorerTreeState;
+    subscribe(listener: (state: ExplorerTreeState, previous: ExplorerTreeState) => void): () => void;
+    setWorkflows(workflows: readonly WorkflowItem[]): void;
+    setKeyword(keyword: string): void;
+    setActiveChainId(chainId: string): void;
+    setExpanded(key: string, expanded: boolean): boolean;
+    toggleExpanded(key: string): boolean;
+    destroy(): void;
+    private rebuild;
+    private resolveRememberedKeys;
+    private resolveForcedKeys;
+}

package/dist/core/FieldCapabilityRegistry.d.ts

@@ -0,0 +1,16 @@
+import type { ComponentDefinition, ComponentFieldOption } from '../types/component';
+export interface FieldCapabilityContext {
+    aiProviders?: ComponentFieldOption[];
+    aiEmbeddingProviders?: ComponentFieldOption[];
+    [key: string]: unknown;
+}
+export type FieldCapabilityHandler = (component: ComponentDefinition, params: Record<string, unknown>, context: FieldCapabilityContext) => void;
+export declare class FieldCapabilityRegistry {
+    private handlers;
+    constructor();
+    register(name: string, handler: FieldCapabilityHandler, overwrite?: boolean): void;
+    unregister(name: string): boolean;
+    clear(): void;
+    apply(component: ComponentDefinition, context?: FieldCapabilityContext): ComponentDefinition;
+    private registerBuiltinCapabilities;
+}

package/dist/core/FieldChangeRegistry.d.ts

@@ -0,0 +1,48 @@
+import type { ComponentField } from '../types/component';
+export interface FieldChangeResolveContext {
+    configuration: Readonly<Record<string, unknown>>;
+    currentNodeId?: string;
+    graphNodes?: Array<{
+        id: string;
+        name?: string;
+        type?: string;
+    }>;
+    requestKey?: string;
+    signal?: AbortSignal;
+    [key: string]: unknown;
+}
+export interface FieldChangeContext extends Omit<FieldChangeResolveContext, 'signal'> {
+    field: ComponentField;
+    signal: AbortSignal;
+}
+export interface FieldChangeResult {
+    patch?: Record<string, unknown>;
+    remove?: readonly string[];
+}
+export type FieldChangeHandler = (value: unknown, configuration: Readonly<Record<string, unknown>>, context: FieldChangeContext) => FieldChangeResult | void | Promise<FieldChangeResult | void>;
+export type FieldChangeExecutionStatus = 'skipped' | 'applied' | 'aborted';
+export interface FieldChangeExecutionResult extends FieldChangeResult {
+    status: FieldChangeExecutionStatus;
+    handlerName?: string;
+    generation: number;
+}
+export declare class FieldChangeHandlerNotFoundError extends Error {
+    readonly handlerName: string;
+    constructor(handlerName: string);
+}
+export declare function getFieldChangeHandlerName(field: ComponentField): string | undefined;
+export declare class FieldChangeRegistry {
+    private handlers;
+    private active;
+    private generation;
+    private abortHandlerExecutions;
+    register(name: string, handler: FieldChangeHandler, overwrite?: boolean): void;
+    unregister(name: string): boolean;
+    has(name: string): boolean;
+    resolve(name: string): FieldChangeHandler | undefined;
+    private requestKey;
+    execute(field: ComponentField, value: unknown, context: FieldChangeResolveContext): Promise<FieldChangeExecutionResult>;
+    abort(requestKey: string): boolean;
+    abortAll(): void;
+    clear(): void;
+}