@revisium/schema-toolkit 0.14.3 → 0.16.0

package/dist/model/index.d.cts

@@ -1,8 +1,11 @@
-import { h as JsonSchemaStore } from '../json-string.store-CcZ197KO.cjs';
-export { A as AddedPropertyEvent, C as ChangeNameEvent, f as JsonArrayStore, m as JsonArrayValueStore, b as JsonBooleanStore, k as JsonBooleanValueStore, a as JsonNumberStore, j as JsonNumberValueStore, c as JsonObjectStore, l as JsonObjectValueStore, g as JsonSchemaStorePrimitives, J as JsonStringStore, i as JsonStringValueStore, p as JsonValueStore, o as JsonValueStoreParent, n as JsonValueStorePrimitives, d as MigrateItemsEvent, M as MigratePropertyEvent, R as RemovedPropertyEvent, e as ReplaceItemsEvent } from '../json-string.store-CcZ197KO.cjs';
+import { h as JsonSchemaStore } from '../json-string.store-DKlkc1u_.cjs';
+export { A as AddedPropertyEvent, C as ChangeNameEvent, f as JsonArrayStore, m as JsonArrayValueStore, b as JsonBooleanStore, k as JsonBooleanValueStore, a as JsonNumberStore, j as JsonNumberValueStore, c as JsonObjectStore, l as JsonObjectValueStore, g as JsonSchemaStorePrimitives, J as JsonStringStore, i as JsonStringValueStore, p as JsonValueStore, o as JsonValueStoreParent, n as JsonValueStorePrimitives, d as MigrateItemsEvent, M as MigratePropertyEvent, R as RemovedPropertyEvent, e as ReplaceItemsEvent } from '../json-string.store-DKlkc1u_.cjs';
+import { b as SchemaNode, P as Path, N as NodeMetadata, S as SchemaValidationError, F as FormulaValidationError, f as SchemaPatch, J as JsonPatch, R as ReactivityAdapter, c as SchemaTree, D as Diagnostic } from '../types-DMzUCve0.cjs';
+import { f as JsonObjectSchema, i as JsonSchema } from '../schema.types-ZX5fUW1X.cjs';
+import { d as JsonValuePatch } from '../json-value-patch.types-CjBpq5VF.cjs';
 import 'node:events';
-import '../schema.types-CLHMJmkJ.cjs';
 import '../json.types-46Cq-WxU.cjs';
+import '@revisium/formula';
 
 declare const equal: (value: unknown) => unknown;
 declare const fromNumberToString: (value: number, defaultValue?: string) => string;
@@ -20,4 +23,593 @@ declare const fromArrayToObject: (_value: unknown, defaultValue: unknown) => unk
 declare const getTransformation: (from: JsonSchemaStore, to: JsonSchemaStore) => Transformation | undefined;
 type Transformation = (value: unknown, defaultValue?: unknown) => unknown;
 
