@robot-admin/naive-ui-components 0.22.1 → 0.23.1

package/dist/useDynamicFormState.d.ts

@@ -1,7 +1,12 @@
-import { A as FormSlots, B as OptionItem, D as FormModel, H as SubmitEventPayload, O as FormOption, R as LayoutType, T as FormInstance, a as ResolvedFormConfig, h as ComponentType, k as FormRecord, n as FormConfig, y as DynamicFormController } from "./useFormConfig.js";
+import { n as ComponentLocale, t as ComponentFeedback } from "./contracts.js";
+import { D as FormSlots, E as FormRecord, F as LayoutType, L as OptionItem, S as FormInstance, T as FormOption, a as ResolvedFormConfig, f as ComponentType, g as DynamicFormController, n as FormConfig, w as FormModel, z as SubmitEventPayload } from "./useFormConfig.js";
+import { n as DictionaryOption } from "./dictionary.js";
+import { n as ResolvedComponentDensity, t as ComponentDensity } from "./density.js";
+import { $ as FormatterConfig, A as UseTableActionsOptions, B as ExpandConfig, D as TableRowKey, F as ColumnDragConfig, G as ToolbarConfig, H as SelectionConfig, K as TreeConfig, L as DisplayConfig, M as UseTableExpandOptions, N as UseTableExpandReturn, O as TableRowKeyIssue, P as BatchActionsConfig, R as EditConfig, S as TableColumn, U as SummaryConfig, V as ResolvedConfig, W as TableConfig, X as ExportConfig, b as SimpleTableActions, d as DataRecord, f as EditMode, g as ParentChildLinkMode, h as PaginationConfig, ht as DynamicRowsReturn, j as UseTableActionsReturn, k as TableRuntimeProps, mt as DynamicRowsOptions, ot as CrossPageSelectionConfig, q as VirtualScrollConfig, ut as RowDragConfig, w as TableInstance, x as StrictTableColumn, z as ErrorConfig } from "./index11.vue.js";
 import * as vue from "vue";
-import { Component, ComputedRef, InjectionKey, MaybeRefOrGetter, Ref, ShallowRef, Slots, VNode } from "vue";
-import { FormInst, FormItemInst, FormRules } from "naive-ui";
+import { App, Component, ComputedRef, InjectionKey, MaybeRefOrGetter, Ref, ShallowRef, Slots, VNode, VNodeChild } from "vue";
+import { DataTableColumn, DataTableRowKey, FormInst, FormItemInst, FormRules, PaginationProps, TreeInst, TreeOption, TreeProps } from "naive-ui";
+import { HLJSApi } from "highlight.js";
 
 //#region src/components/C_Form/composables/useFormRenderer.d.ts
 type ComponentMap = Record<string, Component>;
@@ -31,6 +36,8 @@ interface UseFormRendererOptions {
   instanceSlots?: Readonly<Slots>;
   asyncOptionsCache: Ref<Record<string, OptionItem[]>>;
   asyncLoadingMap: Ref<Record<string, boolean>>;
+  getDictionaryOptions?: (field: string) => readonly DictionaryOption[];
+  isDictionaryLoading?: (field: string) => boolean;
   renderers?: ComputedRef<Record<string, FormRenderer> | undefined>;
   /** Overrides application injection. An isolated registry never reads legacy globals. */
   registry?: FormRendererRegistry;
@@ -65,22 +72,23 @@ declare function useFormRenderer(opts: UseFormRendererOptions): {
 };
 //#endregion
 //#region src/components/C_Form/index.vue.d.ts
-declare const __VLS_export: <T extends object = FormRecord>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
-  props: vue.PublicProps & __VLS_PrettifyLocal<{
+declare const __VLS_export$3: <T extends object = FormRecord>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal$3<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+  props: vue.PublicProps & __VLS_PrettifyLocal$3<{
     /** 字段配置数组 */options: FormOption<T>[]; /** 双向绑定表单数据 */
     modelValue?: FormModel<T>; /** 统一配置对象（收拢原先 13 个分散 Props） */
     config?: FormConfig<T>; /** 当前表单实例的自定义渲染器，不污染全局注册表 */
     renderers?: Record<string, FormRenderer>;
   } & {
     "onUpdate:modelValue"?: ((model: T) => any) | undefined;
-    "onValidate-error"?: ((errors: unknown) => any) | undefined;
     onSubmit?: ((payload: SubmitEventPayload<T>) => any) | undefined;
     "onValidate-success"?: ((model: T) => any) | undefined;
+    "onValidate-error"?: ((errors: unknown) => any) | undefined;
   }> & (typeof globalThis extends {
     __VLS_PROPS_FALLBACK: infer P;
   } ? P : {});
   expose: (exposed: vue.ShallowUnwrapRef<{
     validate: () => Promise<void>;
+    revealField: (field: string) => Promise<boolean>;
     validateField: (field: string | string[]) => Promise<void>;
     validateStep: (step: number | string) => Promise<boolean>;
     validateTab: (tabKey: string) => Promise<boolean>;
@@ -110,12 +118,12 @@ declare const __VLS_export: <T extends object = FormRecord>(__VLS_props: NonNull
   }>) => void;
   attrs: any;
   slots: FormSlots<T>;
-  emit: ((evt: "update:modelValue", model: T) => void) & ((evt: "validate-error", errors: unknown) => void) & ((evt: "submit", payload: SubmitEventPayload<T>) => void) & ((evt: "validate-success", model: T) => void);
+  emit: ((evt: "update:modelValue", model: T) => void) & ((evt: "submit", payload: SubmitEventPayload<T>) => void) & ((evt: "validate-success", model: T) => void) & ((evt: "validate-error", errors: unknown) => void);
 }>) => vue.VNode & {
   __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
 };
-declare const _default: typeof __VLS_export;
-type __VLS_PrettifyLocal<T> = (T extends any ? { [K in keyof T]: T[K] } : { [K in keyof T as K]: T[K] }) & {};
+declare const _default$3: typeof __VLS_export$3;
+type __VLS_PrettifyLocal$3<T> = (T extends any ? { [K in keyof T]: T[K] } : { [K in keyof T as K]: T[K] }) & {};
 //#endregion
 //#region src/components/C_Form/helpers.d.ts
 /** Preserve business-model field inference without changing the component API. */
@@ -146,6 +154,935 @@ interface UseCFormReturn<T extends object> {
 /** Small binding helper for the common controlled C_Form setup. */
 declare function useCForm<T extends object>(setup: UseCFormOptions<T>): UseCFormReturn<T>;
 //#endregion
+//#region src/plugins/highlight.d.ts
+interface HighlightPluginOptions {
+  autoDetect?: boolean;
+  extraLanguages?: string[];
+  /** Explicit compatibility bridge; restored when the owning app unmounts. */
+  exposeToWindow?: boolean;
+  /** Enable lifecycle diagnostics through the supplied logger. */
+  debug?: boolean;
+  logger?: Pick<Console, 'info' | 'warn' | 'error'>;
+  onError?: (error: unknown, context: {
+    source: 'language-loader';
+    language: string;
+  }) => void;
+}
+interface HighlightAPI {
+  getHljs: () => HLJSApi;
+  loadLanguage: (language: string) => Promise<boolean>;
+  loadLanguages: (languages: string[]) => Promise<string[]>;
+  getLoadedLanguages: () => string[];
+}
+/** Create an independent highlighter, including its language registry and loaders. */
+declare function createHighlight(options?: HighlightPluginOptions): HighlightAPI;
+/** Reuse the current app's highlighter or create a standalone, isolated one. */
+declare function useHighlight(options?: HighlightPluginOptions): HighlightAPI;
+/**
+ * * @description 安装 highlight.js 插件到 Vue 应用
+ * ? @param app - Vue 应用实例
+ * ? @param options - 插件配置选项
+ * ! @return 应用独立的 highlight API
+ */
+declare function setupHighlight(app: App, options?: HighlightPluginOptions): HighlightAPI;
+//#endregion
+//#region src/components/C_Table/index.vue.d.ts
+declare const __VLS_export$2: <T extends object = DataRecord, C = unknown>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal$2<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+  props: vue.PublicProps & __VLS_PrettifyLocal$2<TableRuntimeProps<T, C> & {
+    onCancel?: ((rowData: T, rowIndex: number) => any) | undefined;
+    onSave?: ((rowData: T, rowIndex: number, columnKey?: string | undefined) => any) | undefined;
+    "onPagination-change"?: ((page: number, pageSize: number) => any) | undefined;
+    "onRow-delete"?: ((deletedRow: T, index: number) => any) | undefined;
+    "onBatch-action-error"?: ((error: unknown, actionKey: string) => any) | undefined;
+    "onRow-key-error"?: ((issues: TableRowKeyIssue<T>[]) => any) | undefined;
+    "onRow-add"?: ((newRow: T) => any) | undefined;
+    "onRow-copy"?: ((originalRow: T, newRow: T) => any) | undefined;
+    "onRow-move"?: ((row: T, fromIndex: number, toIndex: number) => any) | undefined;
+    "onRow-selection-change"?: ((selectedKey: DataTableRowKey | null, selectedRow: T | null) => any) | undefined;
+    "onView-detail"?: ((data: T) => any) | undefined;
+    "onColumn-change"?: ((columns: TableColumn<T>[]) => any) | undefined;
+    "onExpand-change"?: ((expandedKeys: DataTableRowKey[], row?: T | undefined, expanded?: boolean | undefined) => any) | undefined;
+    "onSelection-change"?: ((checkedKeys: DataTableRowKey[], checkedRows: T[], childSelections?: Map<DataTableRowKey, DataTableRowKey[]> | undefined) => any) | undefined;
+    "onChild-selection-change"?: ((parentKey: DataTableRowKey, childKeys: DataTableRowKey[], childRows: C[]) => any) | undefined;
+    "onParent-child-link-change"?: ((parentKey: DataTableRowKey, shouldSelect: boolean) => any) | undefined;
+    "onUpdate:data"?: ((data: T[]) => any) | undefined;
+    "onEdit-error"?: ((error: unknown) => any) | undefined;
+  }> & (typeof globalThis extends {
+    __VLS_PROPS_FALLBACK: infer P;
+  } ? P : {});
+  expose: (exposed: vue.ShallowUnwrapRef<TableInstance<T, C>>) => void;
+  attrs: any;
+  slots: {
+    'toolbar-left'?: (props: {}) => any;
+  } & {
+    'toolbar-right'?: (props: {}) => any;
+  } & {
+    error?: (props: {
+      error: ErrorConfig;
+    }) => any;
+  } & {
+    loading?: (props: {}) => any;
+  };
+  emit: ((evt: "cancel", rowData: T, rowIndex: number) => void) & ((evt: "save", rowData: T, rowIndex: number, columnKey?: string | undefined) => void) & ((evt: "pagination-change", page: number, pageSize: number) => void) & ((evt: "row-delete", deletedRow: T, index: number) => void) & ((evt: "batch-action-error", error: unknown, actionKey: string) => void) & ((evt: "row-key-error", issues: TableRowKeyIssue<T>[]) => void) & ((evt: "row-add", newRow: T) => void) & ((evt: "row-copy", originalRow: T, newRow: T) => void) & ((evt: "row-move", row: T, fromIndex: number, toIndex: number) => void) & ((evt: "row-selection-change", selectedKey: DataTableRowKey | null, selectedRow: T | null) => void) & ((evt: "view-detail", data: T) => void) & ((evt: "column-change", columns: TableColumn<T>[]) => void) & ((evt: "expand-change", expandedKeys: DataTableRowKey[], row?: T | undefined, expanded?: boolean | undefined) => void) & ((evt: "selection-change", checkedKeys: DataTableRowKey[], checkedRows: T[], childSelections?: Map<DataTableRowKey, DataTableRowKey[]> | undefined) => void) & ((evt: "child-selection-change", parentKey: DataTableRowKey, childKeys: DataTableRowKey[], childRows: C[]) => void) & ((evt: "parent-child-link-change", parentKey: DataTableRowKey, shouldSelect: boolean) => void) & ((evt: "update:data", data: T[]) => void) & ((evt: "edit-error", error: unknown) => void);
+}>) => vue.VNode & {
+  __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+declare const _default$2: typeof __VLS_export$2;
+type __VLS_PrettifyLocal$2<T> = (T extends any ? { [K in keyof T]: T[K] } : { [K in keyof T as K]: T[K] }) & {};
+//#endregion
+//#region src/components/C_Table/helpers.d.ts
+/** Type-safe identity helper that rejects misspelled business field keys. */
+declare function defineTableColumns<T extends object>(columns: StrictTableColumn<T>[]): StrictTableColumn<T>[];
+/** Preserve row types across edit, action, summary and batch callbacks. */
+declare function defineTableConfig<T extends object, C = unknown>(config: TableConfig<T, C>): TableConfig<T, C>;
+/** Find missing and duplicate row keys before stateful table features consume them. */
+declare function validateTableRowKeys<T extends object>(data: readonly T[], rowKey: (row: T) => DataTableRowKey | null | undefined): TableRowKeyIssue<T>[];
+//#endregion
+//#region src/components/C_Table/composables/useTableColumns.d.ts
+/** useTableColumns 中对 tableManager 的最小依赖接口 */
+interface TableManagerRef {
+  editStates: {
+    cellEdit: {
+      isSaving?: Ref<boolean>;
+      isEditingCell: (rowKey: DataTableRowKey, columnKey: string) => boolean;
+      getEditingCellValue: (rowKey: DataTableRowKey, columnKey: string) => unknown;
+      updateEditingCellValue: (rowKey: DataTableRowKey, columnKey: string, value: unknown) => void;
+      saveEditCell: () => Promise<unknown>;
+      cancelEditCell: () => void;
+      startEditCell: (rowKey: DataTableRowKey, columnKey: string) => void;
+    };
+    rowEdit: {
+      isSaving?: Ref<boolean>;
+      isEditingRow: (rowKey: DataTableRowKey) => boolean;
+      getEditingRowData: (rowKey: DataTableRowKey) => DataRecord | undefined;
+      updateEditingRowData: (rowKey: DataTableRowKey, field: string, value: unknown) => void;
+    };
+  };
+  dynamicRowsState?: {
+    enhanceColumns: (columns: TableColumn[]) => TableColumn[];
+  } | null;
+  expandState?: {
+    getTableColumns: (originalColumns: TableColumn[]) => DataTableColumn[];
+  } | null;
+}
+interface UseTableColumnsOptions {
+  /** 原始列配置 */
+  rawColumns: ComputedRef<TableColumn[]>;
+  /** 统一配置 */
+  config: ComputedRef<ResolvedConfig>;
+  /** 默认列宽 */
+  columnWidth: number;
+  /** 区分使用侧显式统一列宽与内部默认值，不把默认值强加给弹性业务列。 */
+  columnWidthExplicit?: boolean;
+  /** 用户设定的 scrollX */
+  scrollX?: number | string;
+  /** 行键获取函数 */
+  rowKey: (row: DataRecord) => DataTableRowKey;
+  /** 表格管理器 */
+  tableManager: TableManagerRef;
+  /** 操作列渲染函数 */
+  actionsRenderer: (row: DataRecord, index: number) => VNodeChild;
+  /** 编辑模式检查器 */
+  editModeChecker: ComputedRef<{
+    isNonEditable: (column: TableColumn) => boolean;
+    isRowEditMode: () => boolean;
+    isCellEditMode: () => boolean;
+  }>;
+  /** 是否渲染操作列 */
+  showActionsColumn: ComputedRef<boolean>;
+}
+interface UseTableColumnsReturn {
+  reactiveColumns: Ref<TableColumn[]>;
+  showSettingsPanel: Ref<boolean>;
+  computedColumns: ComputedRef<DataTableColumn[]>;
+  computedScrollX: ComputedRef<number | string | undefined>;
+  getDictionaryLabel: (column: TableColumn, value: unknown) => string;
+  handleColumnChange: (columns: TableColumn[]) => void;
+}
+/**
+ * 表格列处理引擎
+ */
+declare function useTableColumns(options: UseTableColumnsOptions): UseTableColumnsReturn;
+//#endregion
+//#region src/components/C_Table/composables/useRowEdit.d.ts
+/** 行级校验错误 */
+interface RowValidationError {
+  field: string;
+  message: string;
+}
+/**
+ * 行编辑配置选项
+ */
+interface RowEditOptions {
+  data: () => DataRecord[];
+  rowKey: (row: DataRecord) => DataTableRowKey;
+  onSave?: (rowData: DataRecord, rowIndex: number, originalKey?: DataTableRowKey) => unknown;
+  onCancel?: (rowData: DataRecord, rowIndex: number) => unknown;
+  /** 列配置（用于提取校验规则） */
+  columns?: () => TableColumn[];
+}
+/**
+ * 可编辑行组合函数，提供表格整行的编辑功能
+ */
+declare function useRowEdit(options: RowEditOptions): {
+  editingRowKey: vue.Ref<DataTableRowKey | null, DataTableRowKey | null>;
+  editingData: vue.Ref<Record<string, DataRecord>, Record<string, DataRecord>>;
+  isSaving: vue.Ref<boolean, boolean>;
+  isEditingRow: (rowKey: DataTableRowKey) => boolean;
+  startEditRow: (rowKey: DataTableRowKey) => boolean;
+  cancelEditRow: () => Promise<void>;
+  saveEditRow: () => Promise<{
+    updatedData: DataRecord;
+    rowIndex: number;
+  } | undefined>;
+  validateRow: () => Promise<boolean>;
+  validationErrors: vue.Ref<{
+    field: string;
+    message: string;
+  }[], RowValidationError[] | {
+    field: string;
+    message: string;
+  }[]>;
+  getEditingRowData: (rowKey: DataTableRowKey) => DataRecord | undefined;
+  updateEditingRowData: (rowKey: DataTableRowKey, field: string, value: unknown) => void;
+  findRowData: (rowKey: DataTableRowKey) => DataRecord | null | undefined;
+  invalidate: () => void;
+};
+//#endregion
+//#region src/components/C_Table/composables/useTableManager.d.ts
+/**
+ * 表格管理器配置接口
+ */
+interface TableManagerConfig {
+  feedback?: ComponentFeedback;
+  locale?: ComponentLocale;
+  editable: boolean;
+  editMode: string;
+  showRowActions: boolean;
+  modalTitle: string;
+  modalWidth: number;
+  onEditSave?: (rowData: DataRecord, rowIndex: number, columnKey?: string) => unknown;
+  onEditCancel?: (rowData: DataRecord, rowIndex: number) => unknown;
+  onEditError?: (error: unknown) => void;
+  expandable: boolean;
+  defaultExpandedKeys?: DataTableRowKey[];
+  onLoadExpandData?: (row: DataRecord) => Promise<any[]> | any[];
+  onExpandError?: (error: unknown, row: DataRecord) => void;
+  renderExpandContent?: unknown;
+  rowExpandable?: (row: DataRecord) => boolean;
+  enableSelection: boolean;
+  defaultCheckedKeys?: DataTableRowKey[];
+  rowCheckable?: (row: DataRecord) => boolean;
+  maxSelection?: number;
+  enableChildSelection: boolean;
+  childRowCheckable?: (childRow: DataRecord, parentRow: DataRecord) => boolean;
+  enableParentChildLink: boolean;
+  parentChildLinkMode: ParentChildLinkMode;
+  dynamicRows?: DynamicRowsOptions<DataRecord>;
+  treeEnabled?: boolean;
+  treeChildrenKey?: string;
+}
+/**
+ * 表格管理器参数接口
+ */
+interface TableManagerParams {
+  config: MaybeRefOrGetter<TableManagerConfig>;
+  data: () => DataRecord[];
+  rowKey: (row: DataRecord) => DataTableRowKey;
+  emit: (...args: any[]) => unknown;
+  /** 列配置（用于编辑校验） */
+  columns?: () => TableColumn[];
+  /** UI 壳提供加载内容，状态引擎保持可独立调用。 */
+  renderLoading?: () => VNodeChild;
+  /** String row-key field inherited by dynamic row creation; explicit dynamicRows.rowKey wins. */
+  rowKeyField?: MaybeRefOrGetter<string | undefined>;
+}
+/**
+ * 事件处理器接口
+ */
+interface EventHandlers {
+  onSave: (rowData: DataRecord, rowIndex: number, columnKey?: string, originalKey?: DataTableRowKey) => Promise<void>;
+  onCancel: (rowData: DataRecord, rowIndex: number) => Promise<void>;
+  onExpandChange: (keys: DataTableRowKey[], row?: DataRecord, expanded?: boolean) => void;
+  onSelectionChange: (checkedKeys: DataTableRowKey[], checkedRows: DataRecord[], childSelections: Map<DataTableRowKey, DataTableRowKey[]>) => void;
+  onChildSelectionChange: (parentKey: DataTableRowKey, childKeys: DataTableRowKey[], childRows: DataRecord[]) => void;
+  onRowChange: (data: DataRecord[]) => void;
+  onRowSelectionChange: (selectedKey: DataTableRowKey | null, selectedRow: DataRecord | null) => void;
+  onRowAdd: (newRow: DataRecord) => void;
+  onRowDelete: (deletedRow: DataRecord, index: number) => void;
+  onRowCopy: (originalRow: DataRecord, newRow: DataRecord) => void;
+  onRowMove: (row: DataRecord, fromIndex: number, toIndex: number) => void;
+}
+/**
+ * 表格统一状态管理器
+ */
+declare function useTableManager(params: TableManagerParams): {
+  editStates: {
+    rowEdit: {
+      editingRowKey: vue.Ref<DataTableRowKey | null, DataTableRowKey | null>;
+      editingData: vue.Ref<Record<string, DataRecord>, Record<string, DataRecord>>;
+      isSaving: vue.Ref<boolean, boolean>;
+      isEditingRow: (rowKey: DataTableRowKey) => boolean;
+      startEditRow: (rowKey: DataTableRowKey) => boolean;
+      cancelEditRow: () => Promise<void>;
+      saveEditRow: () => Promise<{
+        updatedData: DataRecord;
+        rowIndex: number;
+      } | undefined>;
+      validateRow: () => Promise<boolean>;
+      validationErrors: vue.Ref<{
+        field: string;
+        message: string;
+      }[], RowValidationError[] | {
+        field: string;
+        message: string;
+      }[]>;
+      getEditingRowData: (rowKey: DataTableRowKey) => DataRecord | undefined;
+      updateEditingRowData: (rowKey: DataTableRowKey, field: string, value: unknown) => void;
+      findRowData: (rowKey: DataTableRowKey) => DataRecord | null | undefined;
+      invalidate: () => void;
+    };
+    cellEdit: {
+      editingCell: vue.Ref<{
+        rowKey: DataTableRowKey | null;
+        columnKey: string | null;
+      }, {
+        rowKey: DataTableRowKey | null;
+        columnKey: string | null;
+      } | {
+        rowKey: DataTableRowKey | null;
+        columnKey: string | null;
+      }>;
+      editingData: vue.Ref<Record<string, unknown>, Record<string, unknown>>;
+      isSaving: vue.Ref<boolean, boolean>;
+      isEditingCell: (rowKey: DataTableRowKey, columnKey: string) => boolean;
+      startEditCell: (rowKey: DataTableRowKey, columnKey: string) => boolean;
+      saveEditCell: () => Promise<{
+        updatedData: {
+          [x: string]: unknown;
+        };
+        rowIndex: number;
+        columnKey: string;
+      } | undefined>;
+      cancelEditCell: () => void;
+      validateCell: () => Promise<boolean>;
+      cellValidationError: vue.Ref<string | null, string | null>;
+      getEditingCellValue: (rowKey: DataTableRowKey, columnKey: string) => unknown;
+      updateEditingCellValue: (rowKey: DataTableRowKey, columnKey: string, value: unknown) => void;
+      findRowData: (rowKey: DataTableRowKey) => DataRecord | null | undefined;
+      invalidate: () => void;
+    };
+    modalEdit: {
+      isModalVisible: vue.Ref<boolean, boolean>;
+      isSaving: vue.Ref<boolean, boolean>;
+      editingData: vue.Ref<DataRecord, DataRecord>;
+      editingRowKey: vue.Ref<DataTableRowKey | null, DataTableRowKey | null>;
+      editingRowIndex: vue.ComputedRef<number>;
+      startEdit: (rowKey: DataTableRowKey, sourceData?: DataRecord | undefined) => boolean;
+      saveEdit: (formData?: DataRecord | undefined) => Promise<{
+        updatedData: any;
+        rowIndex: number;
+      } | undefined>;
+      cancelEdit: () => Promise<boolean>;
+      updateEditingData: (data: DataRecord) => boolean;
+      resetEditingState: () => boolean;
+      isEditingRow: (rowKey: DataTableRowKey) => boolean;
+      getEditingRowData: (rowKey: DataTableRowKey) => any;
+      invalidate: () => void;
+    };
+  };
+  expandState: UseTableExpandReturn<DataRecord, DataRecord>;
+  dynamicRowsState: DynamicRowsReturn<DataRecord>;
+  stateManager: {
+    edit: {
+      /** 开始编辑 */start(rowKey: DataTableRowKey, columnKey?: string): void; /** 取消编辑 */
+      cancel(): void; /** 保存编辑 */
+      save(): Promise<void>; /** 是否正在编辑 */
+      isEditing(rowKey: DataTableRowKey, columnKey?: string): boolean; /** 获取当前编辑数据 */
+      getEditingData(): DataRecord | null | undefined;
+    };
+    expand: {
+      /** 展开行 */row(rowKey: DataTableRowKey): Promise<void>; /** 折叠行 */
+      collapse(rowKey: DataTableRowKey): void; /** 展开折叠切换 */
+      toggle(rowKey: DataTableRowKey): Promise<void>; /** 展开所有行 */
+      all(): Promise<void>; /** 折叠所有行 */
+      collapseAll(): void; /** 检查行是否已展开 */
+      isExpanded(rowKey: DataTableRowKey): boolean;
+    };
+    selection: {
+      /** 选择指定行 */select(rowKey: DataTableRowKey): void; /** 取消选择指定行 */
+      unselect(rowKey: DataTableRowKey): void; /** 选择所有行 */
+      all(): void; /** 清除所有行选择 */
+      clear(): void; /** 检查行是否已选择 */
+      isSelected(rowKey: DataTableRowKey): boolean; /** 获取所有已选择的行数据 */
+      getSelected(): DataRecord[];
+    };
+    childSelection: {
+      /** 选择指定父行下的子行 */select(parentKey: DataTableRowKey, childKey: DataTableRowKey): void; /** 取消选择指定父行下的子行 */
+      unselect(parentKey: DataTableRowKey, childKey: DataTableRowKey): void; /** 选择指定父行下的所有子行 */
+      selectAll(parentKey: DataTableRowKey): void; /** 清除指定父行下的所有子行选择 */
+      clear(parentKey: DataTableRowKey): void; /** 获取指定父行下所有已选择的子行数据 */
+      getSelected(parentKey: DataTableRowKey): DataRecord[];
+    };
+    dynamicRows: {
+      /** 添加行 */add(): void; /** 插入行 */
+      insert(): void; /** 删除行 */
+      delete(): void; /** 复制行 */
+      copy(): void; /** 上移动态行 */
+      moveUp(): void; /** 下移动态行 */
+      moveDown(): void; /** 清空动态行数据 */
+      clearSelection(): void; /** 获取当前选中的动态行数据 */
+      getSelected(): DataRecord | null; /** 打印表格 */
+      print(elementRef?: HTMLElement): Promise<void>; /** 导出表格数据 */
+      download(elementRef?: HTMLElement, filename?: string): Promise<void>;
+    }; /** 清除所有选择 */
+    clearAllSelections(): void;
+  };
+  expandedKeys: vue.ComputedRef<DataTableRowKey[]>;
+  checkedKeys: vue.ComputedRef<DataTableRowKey[]>;
+  eventHandlers: EventHandlers;
+};
+//#endregion
+//#region src/components/C_Table/composables/useTableExpand.d.ts
+/**
+ *
+ */
+declare function useTableExpand<T extends object = DataRecord, C = DataRecord>(options: UseTableExpandOptions<T, C>): UseTableExpandReturn<T, C>;
+//#endregion
+//#region src/components/C_Table/composables/useTableActions.d.ts
+/**
+ * 表格操作Hook
+ */
+declare function useTableActions<T extends object = DataRecord>(options: UseTableActionsOptions<T>): UseTableActionsReturn<T>;
+//#endregion
+//#region src/components/C_Table/composables/usePagination.d.ts
+interface UsePaginationOptions<T extends object = DataRecord> {
+  /** 数据源 - 支持函数、Ref 或 ComputedRef */
+  data: (() => T[]) | Ref<T[]> | ComputedRef<T[]>;
+  /** 分页配置 */
+  config: Ref<PaginationConfig | null> | ComputedRef<PaginationConfig | null>;
+  /** 事件触发器 */
+  emit?: (event: 'pagination-change', page: number, pageSize: number) => void;
+}
+interface UsePaginationReturn<T extends object = DataRecord> {
+  currentPage: Ref<number>;
+  currentPageSize: Ref<number>;
+  paginatedData: ComputedRef<T[]>;
+  paginationConfig: ComputedRef<PaginationProps | null>;
+  handlePageChange: (page: number) => void;
+  handlePageSizeChange: (pageSize: number) => void;
+  resetToFirstPage: () => void;
+  getTotalPages: () => number;
+}
+/** Local and remote pagination with stable controlled-state synchronization. */
+declare function usePagination<T extends object = DataRecord>(options: UsePaginationOptions<T>): UsePaginationReturn<T>;
+//#endregion
+//#region src/components/C_Table/composables/useCellEdit.d.ts
+/**
+ * 单元格编辑配置选项
+ */
+interface CellEditOptions {
+  data: () => DataRecord[];
+  rowKey: (row: DataRecord) => DataTableRowKey;
+  onSave?: (rowData: DataRecord, rowIndex: number, columnKey: string, originalKey?: DataTableRowKey) => unknown;
+  /** 列配置（用于提取校验规则） */
+  columns?: () => TableColumn[];
+}
+/**
+ * 可编辑单元格组合函数，提供表格单元格的编辑功能
+ */
+declare function useCellEdit(options: CellEditOptions): {
+  editingCell: vue.Ref<{
+    rowKey: DataTableRowKey | null;
+    columnKey: string | null;
+  }, {
+    rowKey: DataTableRowKey | null;
+    columnKey: string | null;
+  } | {
+    rowKey: DataTableRowKey | null;
+    columnKey: string | null;
+  }>;
+  editingData: vue.Ref<Record<string, unknown>, Record<string, unknown>>;
+  isSaving: vue.Ref<boolean, boolean>;
+  isEditingCell: (rowKey: DataTableRowKey, columnKey: string) => boolean;
+  startEditCell: (rowKey: DataTableRowKey, columnKey: string) => boolean;
+  saveEditCell: () => Promise<{
+    updatedData: {
+      [x: string]: unknown;
+    };
+    rowIndex: number;
+    columnKey: string;
+  } | undefined>;
+  cancelEditCell: () => void;
+  validateCell: () => Promise<boolean>;
+  cellValidationError: vue.Ref<string | null, string | null>;
+  getEditingCellValue: (rowKey: DataTableRowKey, columnKey: string) => unknown;
+  updateEditingCellValue: (rowKey: DataTableRowKey, columnKey: string, value: unknown) => void;
+  findRowData: (rowKey: DataTableRowKey) => DataRecord | null | undefined;
+  invalidate: () => void;
+};
+//#endregion
+//#region node_modules/@vue/shared/dist/shared.d.ts
+type IfAny<T, Y, N> = 0 extends 1 & T ? Y : N;
+//#endregion
+//#region src/components/C_Table/composables/useModalEdit.d.ts
+interface ModalEditOptions<T extends object = DataRecord> {
+  data: () => T[];
+  rowKey: (row: T) => DataTableRowKey;
+  onSave?: (editingData: T, rowIndex: number, originalKey?: DataTableRowKey) => unknown;
+  onCancel?: (originalData: T, rowIndex: number) => unknown;
+}
+/** Modal edit state with lossless snapshots and retry-safe async saves. */
+declare function useModalEdit<T extends object = DataRecord>(options: ModalEditOptions<T>): {
+  isModalVisible: vue.Ref<boolean, boolean>;
+  isSaving: vue.Ref<boolean, boolean>;
+  editingData: [T] extends [vue.Ref<any, any>] ? IfAny<T, vue.Ref<T, T>, T> : vue.Ref<vue.UnwrapRef<T>, T | vue.UnwrapRef<T>>;
+  editingRowKey: vue.Ref<DataTableRowKey | null, DataTableRowKey | null>;
+  editingRowIndex: vue.ComputedRef<number>;
+  startEdit: (rowKey: DataTableRowKey, sourceData?: T) => boolean;
+  saveEdit: (formData?: T) => Promise<{
+    updatedData: any;
+    rowIndex: number;
+  } | undefined>;
+  cancelEdit: () => Promise<boolean>;
+  updateEditingData: (data: T) => boolean;
+  resetEditingState: () => boolean;
+  isEditingRow: (rowKey: DataTableRowKey) => boolean;
+  getEditingRowData: (rowKey: DataTableRowKey) => any;
+  invalidate: () => void;
+};
+//#endregion
+//#region src/components/C_Table/composables/useTableQuery.d.ts
+interface TableQueryContext<Q> {
+  page: number;
+  pageSize: number;
+  query: Readonly<Q>;
+  signal: AbortSignal;
+}
+interface TableQueryResult<T extends object> {
+  data: readonly T[];
+  total: number;
+}
+interface UseTableQueryOptions<T extends object, Q extends object> {
+  request: (context: TableQueryContext<Q>) => Promise<TableQueryResult<T>>;
+  initialQuery: Q;
+  columns?: MaybeRefOrGetter<TableColumn<T>[] | undefined>;
+  config?: MaybeRefOrGetter<TableConfig<T> | undefined>;
+  rowKey?: TableRowKey<T>;
+  initialPage?: number;
+  pageSize?: number;
+  immediate?: boolean;
+  onError?: (error: unknown) => void;
+  onSuccess?: (result: TableQueryResult<T>) => void;
+}
+/**
+ * Remote table controller with latest-request-wins cancellation and ready-to-bind props.
+ */
+declare function useTableQuery<T extends object, Q extends object = Record<string, unknown>>(options: UseTableQueryOptions<T, Q>): {
+  data: vue.ShallowRef<T[], T[]>;
+  loading: vue.Ref<boolean, boolean>;
+  error: vue.ShallowRef<unknown, unknown>;
+  total: vue.Ref<number, number>;
+  page: vue.Ref<number, number>;
+  pageSize: vue.Ref<number, number>;
+  query: vue.Ref<any, any> extends Q ? Q extends Q & vue.Ref<any, any> ? IfAny<Q, vue.ShallowRef<Q, Q>, Q> : vue.ShallowRef<Q, Q> : vue.ShallowRef<Q, Q>;
+  tableProps: vue.ComputedRef<{
+    data: T[];
+    loading: boolean;
+    columns: TableColumn<T>[] | undefined;
+    rowKey: TableRowKey<T>;
+    config: {
+      pagination: {
+        enabled: true;
+        remote: true;
+        page: number;
+        pageSize: number;
+        total: number;
+        showSizePicker?: boolean;
+        showQuickJumper?: boolean;
+        pageSizes?: number[];
+        simple?: boolean;
+        size?: "small" | "medium" | "large";
+      };
+      density?: ComponentDensity;
+      feedback?: ComponentFeedback;
+      locale?: ComponentLocale;
+      validateRowKeys?: boolean;
+      edit?: boolean | EditMode | EditConfig<T> | undefined;
+      actions?: SimpleTableActions<T> | undefined;
+      expand?: boolean | ExpandConfig<T, unknown> | undefined;
+      selection?: boolean | SelectionConfig<T, unknown> | undefined;
+      dynamicRows?: DynamicRowsOptions<T> | (string extends keyof T ? boolean : false) | undefined;
+      toolbar?: ToolbarConfig;
+      display?: DisplayConfig;
+      virtualScroll?: VirtualScrollConfig | boolean;
+      summary?: SummaryConfig<T> | undefined;
+      columnDrag?: ColumnDragConfig | boolean;
+      tree?: TreeConfig | boolean;
+      rowDrag?: RowDragConfig | boolean;
+      crossPageSelection?: CrossPageSelectionConfig | boolean;
+      export?: ExportConfig;
+      persistKey?: string;
+      formatterConfig?: FormatterConfig;
+      error?: ErrorConfig;
+      batchActions?: BatchActionsConfig<T> | undefined;
+    };
+  }>;
+  execute: () => Promise<boolean>;
+  reload: () => Promise<boolean>;
+  setQuery: (next: Partial<Q> | ((current: Readonly<Q>) => Q), reload?: boolean) => Promise<boolean>;
+  resetQuery: (reload?: boolean) => Promise<boolean>;
+  handlePaginationChange: (nextPage: number, nextPageSize: number) => Promise<boolean>;
+  bindings: vue.ComputedRef<{
+    onPaginationChange: (nextPage: number, nextPageSize: number) => Promise<boolean>;
+    data: T[];
+    loading: boolean;
+    columns: TableColumn<T>[] | undefined;
+    rowKey: TableRowKey<T>;
+    config: {
+      pagination: {
+        enabled: true;
+        remote: true;
+        page: number;
+        pageSize: number;
+        total: number;
+        showSizePicker?: boolean;
+        showQuickJumper?: boolean;
+        pageSizes?: number[];
+        simple?: boolean;
+        size?: "small" | "medium" | "large";
+      };
+      density?: ComponentDensity;
+      feedback?: ComponentFeedback;
+      locale?: ComponentLocale;
+      validateRowKeys?: boolean;
+      edit?: boolean | EditMode | EditConfig<T> | undefined;
+      actions?: SimpleTableActions<T> | undefined;
+      expand?: boolean | ExpandConfig<T, unknown> | undefined;
+      selection?: boolean | SelectionConfig<T, unknown> | undefined;
+      dynamicRows?: DynamicRowsOptions<T> | (string extends keyof T ? boolean : false) | undefined;
+      toolbar?: ToolbarConfig;
+      display?: DisplayConfig;
+      virtualScroll?: VirtualScrollConfig | boolean;
+      summary?: SummaryConfig<T> | undefined;
+      columnDrag?: ColumnDragConfig | boolean;
+      tree?: TreeConfig | boolean;
+      rowDrag?: RowDragConfig | boolean;
+      crossPageSelection?: CrossPageSelectionConfig | boolean;
+      export?: ExportConfig;
+      persistKey?: string;
+      formatterConfig?: FormatterConfig;
+      error?: ErrorConfig;
+      batchActions?: BatchActionsConfig<T> | undefined;
+    };
+  }>;
+  cancel: () => void;
+};
+//#endregion
+//#region src/components/C_Tree/types.d.ts
+type TreeKey = string | number;
+type TreeMode = 'menu' | 'file' | 'org' | 'custom';
+type StatusType = 'success' | 'warning' | 'error' | 'info';
+type ButtonType = 'primary' | 'info' | 'warning' | 'error' | 'default';
+/** Custom fields are allowed; keyField/labelField select the actual identity and label. */
+interface TreeOption$1 extends TreeOption {
+  id?: TreeKey;
+  children?: TreeOption$1[];
+}
+interface TreeNodeData extends TreeOption$1 {
+  name?: string;
+  type?: string;
+  children?: TreeNodeData[];
+}
+interface DropInfo<T extends object = TreeOption$1> {
+  node: T;
+  dragNode: T;
+  dropPosition: 'before' | 'inside' | 'after';
+  event: DragEvent;
+}
+interface StatusConfig {
+  field: string;
+  values: Record<string | number, {
+    text: string;
+    type: StatusType;
+  }>;
+}
+interface ActionConfig<T extends object = TreeNodeData> {
+  key: string;
+  text: string;
+  icon: string;
+  type?: ButtonType;
+  show?: (node: T) => boolean;
+  confirm?: string;
+}
+interface IconConfig {
+  default?: string;
+  typeMap?: Record<string, string>;
+  colorMap?: Record<string, string>;
+}
+type MaybeArray<T> = T | T[];
+type TreeUpdateHandler<T extends object, A extends TreeUpdateMeta['action']> = (keys: TreeKey[], options: Array<T | null>, meta: TreeUpdateMeta<T, A>) => void;
+type TreeDragHandler<T extends object> = (info: {
+  node: T;
+  event: DragEvent;
+}) => void;
+/** 原生功能保持透传，涉及节点的回调由数据源推导业务类型。 */
+type TreeNativeProps<T extends object = TreeNodeData> = Omit<TreeProps, 'data' | 'filter' | 'onLoad' | 'getChildren' | 'renderLabel' | 'renderPrefix' | 'renderSuffix' | 'renderSwitcherIcon' | 'nodeProps' | 'allowDrop' | 'checkOnClick' | 'overrideDefaultNodeClickBehavior' | 'onDrop' | 'onDragenter' | 'onDragleave' | 'onDragend' | 'onDragstart' | 'onDragover' | 'onUpdateExpandedKeys' | 'onUpdate:expandedKeys' | 'onUpdateSelectedKeys' | 'onUpdate:selectedKeys' | 'onUpdateCheckedKeys' | 'onUpdate:checkedKeys' | 'onUpdateIndeterminateKeys' | 'onUpdate:indeterminateKeys'> & {
+  filter?: (pattern: string, node: T) => boolean;
+  onLoad?: (node: T) => Promise<unknown>;
+  getChildren?: (node: T) => unknown;
+  renderLabel?: (context: TreeRenderContext<T>) => VNodeChild;
+  renderPrefix?: (context: TreeRenderContext<T>) => VNodeChild;
+  renderSuffix?: (context: TreeRenderContext<T>) => VNodeChild;
+  renderSwitcherIcon?: (context: {
+    expanded: boolean;
+    selected: boolean;
+    option: T;
+  }) => VNodeChild;
+  nodeProps?: (context: {
+    option: T;
+  }) => ReturnType<NonNullable<TreeProps['nodeProps']>>;
+  allowDrop?: (info: {
+    dropPosition: DropInfo['dropPosition'];
+    node: T;
+    phase: 'drag' | 'drop';
+  }) => boolean;
+  checkOnClick?: boolean | ((node: T) => boolean);
+  overrideDefaultNodeClickBehavior?: (info: {
+    option: T;
+  }) => ReturnType<NonNullable<TreeProps['overrideDefaultNodeClickBehavior']>>;
+  onDrop?: MaybeArray<(info: DropInfo<T>) => void>;
+  onDragenter?: MaybeArray<TreeDragHandler<T>>;
+  onDragleave?: MaybeArray<TreeDragHandler<T>>;
+  onDragend?: MaybeArray<TreeDragHandler<T>>;
+  onDragstart?: MaybeArray<TreeDragHandler<T>>;
+  onDragover?: MaybeArray<TreeDragHandler<T>>;
+  onUpdateExpandedKeys?: MaybeArray<TreeUpdateHandler<T, 'expand' | 'collapse' | 'filter'>>;
+  'onUpdate:expandedKeys'?: MaybeArray<TreeUpdateHandler<T, 'expand' | 'collapse' | 'filter'>>;
+  onUpdateSelectedKeys?: MaybeArray<TreeUpdateHandler<T, 'select' | 'unselect'>>;
+  'onUpdate:selectedKeys'?: MaybeArray<TreeUpdateHandler<T, 'select' | 'unselect'>>;
+  onUpdateCheckedKeys?: MaybeArray<TreeUpdateHandler<T, 'check' | 'uncheck'>>;
+  'onUpdate:checkedKeys'?: MaybeArray<TreeUpdateHandler<T, 'check' | 'uncheck'>>;
+  onUpdateIndeterminateKeys?: MaybeArray<(keys: TreeKey[], options: Array<T | null>) => void>;
+  'onUpdate:indeterminateKeys'?: MaybeArray<(keys: TreeKey[], options: Array<T | null>) => void>;
+};
+interface TreeRenderContext<T extends object = TreeOption$1> {
+  option: T;
+  checked: boolean;
+  selected: boolean;
+}
+interface TreeUpdateMeta<T extends object = TreeOption$1, A extends 'select' | 'unselect' | 'check' | 'uncheck' | 'expand' | 'collapse' | 'filter' = 'select' | 'unselect' | 'check' | 'uncheck' | 'expand' | 'collapse' | 'filter'> {
+  node: T | null;
+  action: A;
+}
+interface TreeProps$1<T extends object = TreeNodeData> {
+  /** Business interfaces need no string index signature; fields are selected by config. */
+  data: readonly T[];
+  mode?: TreeMode;
+  /** Native tree capabilities; explicit wrapper props have priority. */
+  treeProps?: TreeNativeProps<T>;
+  density?: ComponentDensity;
+  keyField?: string;
+  labelField?: string;
+  childrenField?: string;
+  searchPattern?: string;
+  searchable?: boolean;
+  searchPlaceholder?: string;
+  draggable?: boolean;
+  showLine?: boolean;
+  showToolbar?: boolean;
+  addable?: boolean;
+  addText?: string;
+  refreshable?: boolean;
+  iconField?: string;
+  iconConfig?: IconConfig;
+  statusConfigs?: StatusConfig[];
+  actions?: ActionConfig<T>[];
+  defaultExpandAll?: boolean;
+  defaultExpandedKeys?: TreeKey[];
+  defaultSelectedKeys?: TreeKey[];
+  defaultCheckedKeys?: TreeKey[];
+  expandedKeys?: TreeKey[];
+  selectedKeys?: TreeKey[];
+  checkedKeys?: TreeKey[];
+}
+interface TreeExpose<T extends object = TreeNodeData> {
+  expandAll: () => void;
+  collapseAll: () => void;
+  selectNode: (key: TreeKey) => void;
+  clearSelection: () => void;
+  setCheckedKeys: (keys: TreeKey[]) => void;
+  clearChecked: () => void;
+  getSelectedNode: () => T | null;
+  getCheckedData: () => {
+    keys: TreeKey[];
+    options: Array<T | null>;
+  };
+  getIndeterminateData: () => {
+    keys: TreeKey[];
+    options: Array<T | null>;
+  };
+  scrollTo: TreeInst['scrollTo'];
+  /** Vue 公开实例会解包顶层 Ref；这些属性直接读取数组。 */
+  expandedKeys: TreeKey[];
+  selectedKeys: TreeKey[];
+  checkedKeys: TreeKey[];
+}
+interface TreeEmits<T extends object = TreeNodeData> {
+  'update:searchPattern': [pattern: string];
+  'update:expandedKeys': [keys: TreeKey[], options: Array<T | null>, meta: TreeUpdateMeta<T>];
+  'update:selectedKeys': [keys: TreeKey[], options: Array<T | null>, meta: TreeUpdateMeta<T>];
+  'update:checkedKeys': [keys: TreeKey[], options: Array<T | null>, meta: TreeUpdateMeta<T>];
+  'node-select': [node: T | null, selectedKeys: TreeKey[]];
+  'node-action': [action: string, node: T];
+  'node-drop': [info: DropInfo<T>];
+  'load-error': [error: unknown, node: T];
+  add: [parentNode?: T];
+  refresh: [];
+}
+interface TreeSlots<T extends object = TreeOption$1> {
+  'toolbar-actions'?: () => VNodeChild;
+  label?: (context: TreeRenderContext<T>) => VNodeChild;
+  prefix?: (context: TreeRenderContext<T>) => VNodeChild;
+  suffix?: (context: TreeRenderContext<T>) => VNodeChild;
+  empty?: () => VNodeChild;
+}
+//#endregion
+//#region src/components/C_Tree/index.vue.d.ts
+declare const __VLS_export$1: <T extends object = TreeNodeData>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal$1<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+  props: vue.PublicProps & __VLS_PrettifyLocal$1<TreeProps$1<T> & {
+    onAdd?: ((parentNode?: T | undefined) => any) | undefined;
+    onRefresh?: (() => any) | undefined;
+    "onLoad-error"?: ((error: unknown, node: T) => any) | undefined;
+    "onUpdate:searchPattern"?: ((pattern: string) => any) | undefined;
+    "onUpdate:expandedKeys"?: ((keys: TreeKey[], options: (T | null)[], meta: TreeUpdateMeta<T, "filter" | "select" | "unselect" | "expand" | "collapse" | "check" | "uncheck">) => any) | undefined;
+    "onUpdate:selectedKeys"?: ((keys: TreeKey[], options: (T | null)[], meta: TreeUpdateMeta<T, "filter" | "select" | "unselect" | "expand" | "collapse" | "check" | "uncheck">) => any) | undefined;
+    "onUpdate:checkedKeys"?: ((keys: TreeKey[], options: (T | null)[], meta: TreeUpdateMeta<T, "filter" | "select" | "unselect" | "expand" | "collapse" | "check" | "uncheck">) => any) | undefined;
+    "onNode-select"?: ((node: T | null, selectedKeys: TreeKey[]) => any) | undefined;
+    "onNode-action"?: ((action: string, node: T) => any) | undefined;
+    "onNode-drop"?: ((info: DropInfo<T>) => any) | undefined;
+  }> & (typeof globalThis extends {
+    __VLS_PROPS_FALLBACK: infer P;
+  } ? P : {});
+  expose: (exposed: vue.ShallowUnwrapRef<Omit<TreeExpose<T>, "selectedKeys" | "expandedKeys" | "checkedKeys"> & {
+    expandedKeys: vue.Ref<TreeKey[]>;
+    selectedKeys: vue.Ref<TreeKey[]>;
+    checkedKeys: vue.Ref<TreeKey[]>;
+  }>) => void;
+  attrs: any;
+  slots: TreeSlots<T>;
+  emit: ((evt: "add", parentNode?: T | undefined) => void) & ((evt: "refresh") => void) & ((evt: "load-error", error: unknown, node: T) => void) & ((evt: "update:searchPattern", pattern: string) => void) & ((evt: "update:expandedKeys", keys: TreeKey[], options: (T | null)[], meta: TreeUpdateMeta<T, "filter" | "select" | "unselect" | "expand" | "collapse" | "check" | "uncheck">) => void) & ((evt: "update:selectedKeys", keys: TreeKey[], options: (T | null)[], meta: TreeUpdateMeta<T, "filter" | "select" | "unselect" | "expand" | "collapse" | "check" | "uncheck">) => void) & ((evt: "update:checkedKeys", keys: TreeKey[], options: (T | null)[], meta: TreeUpdateMeta<T, "filter" | "select" | "unselect" | "expand" | "collapse" | "check" | "uncheck">) => void) & ((evt: "node-select", node: T | null, selectedKeys: TreeKey[]) => void) & ((evt: "node-action", action: string, node: T) => void) & ((evt: "node-drop", info: DropInfo<T>) => void);
+}>) => vue.VNode & {
+  __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+declare const _default$1: typeof __VLS_export$1;
+type __VLS_PrettifyLocal$1<T> = (T extends any ? { [K in keyof T]: T[K] } : { [K in keyof T as K]: T[K] }) & {};
+//#endregion
+//#region src/components/C_Tree/data.d.ts
+declare const presetConfigs: Record<TreeMode, Partial<Omit<TreeProps$1, 'data' | 'treeProps' | 'actions'>> & {
+  actions?: Omit<ActionConfig, 'show'>[];
+}>;
+//#endregion
+//#region src/components/C_Tree/composables/useTreeOperations.d.ts
+type EmitFn$1<T extends object> = <E extends keyof TreeEmits<T>>(event: E, ...args: TreeEmits<T>[E]) => void;
+/** State coordination only; checking, filtering, keyboard and loading stay native. */
+declare function useTreeOperations<T extends object = TreeNodeData>(props: TreeProps$1<T>, emit: EmitFn$1<T>, slots?: TreeSlots<T>): {
+  internalSearchPattern: Ref<string, string>;
+  expandedKeys: vue.WritableComputedRef<TreeKey[], TreeKey[]>;
+  selectedKeys: vue.WritableComputedRef<TreeKey[], TreeKey[]>;
+  checkedKeys: vue.WritableComputedRef<TreeKey[], TreeKey[]>;
+  isAllExpanded: vue.ComputedRef<boolean>;
+  treeData: vue.ComputedRef<readonly T[]>;
+  currentSearchPattern: vue.WritableComputedRef<string, string>;
+  renderPrefix: (info: TreeRenderContext<T>) => any;
+  renderLabel: (info: TreeRenderContext<T>) => string | number | boolean | void | vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+  }> | vue.VNodeArrayChildren | null;
+  renderSuffix: (info: TreeRenderContext<T>) => any;
+  treeBindings: vue.ComputedRef<TreeProps>;
+  treeRef: vue.ShallowRef<TreeInst | undefined, TreeInst | undefined>;
+  density: vue.ComputedRef<ResolvedComponentDensity>;
+  toggleExpandAll: () => void;
+  handleExpandedKeysChange: (keys: TreeKey[], options?: (T | null)[], meta?: TreeUpdateMeta<T>) => void;
+  handleSelectedKeysChange: (keys: TreeKey[], options?: (T | null)[], meta?: TreeUpdateMeta<T>) => void;
+  handleCheckedKeysChange: (keys: TreeKey[], options?: (T | null)[], meta?: TreeUpdateMeta<T>) => void;
+  handleDrop: (info: DropInfo<T>) => void;
+  handleAdd: () => void;
+  handleRefresh: () => void;
+  expose: Omit<TreeExpose<T>, "selectedKeys" | "expandedKeys" | "checkedKeys"> & {
+    expandedKeys: Ref<TreeKey[]>;
+    selectedKeys: Ref<TreeKey[]>;
+    checkedKeys: Ref<TreeKey[]>;
+  };
+};
+//#endregion
+//#region src/components/C_FormModal/types.d.ts
+type FormModalMode = 'create' | 'edit';
+/**
+ * Structural editor contract. It intentionally does not depend on request-core,
+ * so any headless CRUD implementation can drive the modal.
+ */
+interface FormModalEditor<T extends object = FormRecord> {
+  visible: Ref<boolean>;
+  mode: Ref<FormModalMode>;
+  model: Ref<T | null>;
+  title: Ref<string>;
+  loading: Ref<boolean> | ComputedRef<boolean>;
+  setModel(model: T): void;
+  close(): void;
+  submit(model?: T): Promise<boolean>;
+}
+interface FormModalProps<T extends object = FormRecord> {
+  editor: FormModalEditor<T>;
+  options: FormOption<T>[];
+  config?: FormConfig<T>;
+  width?: number | string;
+  createText?: string;
+  saveText?: string;
+  cancelText?: string;
+  closable?: boolean;
+  maskClosable?: boolean;
+  closeOnEsc?: boolean;
+}
+interface FormModalEmits<T extends object = FormRecord> {
+  submit: [payload: SubmitEventPayload<T>, saved: boolean];
+  close: [];
+}
+//#endregion
+//#region src/components/C_FormModal/index.vue.d.ts
+declare const __VLS_export: <T extends object = FormRecord>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+  props: vue.PublicProps & __VLS_PrettifyLocal<FormModalProps<T> & {
+    onSubmit?: ((payload: SubmitEventPayload<T>, saved: boolean) => any) | undefined;
+    onClose?: (() => any) | undefined;
+  }> & (typeof globalThis extends {
+    __VLS_PROPS_FALLBACK: infer P;
+  } ? P : {});
+  expose: (exposed: {}) => void;
+  attrs: any;
+  slots: {
+    [x: string]: ((props: any) => any) | undefined;
+  };
+  emit: ((evt: "submit", payload: SubmitEventPayload<T>, saved: boolean) => void) & ((evt: "close") => void);
+}>) => vue.VNode & {
+  __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+declare const _default: typeof __VLS_export;
+type __VLS_PrettifyLocal<T> = (T extends any ? { [K in keyof T]: T[K] } : { [K in keyof T as K]: T[K] }) & {};
+//#endregion
+//#region src/utils/storage.d.ts
+/** SSR-safe localStorage helpers. Storage failures never break component state. */
+/** Store a value. Returns false when storage is unavailable or full. */
+declare function setItem<T>(key: string, value: T): boolean;
+/** Read and safely deserialize a value. */
+declare function getItem<T = unknown>(key: string): T | null;
+/** Remove one value. Returns whether the storage operation was available. */
+declare function removeItem(key: string): boolean;
+/**
+ * Clear localStorage for backward compatibility.
+ * Prefer `removeItem` in components so unrelated application data is preserved.
+ */
+declare function removeAllItem(): boolean;
+//#endregion
 //#region src/components/C_Form/composables/useFormState.d.ts
 type FormEmit = {
   (event: 'update:modelValue', model: FormModel): void;
@@ -160,7 +1097,8 @@ declare function useFormState(options: ComputedRef<FormOption[]>, config: Comput
   visibleOptions: ComputedRef<FormOption[]>;
   initialize: () => void;
   handleFieldChange: (field: string) => void;
-  setFormItemRef: (field: string, instance: FormItemInst | null) => void;
+  setFormItemRef: (field: string, instance: FormItemInst | null) => void; /** 复用 Naive 表单项的实例引用；不把 DOM 查找扩散到 document。 */
+  getFormItemElement: (field: string) => HTMLElement | null;
   validate: () => Promise<void>;
   validateField: (field: string | string[]) => Promise<void>;
   validateStep: (step: number | string) => Promise<boolean>;
@@ -185,6 +1123,8 @@ declare function useFormState(options: ComputedRef<FormOption[]>, config: Comput
   asyncOptionsCache: Ref<Record<string, OptionItem[]>, Record<string, OptionItem[]>>;
   asyncLoadingMap: Ref<Record<string, boolean>, Record<string, boolean>>;
   asyncErrorMap: Ref<Record<string, unknown>, Record<string, unknown>>;
+  getDictionaryOptions: (key: string) => readonly DictionaryOption[];
+  isDictionaryLoading: (key: string) => boolean;
   reloadOptions: (field?: string) => Promise<void>;
 };
 //#endregion
@@ -244,4 +1184,4 @@ type DynamicFormStateType = DynamicFormController;
  */
 declare const DYNAMIC_FORM_STATE_KEY: unique symbol;
 //#endregion
-export { unregisterRenderer as C, registerRenderer as S, FormRendererContext as _, UseFormDirtyReturn as a, UseFormRendererOptions as b, UseCFormOptions as c, defineFormOptions as d, useCForm as f, FormRenderer as g, FORM_RENDERER_REGISTRY_KEY as h, useDynamicFormState as i, UseCFormReturn as l, ComponentMap as m, DynamicFormStateType as n, useFormDirty as o, _default as p, FIELD_TYPE_OPTIONS as r, useFormState as s, DYNAMIC_FORM_STATE_KEY as t, defineFormConfig as u, FormRendererRegistry as v, useFormRenderer as w, createFormRendererRegistry as x, RendererProps as y };
+export { HighlightAPI as $, TreeNativeProps as A, useTableQuery as B, IconConfig as C, TreeExpose as D, TreeEmits as E, TreeSlots as F, useTableExpand as G, useCellEdit as H, TreeUpdateMeta as I, useTableColumns as J, useTableManager as K, TableQueryContext as L, TreeOption$1 as M, TreeProps$1 as N, TreeKey as O, TreeRenderContext as P, _default$2 as Q, TableQueryResult as R, DropInfo as S, StatusType as T, usePagination as U, useModalEdit as V, useTableActions as W, defineTableConfig as X, defineTableColumns as Y, validateTableRowKeys as Z, useTreeOperations as _, createFormRendererRegistry as _t, UseFormDirtyReturn as a, UseCFormReturn as at, ActionConfig as b, useFormRenderer as bt, getItem as c, useCForm as ct, setItem as d, FORM_RENDERER_REGISTRY_KEY as dt, HighlightPluginOptions as et, _default as f, FormRenderer as ft, FormModalProps as g, UseFormRendererOptions as gt, FormModalMode as h, RendererProps as ht, useDynamicFormState as i, UseCFormOptions as it, TreeNodeData as j, TreeMode as k, removeAllItem as l, _default$3 as lt, FormModalEmits as m, FormRendererRegistry as mt, DynamicFormStateType as n, setupHighlight as nt, useFormDirty as o, defineFormConfig as ot, FormModalEditor as p, FormRendererContext as pt, useRowEdit as q, FIELD_TYPE_OPTIONS as r, useHighlight as rt, useFormState as s, defineFormOptions as st, DYNAMIC_FORM_STATE_KEY as t, createHighlight as tt, removeItem as u, ComponentMap as ut, presetConfigs as v, registerRenderer as vt, StatusConfig as w, ButtonType as x, _default$1 as y, unregisterRenderer as yt, UseTableQueryOptions as z };