-export { JsonSchemaStore, equal, fromArrayToObject, fromArrayTransformation, fromBooleanToNumber, fromBooleanToString, fromNumberToBoolean, fromNumberToString, fromObjectToArray, fromObjectToPrimitive, fromPrimitiveToObject, fromStringToBoolean, fromStringToNumber, getTransformation, toArrayTransformation };
+interface ReactivityOptions {
+    reactivity?: ReactivityAdapter;
+}
+type FieldType = 'string' | 'number' | 'boolean' | 'object' | 'array';
+interface ReplaceResult {
+    replacedNodeId: string;
+    newNodeId: string;
+}
+interface SchemaModel {
+    root(): SchemaNode;
+    nodeById(id: string): SchemaNode;
+    pathOf(id: string): Path;
+    addField(parentId: string, name: string, type: FieldType): SchemaNode;
+    removeField(nodeId: string): boolean;
+    renameField(nodeId: string, newName: string): void;
+    changeFieldType(nodeId: string, newType: FieldType): SchemaNode;
+    updateMetadata(nodeId: string, meta: Partial<NodeMetadata>): void;
+    updateFormula(nodeId: string, expression: string | undefined): void;
+    updateForeignKey(nodeId: string, foreignKey: string | undefined): void;
+    updateDefaultValue(nodeId: string, value: unknown): void;
+    wrapInArray(nodeId: string): ReplaceResult | null;
+    wrapRootInArray(): ReplaceResult | null;
+    replaceRoot(newType: FieldType): ReplaceResult | null;
+    canMoveNode(nodeId: string, targetParentId: string): boolean;
+    hasValidDropTarget(nodeId: string): boolean;
+    getFormulaDependents(nodeId: string): readonly string[];
+    hasFormulaDependents(nodeId: string): boolean;
+    getValidationErrors(): SchemaValidationError[];
+    getFormulaErrors(): FormulaValidationError[];
+    isDirty(): boolean;
+    isValid(): boolean;
+    getPatches(): SchemaPatch[];
+    getJsonPatches(): JsonPatch[];
+    markAsSaved(): void;
+    revert(): void;
+    getPlainSchema(): JsonObjectSchema;
+    generateDefaultValue(options?: {
+        arrayItemCount?: number;
+    }): unknown;
+}
+
+declare function createSchemaModel(schema: JsonObjectSchema, options?: ReactivityOptions): SchemaModel;
+
+declare class SchemaParser {
+    private pendingFormulas;
+    parse(schema: JsonObjectSchema): SchemaNode;
+    parseFormulas(tree: SchemaTree): void;
+    private parseNode;
+    private parseObject;
+    private parseArray;
+    private parseString;
+    private parseNumber;
+    private parseBoolean;
+    private extractMetadata;
+    private collectFormula;
+}
+
+declare class NodeFactory$1 {
+    createNode(name: string, type: FieldType): SchemaNode;
+    private createArrayNode;
+    createArrayNodeWithItems(name: string, items: SchemaNode): SchemaNode;
+}
+
+interface RowData {
+    rowId: string;
+    data: unknown;
+}
+interface TableModelOptions {
+    tableId: string;
+    schema: JsonObjectSchema;
+    rows?: RowData[];
+    fkResolver?: ForeignKeyResolver;
+}
+interface TableModel {
+    readonly fk: ForeignKeyResolver | undefined;
+    readonly tableId: string;
+    readonly baseTableId: string;
+    readonly isRenamed: boolean;
+    rename(newTableId: string): void;
+    readonly schema: SchemaModel;
+    readonly rows: readonly RowModel[];
+    readonly rowCount: number;
+    addRow(rowId: string, data?: unknown): RowModel;
+    removeRow(rowId: string): void;
+    getRow(rowId: string): RowModel | undefined;
+    getRowIndex(rowId: string): number;
+    getRowAt(index: number): RowModel | undefined;
+    readonly isDirty: boolean;
+    commit(): void;
+    revert(): void;
+}
+
+interface ForeignKeyLoaderResult {
+    schema: JsonObjectSchema;
+    rows: RowData[];
+}
+interface ForeignKeyRowLoaderResult {
+    schema: JsonObjectSchema;
+    row: RowData;
+}
+interface ForeignKeyLoader {
+    loadSchema(tableId: string): Promise<JsonObjectSchema>;
+    loadTable(tableId: string): Promise<ForeignKeyLoaderResult>;
+    loadRow(tableId: string, rowId: string): Promise<ForeignKeyRowLoaderResult>;
+}
+interface ForeignKeyResolverOptions {
+    reactivity?: ReactivityAdapter;
+    loader?: ForeignKeyLoader;
+    prefetch?: boolean;
+    prefetchDepth?: 1;
+}
+
+interface ForeignKeyResolver {
+    addSchema(tableId: string, schema: JsonObjectSchema): void;
+    addTable(tableId: string, schema: JsonObjectSchema, rows: RowData[]): void;
+    addRow(tableId: string, rowId: string, data: unknown): void;
+    renameTable(oldTableId: string, newTableId: string): void;
+    getSchema(tableId: string): Promise<JsonObjectSchema>;
+    getRowData(tableId: string, rowId: string): Promise<RowData>;
+    isLoading(tableId: string): boolean;
+    isLoadingRow(tableId: string, rowId: string): boolean;
+    hasSchema(tableId: string): boolean;
+    hasTable(tableId: string): boolean;
+    hasRow(tableId: string, rowId: string): boolean;
+    setPrefetch(enabled: boolean): void;
+    readonly isPrefetchEnabled: boolean;
+    dispose(): void;
+}
+
+type NodeFactoryFn = (name: string, schema: JsonSchema, value: unknown, id?: string) => ValueNode;
+declare class NodeFactoryRegistry {
+    private readonly factories;
+    register(schemaType: string, factory: NodeFactoryFn): this;
+    get(schemaType: string): NodeFactoryFn | undefined;
+    has(schemaType: string): boolean;
+}
+type RefSchemas = Record<string, JsonSchema>;
+interface NodeFactoryOptions {
+    refSchemas?: RefSchemas;
+    reactivity?: ReactivityAdapter;
+    fkResolver?: ForeignKeyResolver;
+}
+declare class NodeFactory {
+    private readonly registry;
+    private readonly refSchemas;
+    constructor(registry: NodeFactoryRegistry, options?: NodeFactoryOptions);
+    create(name: string, schema: JsonSchema, value: unknown, id?: string): ValueNode;
+    createTree(schema: JsonSchema, value: unknown): ValueNode;
+    private getSchemaType;
+    private resolveSchema;
+}
+declare function createDefaultRegistry(reactivity?: ReactivityAdapter, fkResolver?: ForeignKeyResolver): NodeFactoryRegistry;
+declare function createNodeFactory(options?: NodeFactoryOptions): NodeFactory;
+
+declare enum ValueType {
+    String = "string",
+    Number = "number",
+    Boolean = "boolean",
+    Object = "object",
+    Array = "array"
+}
+interface FormulaDefinition {
+    readonly expression: string;
+    readonly version: number;
+}
+interface FormulaWarning {
+    readonly type: 'nan' | 'infinity' | 'type-coercion' | 'division-by-zero' | 'null-reference' | 'runtime-error';
+    readonly message: string;
+    readonly expression: string;
+    readonly computedValue: unknown;
+}
+interface ValueNode {
+    readonly id: string;
+    readonly type: ValueType;
+    readonly schema: JsonSchema;
+    parent: ValueNode | null;
+    readonly name: string;
+    readonly value: unknown;
+    getPlainValue(): unknown;
+    isObject(): this is ObjectValueNode$1;
+    isArray(): this is ArrayValueNode$1;
+    isPrimitive(): this is PrimitiveValueNode;
+    readonly errors: readonly Diagnostic[];
+    readonly warnings: readonly Diagnostic[];
+    readonly isValid: boolean;
+    readonly hasWarnings: boolean;
+}
+interface DirtyTrackable {
+    readonly isDirty: boolean;
+    commit(): void;
+    revert(): void;
+}
+interface PrimitiveValueNode extends ValueNode, DirtyTrackable {
+    value: string | number | boolean;
+    readonly baseValue: string | number | boolean;
+    readonly defaultValue: unknown;
+    readonly formula: FormulaDefinition | undefined;
+    readonly formulaWarning: FormulaWarning | null;
+    readonly isReadOnly: boolean;
+    setValue(value: unknown, options?: {
+        internal?: boolean;
+    }): void;
+    setFormulaWarning(warning: FormulaWarning | null): void;
+}
+interface ObjectValueNode$1 extends ValueNode, DirtyTrackable {
+    readonly value: Record<string, ValueNode>;
+    readonly children: readonly ValueNode[];
+    child(name: string): ValueNode | undefined;
+    addChild(node: ValueNode): void;
+    removeChild(name: string): void;
+    hasChild(name: string): boolean;
+}
+interface ArrayValueNode$1 extends ValueNode, DirtyTrackable {
+    readonly value: readonly ValueNode[];
+    readonly length: number;
+    at(index: number): ValueNode | undefined;
+    push(node: ValueNode): void;
+    insertAt(index: number, node: ValueNode): void;
+    removeAt(index: number): void;
+    move(fromIndex: number, toIndex: number): void;
+    replaceAt(index: number, node: ValueNode): void;
+    clear(): void;
+    setNodeFactory(factory: NodeFactory): void;
+    pushValue(value?: unknown): void;
+    insertValueAt(index: number, value?: unknown): void;
+}
+interface ValueNodeOptions {
+    readonly id?: string;
+    readonly name: string;
+    readonly schema: JsonSchema;
+    readonly parent?: ValueNode | null;
+}
+interface PrimitiveNodeOptions extends ValueNodeOptions {
+    readonly value?: unknown;
+}
+interface ObjectNodeOptions extends ValueNodeOptions {
+    readonly children?: ValueNode[];
+}
+interface ArrayNodeOptions extends ValueNodeOptions {
+    readonly items?: ValueNode[];
+}
+declare function extractFormulaDefinition(schema: JsonSchema): FormulaDefinition | undefined;
+
+interface ValueTreeLike {
+    readonly root: ValueNode;
+    get(path: string): ValueNode | undefined;
+    getValue(path: string): unknown;
+    setValue(path: string, value: unknown): void;
+    getPlainValue(): unknown;
+    readonly isDirty: boolean;
+    readonly isValid: boolean;
+    readonly errors: readonly Diagnostic[];
+    getPatches(): readonly JsonValuePatch[];
+    commit(): void;
+    revert(): void;
+}
+
+interface TableModelLike {
+    getRowIndex(rowId: string): number;
+    getRowAt(index: number): RowModel | undefined;
+    readonly rowCount: number;
+}
+interface RowModel {
+    readonly rowId: string;
+    readonly tableModel: TableModelLike | null;
+    readonly tree: ValueTreeLike;
+    readonly index: number;
+    readonly prev: RowModel | null;
+    readonly next: RowModel | null;
+    get(path: string): ValueNode | undefined;
+    getValue(path: string): unknown;
+    setValue(path: string, value: unknown): void;
+    getPlainValue(): unknown;
+    readonly isDirty: boolean;
+    readonly isValid: boolean;
+    readonly errors: readonly Diagnostic[];
+    getPatches(): readonly JsonValuePatch[];
+    commit(): void;
+    revert(): void;
+}
+
+declare class RowModelImpl implements RowModel {
+    private readonly _rowId;
+    private readonly _tree;
+    private readonly _reactivity?;
+    private _tableModel;
+    constructor(_rowId: string, _tree: ValueTreeLike, _reactivity?: ReactivityAdapter | undefined);
+    private initObservable;
+    get rowId(): string;
+    get tableModel(): TableModelLike | null;
+    get tree(): ValueTreeLike;
+    get index(): number;
+    get prev(): RowModel | null;
+    get next(): RowModel | null;
+    get(path: string): ValueNode | undefined;
+    getValue(path: string): unknown;
+    setValue(path: string, value: unknown): void;
+    getPlainValue(): unknown;
+    get isDirty(): boolean;
+    get isValid(): boolean;
+    get errors(): readonly Diagnostic[];
+    getPatches(): readonly JsonValuePatch[];
+    commit(): void;
+    revert(): void;
+    setTableModel(tableModel: TableModelLike | null): void;
+}
+
+declare class TableModelImpl implements TableModel {
+    private _tableId;
+    private _baseTableId;
+    private readonly _schema;
+    private readonly _rows;
+    private readonly _jsonSchema;
+    private readonly _reactivity;
+    private readonly _fkResolver;
+    constructor(options: TableModelOptions, reactivity?: ReactivityAdapter);
+    private initObservable;
+    get tableId(): string;
+    get baseTableId(): string;
+    get isRenamed(): boolean;
+    get fk(): ForeignKeyResolver | undefined;
+    get schema(): SchemaModel;
+    get rows(): readonly RowModel[];
+    get rowCount(): number;
+    rename(newTableId: string): void;
+    addRow(rowId: string, data?: unknown): RowModel;
+    removeRow(rowId: string): void;
+    getRow(rowId: string): RowModel | undefined;
+    getRowIndex(rowId: string): number;
+    getRowAt(index: number): RowModel | undefined;
+    get isDirty(): boolean;
+    commit(): void;
+    revert(): void;
+    private createRowModel;
+}
+declare function createTableModel(options: TableModelOptions, reactivity?: ReactivityAdapter): TableModel;
+
+interface GenerateDefaultValueOptions {
+    arrayItemCount?: number;
+    refSchemas?: Record<string, JsonSchema>;
+}
+
+declare function generateDefaultValue(schema: JsonSchema | null | undefined, options?: GenerateDefaultValueOptions): unknown;
+
+declare class ForeignKeyResolverImpl implements ForeignKeyResolver {
+    private readonly _schemaCache;
+    private readonly _tableCache;
+    private readonly _loadingTables;
+    private readonly _loadingRows;
+    private readonly _pendingTableLoads;
+    private readonly _pendingRowLoads;
+    private _prefetchEnabled;
+    private _disposed;
+    private readonly loader;
+    private readonly reactivity;
+    constructor(options?: ForeignKeyResolverOptions);
+    private initObservable;
+    get isPrefetchEnabled(): boolean;
+    setPrefetch(enabled: boolean): void;
+    hasSchema(tableId: string): boolean;
+    hasTable(tableId: string): boolean;
+    hasRow(tableId: string, rowId: string): boolean;
+    isLoading(tableId: string): boolean;
+    isLoadingRow(tableId: string, rowId: string): boolean;
+    addSchema(tableId: string, schema: JsonObjectSchema): void;
+    addTable(tableId: string, schema: JsonObjectSchema, rows: RowData[]): void;
+    addRow(tableId: string, rowId: string, data: unknown): void;
+    renameTable(oldTableId: string, newTableId: string): void;
+    getSchema(tableId: string): Promise<JsonObjectSchema>;
+    getRowData(tableId: string, rowId: string): Promise<RowData>;
+    dispose(): void;
+    private loadSchemaInternal;
+    private loadRowInternal;
+    private ensureTableCache;
+    private markRowAsLoading;
+    private clearRowLoading;
+    private setPendingRowLoad;
+    private clearPendingRowLoad;
+    private prefetchForeignKeysFromTable;
+    private prefetchForeignKeysFromRow;
+    private prefetchRow;
+    private extractForeignKeys;
+    private getForeignKeyFromSchema;
+}
+declare function createForeignKeyResolver(options?: ForeignKeyResolverOptions): ForeignKeyResolver;
+
+declare class ForeignKeyNotFoundError extends Error {
+    readonly tableId: string;
+    readonly rowId?: string | undefined;
+    constructor(tableId: string, rowId?: string | undefined);
+}
+declare class ForeignKeyResolverNotConfiguredError extends Error {
+    constructor();
+}
+
+interface DataModel {
+    readonly fk: ForeignKeyResolver;
+    addTable(tableId: string, schema: JsonObjectSchema, rows?: RowData[]): TableModel;
+    getTable(tableId: string): TableModel | undefined;
+    removeTable(tableId: string): void;
+    renameTable(oldTableId: string, newTableId: string): void;
+    hasTable(tableId: string): boolean;
+    readonly tables: readonly TableModel[];
+    readonly tableIds: readonly string[];
+    readonly isDirty: boolean;
+    commit(): void;
+    revert(): void;
+    dispose(): void;
+}
+
+interface DataModelOptions {
+    reactivity?: ReactivityAdapter;
+    fkResolver?: ForeignKeyResolver;
+}
+
+declare class DataModelImpl implements DataModel {
+    private readonly _tables;
+    private readonly _fk;
+    private readonly _ownsFkResolver;
+    private readonly _reactivity;
+    constructor(options?: DataModelOptions);
+    private initObservable;
+    get fk(): ForeignKeyResolver;
+    get tables(): readonly TableModel[];
+    get tableIds(): readonly string[];
+    get isDirty(): boolean;
+    hasTable(tableId: string): boolean;
+    getTable(tableId: string): TableModel | undefined;
+    addTable(tableId: string, schema: JsonObjectSchema, rows?: RowData[]): TableModel;
+    removeTable(tableId: string): void;
+    renameTable(oldTableId: string, newTableId: string): void;
+    commit(): void;
+    revert(): void;
+    dispose(): void;
+}
+declare function createDataModel(options?: DataModelOptions): DataModel;
+
+declare function generateNodeId(): string;
+declare function resetNodeIdCounter(): void;
+declare abstract class BaseValueNode implements ValueNode {
+    readonly id: string;
+    abstract readonly type: ValueType;
+    readonly schema: JsonSchema;
+    private _parent;
+    private readonly _name;
+    constructor(id: string | undefined, name: string, schema: JsonSchema);
+    get parent(): ValueNode | null;
+    set parent(value: ValueNode | null);
+    get name(): string;
+    abstract get value(): unknown;
+    abstract getPlainValue(): unknown;
+    isObject(): this is ObjectValueNode$1;
+    isArray(): this is ArrayValueNode$1;
+    isPrimitive(): this is PrimitiveValueNode;
+    get errors(): readonly Diagnostic[];
+    get warnings(): readonly Diagnostic[];
+    get isValid(): boolean;
+    get hasWarnings(): boolean;
+}
+
+declare abstract class BasePrimitiveValueNode<T extends string | number | boolean> extends BaseValueNode implements PrimitiveValueNode {
+    protected readonly reactivity?: ReactivityAdapter | undefined;
+    protected _value: T;
+    protected _baseValue: T;
+    protected _formulaWarning: FormulaWarning | null;
+    constructor(id: string | undefined, name: string, schema: JsonSchema, value: T | undefined, defaultValue: T, reactivity?: ReactivityAdapter | undefined);
+    protected initObservable(): void;
+    get value(): T;
+    set value(newValue: T);
+    get baseValue(): T;
+    get isDirty(): boolean;
+    abstract get defaultValue(): T;
+    get formula(): FormulaDefinition | undefined;
+    get formulaWarning(): FormulaWarning | null;
+    get isReadOnly(): boolean;
+    getPlainValue(): T;
+    setValue(value: unknown, options?: {
+        internal?: boolean;
+    }): void;
+    protected abstract coerceValue(value: unknown): T;
+    setFormulaWarning(warning: FormulaWarning | null): void;
+    commit(): void;
+    revert(): void;
+    isPrimitive(): this is PrimitiveValueNode;
+    get errors(): readonly Diagnostic[];
+    protected computeErrors(): readonly Diagnostic[];
+    get warnings(): readonly Diagnostic[];
+}
+
+declare class StringValueNode extends BasePrimitiveValueNode<string> {
+    readonly type = ValueType.String;
+    constructor(id: string | undefined, name: string, schema: JsonSchema, value?: string, reactivity?: ReactivityAdapter);
+    get defaultValue(): string;
+    protected coerceValue(value: unknown): string;
+    protected computeErrors(): readonly Diagnostic[];
+    private validateRequired;
+    private validateForeignKey;
+    private validateMinLength;
+    private validateMaxLength;
+    private validatePattern;
+    private validateEnum;
+}
+
+declare class NumberValueNode extends BasePrimitiveValueNode<number> {
+    readonly type = ValueType.Number;
+    constructor(id: string | undefined, name: string, schema: JsonSchema, value?: number, reactivity?: ReactivityAdapter);
+    get defaultValue(): number;
+    protected coerceValue(value: unknown): number;
+    protected computeErrors(): readonly Diagnostic[];
+}
+
+declare class BooleanValueNode extends BasePrimitiveValueNode<boolean> {
+    readonly type = ValueType.Boolean;
+    constructor(id: string | undefined, name: string, schema: JsonSchema, value?: boolean, reactivity?: ReactivityAdapter);
+    get defaultValue(): boolean;
+    protected coerceValue(value: unknown): boolean;
+}
+
+declare class ObjectValueNode extends BaseValueNode implements ObjectValueNode$1 {
+    private readonly reactivity?;
+    readonly type = ValueType.Object;
+    private _children;
+    private _baseChildren;
+    constructor(id: string | undefined, name: string, schema: JsonSchema, children?: ValueNode[], reactivity?: ReactivityAdapter | undefined);
+    private initObservable;
+    get value(): Record<string, ValueNode>;
+    get children(): readonly ValueNode[];
+    getPlainValue(): Record<string, unknown>;
+    child(name: string): ValueNode | undefined;
+    hasChild(name: string): boolean;
+    addChild(node: ValueNode): void;
+    removeChild(name: string): void;
+    get isDirty(): boolean;
+    commit(): void;
+    revert(): void;
+    isObject(): this is ObjectValueNode$1;
+    get errors(): readonly Diagnostic[];
+    get warnings(): readonly Diagnostic[];
+}
+
+declare class ArrayValueNode extends BaseValueNode implements ArrayValueNode$1 {
+    private readonly reactivity?;
+    readonly type = ValueType.Array;
+    private _items;
+    private _baseItems;
+    private _nodeFactory;
+    constructor(id: string | undefined, name: string, schema: JsonSchema, items?: ValueNode[], reactivity?: ReactivityAdapter | undefined);
+    private initObservable;
+    get value(): readonly ValueNode[];
+    get length(): number;
+    getPlainValue(): unknown[];
+    at(index: number): ValueNode | undefined;
+    push(node: ValueNode): void;
+    insertAt(index: number, node: ValueNode): void;
+    removeAt(index: number): void;
+    move(fromIndex: number, toIndex: number): void;
+    replaceAt(index: number, node: ValueNode): void;
+    clear(): void;
+    setNodeFactory(factory: NodeFactory): void;
+    pushValue(value?: unknown): void;
+    insertValueAt(index: number, value?: unknown): void;
+    private createItemNode;
+    private propagateFactory;
+    get isDirty(): boolean;
+    commit(): void;
+    revert(): void;
+    isArray(): this is ArrayValueNode$1;
+    get errors(): readonly Diagnostic[];
+    get warnings(): readonly Diagnostic[];
+}
+
+interface ForeignKeyValueNode extends ValueNode {
+    readonly value: string;
+    readonly foreignKey: string;
+    getRow(): Promise<RowData>;
+    getSchema(): Promise<JsonObjectSchema>;
+    readonly isLoading: boolean;
+}
+declare function isForeignKeyValueNode(node: ValueNode): node is ForeignKeyValueNode;
+declare class ForeignKeyValueNodeImpl extends StringValueNode implements ForeignKeyValueNode {
+    private readonly fkResolver?;
+    private readonly _foreignKey;
+    constructor(id: string | undefined, name: string, schema: JsonSchema, value?: string, reactivity?: ReactivityAdapter, fkResolver?: ForeignKeyResolver | undefined);
+    get foreignKey(): string;
+    get isLoading(): boolean;
+    getRow(): Promise<RowData>;
+    getSchema(): Promise<JsonObjectSchema>;
+}
+
+export { type ArrayNodeOptions, ArrayValueNode, type ArrayValueNode$1 as ArrayValueNodeInterface, BasePrimitiveValueNode, BaseValueNode, BooleanValueNode, type DataModel, DataModelImpl, type DataModelOptions, type DirtyTrackable, type FieldType, type ForeignKeyLoader, type ForeignKeyLoaderResult, ForeignKeyNotFoundError, type ForeignKeyResolver, ForeignKeyResolverImpl, ForeignKeyResolverNotConfiguredError, type ForeignKeyResolverOptions, type ForeignKeyRowLoaderResult, type ForeignKeyValueNode, ForeignKeyValueNodeImpl, type FormulaDefinition, type FormulaWarning, type GenerateDefaultValueOptions, JsonSchemaStore, NodeFactory$1 as NodeFactory, type NodeFactoryFn, type NodeFactoryOptions, NodeFactoryRegistry, NumberValueNode, type ObjectNodeOptions, ObjectValueNode, type ObjectValueNode$1 as ObjectValueNodeInterface, type PrimitiveNodeOptions, type PrimitiveValueNode, type ReactivityOptions, type RefSchemas, type ReplaceResult, type RowData, type RowModel, RowModelImpl, type SchemaModel, SchemaParser, StringValueNode, type TableModel, TableModelImpl, type TableModelLike, type TableModelOptions, type ValueNode, NodeFactory as ValueNodeFactory, type ValueNodeOptions, type ValueTreeLike, ValueType, createDataModel, createDefaultRegistry, createForeignKeyResolver, createNodeFactory, createSchemaModel, createTableModel, equal, extractFormulaDefinition, fromArrayToObject, fromArrayTransformation, fromBooleanToNumber, fromBooleanToString, fromNumberToBoolean, fromNumberToString, fromObjectToArray, fromObjectToPrimitive, fromPrimitiveToObject, fromStringToBoolean, fromStringToNumber, generateDefaultValue, generateNodeId, getTransformation, isForeignKeyValueNode, resetNodeIdCounter, toArrayTransformation };