@revisium/schema-toolkit 0.20.2 → 0.21.1

package/dist/model/index.d.ts

@@ -1,61 +1,19 @@
-import { h as JsonSchemaStore } from '../json-string.store-C58zbl31.js';
-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-C58zbl31.js';
-import { l as SchemaNode, P as Path, j as NodeMetadata, h as SchemaValidationError, T as TreeFormulaValidationError, n as SchemaPatch, m as SchemaTree, D as Diagnostic, B as BasePath, r as BasePathSegment, s as Formula, F as FormulaDependency } from '../FormulaPathBuilder-DwlKOvVB.js';
-export { b as FormulaPathBuilder, a as FormulaSerializer, R as ResolvedDependency } from '../FormulaPathBuilder-DwlKOvVB.js';
-import { h as JsonPatch } from '../json-patch.types-DY7k9hxy.js';
-import { f as JsonObjectSchema, i as JsonSchema } from '../schema.types-B5OgKLpV.js';
-import { d as JsonValuePatch } from '../json-value-patch.types-CgiEpchp.js';
+import { h as JsonSchemaStore } from '../json-string.store-DfdLcgnM.js';
+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-DfdLcgnM.js';
+import { a3 as RefSchemas, Y as TypeTransformer, E as FieldTypeSpec, _ as TransformResult, Z as TransformContext, M as RowData, H as SchemaModelOptions, B as SchemaModel, C as FieldType, Q as RowModel, S as SchemaPaths, N as NodeAtPath, V as ValueAtPath, I as InferValue, U as RowModelOptions, z as ValueTreeLike, W as TableModelLike, q as ValueNode, d as JsonValuePatch, L as TableModelOptions, K as TableModel, X as ForeignKeyResolver, R as RefSchemas$1, l as ValueType, a4 as NodeChangeListener, a5 as NodeChangeEvent, O as ObjectValueNode$1, A as ArrayValueNode$1, P as PrimitiveValueNode, r as FormulaWarning, F as FormulaDefinition, y as NodeFactory$1, a6 as ValuePath, a7 as Change, x as NodeFactoryOptions, g as InferNode } from '../typed-BRZhUqGG.js';
+export { v as ArrayNodeOptions, a2 as CompositeTypeName, D as DirtyTrackable, $ as FieldSchemaSpec, w as NodeFactoryFn, n as NodeFactoryRegistry, u as ObjectNodeOptions, t as PrimitiveNodeOptions, a1 as PrimitiveTypeName, G as ReplaceResult, a0 as SimpleFieldType, s as ValueNodeOptions, p as createDefaultRegistry, o as createNodeFactory, m as extractFormulaDefinition } from '../typed-BRZhUqGG.js';
+import { g as JsonObjectSchema, j as JsonSchema } from '../schema.types-On_VGw2m.js';
+import { j as SchemaNode, T as TreeFormulaValidationError, D as Diagnostic, o as Formula, F as FormulaDependency, P as Path } from '../types-C_pTFtSY.js';
+export { R as ResolvedDependency } from '../types-C_pTFtSY.js';
+import { S as SchemaTree } from '../FormulaPathBuilder-QR0htn-e.js';
+export { a as FormulaPathBuilder, F as FormulaSerializer } from '../FormulaPathBuilder-QR0htn-e.js';
 import { ASTNode } from '@revisium/formula';
 import 'eventemitter3';
 import '../json.types-PrMmLhba.js';
-
-declare const equal: (value: unknown) => unknown;
-declare const fromNumberToString: (value: number, defaultValue?: string) => string;
-declare const fromBooleanToString: (value: boolean, defaultValue?: string) => string;
-declare const fromStringToBoolean: (value: string, defaultValue?: boolean) => boolean;
-declare const fromStringToNumber: (value: string, defaultValue?: number) => number;
-declare const fromBooleanToNumber: (value: boolean) => number;
-declare const fromNumberToBoolean: (value: number) => boolean;
-declare const toArrayTransformation: (transformation: Transformation) => (value: unknown) => unknown[];
-declare const fromArrayTransformation: (transformation: Transformation) => (value: unknown) => unknown;
-declare const fromObjectToPrimitive: (_value: unknown, defaultValue: unknown) => unknown;
-declare const fromPrimitiveToObject: (_value: unknown, defaultValue: unknown) => unknown;
-declare const fromObjectToArray: (_value: unknown, defaultValue: unknown) => unknown;
-declare const fromArrayToObject: (_value: unknown, defaultValue: unknown) => unknown;
-declare const getTransformation: (from: JsonSchemaStore, to: JsonSchemaStore) => Transformation | undefined;
-type Transformation = (value: unknown, defaultValue?: unknown) => unknown;
-
-type PrimitiveTypeName = 'string' | 'number' | 'boolean';
-type CompositeTypeName = 'object' | 'array';
-type SimpleFieldType = PrimitiveTypeName | CompositeTypeName;
-interface FieldSchemaSpec {
-    type?: SimpleFieldType;
-    $ref?: string;
-    default?: unknown;
-    title?: string;
-    description?: string;
-    deprecated?: boolean;
-    foreignKey?: string;
-    'x-formula'?: {
-        expression: string;
-    };
-}
-type FieldTypeSpec = SimpleFieldType | FieldSchemaSpec;
-interface TransformContext {
-    sourceNode: SchemaNode;
-    targetSpec: FieldSchemaSpec;
-    refSchemas?: RefSchemas$1;
-}
-interface TransformResult {
-    node: SchemaNode;
-}
-interface TypeTransformer {
-    canTransform(ctx: TransformContext): boolean;
-    transform(ctx: TransformContext): TransformResult;
-}
+import '../json-patch.types-BpVnp08Z.js';
 
 interface TypeTransformChainOptions {
-    refSchemas?: RefSchemas$1;
+    refSchemas?: RefSchemas;
     customTransformers?: TypeTransformer[];
 }
 declare class TypeTransformChain {
@@ -97,62 +55,43 @@ declare class DefaultTransformer implements TypeTransformer {
     private extractMetadata;
 }
 
-type RefSchemas$1 = Record<string, JsonSchema>;
-interface SchemaModelOptions {
-    refSchemas?: RefSchemas$1;
-    customTransformers?: TypeTransformer[];
+interface ForeignKeyRowLoaderResult {
+    schema: JsonObjectSchema;
+    row: RowData;
 }
-type FieldType = 'string' | 'number' | 'boolean' | 'object' | 'array';
-
-interface ReplaceResult {
-    replacedNodeId: string;
-    newNodeId: string;
-}
-interface SchemaModel {
-    readonly root: SchemaNode;
-    nodeById(id: string): SchemaNode;
-    pathOf(id: string): Path;
-    addField(parentId: string, name: string, type: FieldType): SchemaNode;
-    insertFieldAt(parentId: string, index: number, name: string, type: FieldType): SchemaNode;
-    removeField(nodeId: string): boolean;
-    renameField(nodeId: string, newName: string): void;
-    changeFieldType(nodeId: string, newType: FieldTypeSpec): 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;
-    moveNode(nodeId: string, targetParentId: string): void;
-    getFormulaDependents(nodeId: string): readonly string[];
-    hasFormulaDependents(nodeId: string): boolean;
-    serializeFormula(nodeId: string): string;
-    readonly validationErrors: SchemaValidationError[];
-    readonly formulaErrors: TreeFormulaValidationError[];
-    readonly isDirty: boolean;
-    readonly isValid: boolean;
-    readonly patches: SchemaPatch[];
-    readonly jsonPatches: JsonPatch[];
-    markAsSaved(): void;
-    revert(): void;
-    readonly plainSchema: JsonObjectSchema;
-    readonly nodeCount: number;
-    readonly refSchemas: RefSchemas$1 | undefined;
-    generateDefaultValue(options?: {
-        arrayItemCount?: number;
-    }): unknown;
+interface ForeignKeyLoader {
+    loadSchema(tableId: string): Promise<JsonObjectSchema>;
+    loadRow(tableId: string, rowId: string): Promise<ForeignKeyRowLoaderResult>;
+}
+interface ForeignKeyResolverOptions {
+    loader?: ForeignKeyLoader;
+    prefetch?: boolean;
+    prefetchDepth?: 1;
 }
 
+declare const equal: (value: unknown) => unknown;
+declare const fromNumberToString: (value: number, defaultValue?: string) => string;
+declare const fromBooleanToString: (value: boolean, defaultValue?: string) => string;
+declare const fromStringToBoolean: (value: string, defaultValue?: boolean) => boolean;
+declare const fromStringToNumber: (value: string, defaultValue?: number) => number;
+declare const fromBooleanToNumber: (value: boolean) => number;
+declare const fromNumberToBoolean: (value: number) => boolean;
+declare const toArrayTransformation: (transformation: Transformation) => (value: unknown) => unknown[];
+declare const fromArrayTransformation: (transformation: Transformation) => (value: unknown) => unknown;
+declare const fromObjectToPrimitive: (_value: unknown, defaultValue: unknown) => unknown;
+declare const fromPrimitiveToObject: (_value: unknown, defaultValue: unknown) => unknown;
+declare const fromObjectToArray: (_value: unknown, defaultValue: unknown) => unknown;
+declare const fromArrayToObject: (_value: unknown, defaultValue: unknown) => unknown;
+declare const getTransformation: (from: JsonSchemaStore, to: JsonSchemaStore) => Transformation | undefined;
+type Transformation = (value: unknown, defaultValue?: unknown) => unknown;
+
 declare function createSchemaModel(schema: JsonObjectSchema, options?: SchemaModelOptions): SchemaModel;
 
 declare class SchemaParser {
     private pendingFormulas;
     private _parseErrors;
     private _refSchemas;
-    parse(schema: JsonObjectSchema, refSchemas?: RefSchemas$1): SchemaNode;
+    parse(schema: JsonObjectSchema, refSchemas?: RefSchemas): SchemaNode;
     parseFormulas(tree: SchemaTree): void;
     get parseErrors(): TreeFormulaValidationError[];
     private parseNode;
@@ -165,255 +104,21 @@ declare class SchemaParser {
     private collectFormula;
 }
 
-declare class NodeFactory$1 {
+declare class NodeFactory {
     createNode(name: string, type: FieldType): SchemaNode;
     private createArrayNodeInternal;
     createArrayNodeWithItems(name: string, items: SchemaNode): SchemaNode;
 }
 
-declare enum ValueType {
-    String = "string",
-    Number = "number",
-    Boolean = "boolean",
-    Object = "object",
-    Array = "array"
+interface TypedRowModel<S> extends RowModel {
+    get<P extends SchemaPaths<S>>(path: P): NodeAtPath<S, P>;
+    getValue<P extends SchemaPaths<S>>(path: P): ValueAtPath<S, P>;
+    setValue<P extends SchemaPaths<S>>(path: P, value: ValueAtPath<S, P>): void;
+    getPlainValue(): InferValue<S>;
 }
-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;
-
-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;
-    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(fkResolver?: ForeignKeyResolver): NodeFactoryRegistry;
-declare function createNodeFactory(options?: NodeFactoryOptions): NodeFactory;
-
-interface RowData {
-    rowId: string;
-    data: unknown;
-}
-interface TableModelOptions {
-    tableId: string;
-    schema: JsonObjectSchema;
-    rows?: RowData[];
-    fkResolver?: ForeignKeyResolver;
-    refSchemas?: RefSchemas;
-}
-interface TableModel {
-    readonly fk: ForeignKeyResolver | undefined;
-    readonly refSchemas: RefSchemas | 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;
-    dispose(): 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 {
-    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;
-}
-
-interface ValuePathSegment extends BasePathSegment {
-    isProperty(): boolean;
-    isIndex(): boolean;
-    propertyName(): string;
-    indexValue(): number;
-    equals(other: ValuePathSegment): boolean;
-}
-interface ValuePath extends BasePath<ValuePathSegment, ValuePath> {
-    asString(): string;
-    asJsonPointer(): string;
-    child(name: string): ValuePath;
-    childIndex(index: number): ValuePath;
-}
-
-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;
-    nodeById(id: string): ValueNode | undefined;
-    pathOf(nodeOrId: ValueNode | string): ValuePath;
-    dispose(): void;
-}
-
-interface RowModelOptions {
-    rowId: string;
-    schema: JsonSchema;
-    data?: unknown;
-    fkResolver?: ForeignKeyResolver;
-    refSchemas?: RefSchemas;
-}
-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;
-    nodeById(id: string): ValueNode | undefined;
-    readonly isDirty: boolean;
-    readonly isValid: boolean;
-    readonly errors: readonly Diagnostic[];
-    getPatches(): readonly JsonValuePatch[];
-    commit(): void;
-    revert(): void;
-    dispose(): void;
+interface TypedRowModelOptions<S extends JsonSchema> extends Omit<RowModelOptions, 'schema' | 'data'> {
+    schema: S;
+    data?: InferValue<S>;
 }
 
 declare class RowModelImpl implements RowModel {
@@ -441,8 +146,24 @@ declare class RowModelImpl implements RowModel {
     dispose(): void;
     setTableModel(tableModel: TableModelLike | null): void;
 }
+declare function createRowModel<const S extends JsonSchema>(options: TypedRowModelOptions<S>): TypedRowModel<S>;
 declare function createRowModel(options: RowModelOptions): RowModel;
 
+interface TypedRowData<S> {
+    rowId: string;
+    data: InferValue<S>;
+}
+interface TypedTableModel<S> extends TableModel {
+    readonly rows: readonly TypedRowModel<S>[];
+    addRow(rowId: string, data?: InferValue<S>): TypedRowModel<S>;
+    getRow(rowId: string): TypedRowModel<S> | undefined;
+    getRowAt(index: number): TypedRowModel<S> | undefined;
+}
+interface TypedTableModelOptions<S extends JsonObjectSchema> extends Omit<TableModelOptions, 'schema' | 'rows'> {
+    schema: S;
+    rows?: TypedRowData<S>[];
+}
+
 declare class TableModelImpl implements TableModel {
     private _tableId;
     private _baseTableId;
@@ -456,7 +177,7 @@ declare class TableModelImpl implements TableModel {
     get baseTableId(): string;
     get isRenamed(): boolean;
     get fk(): ForeignKeyResolver | undefined;
-    get refSchemas(): RefSchemas | undefined;
+    get refSchemas(): RefSchemas$1 | undefined;
     get schema(): SchemaModel;
     get rows(): readonly RowModel[];
     get rowCount(): number;
@@ -472,6 +193,7 @@ declare class TableModelImpl implements TableModel {
     dispose(): void;
     private createRow;
 }
+declare function createTableModel<const S extends JsonObjectSchema>(options: TypedTableModelOptions<S>): TypedTableModel<S>;
 declare function createTableModel(options: TableModelOptions): TableModel;
 
 interface GenerateDefaultValueOptions {
@@ -634,7 +356,11 @@ declare abstract class BaseValueNode implements ValueNode {
     readonly schema: JsonSchema;
     private _parent;
     private readonly _name;
+    private readonly _emitter;
     constructor(id: string | undefined, name: string, schema: JsonSchema);
+    on(event: 'change', listener: NodeChangeListener): void;
+    off(event: 'change', listener: NodeChangeListener): void;
+    protected emit(changeEvent: NodeChangeEvent): void;
     get parent(): ValueNode | null;
     set parent(value: ValueNode | null);
     get name(): string;
@@ -718,6 +444,9 @@ declare class ObjectValueNode extends BaseValueNode implements ObjectValueNode$1
     hasChild(name: string): boolean;
     addChild(node: ValueNode): void;
     removeChild(name: string): void;
+    setValue(value: Record<string, unknown>, options?: {
+        internal?: boolean;
+    }): void;
     get isDirty(): boolean;
     commit(): void;
     revert(): void;
@@ -742,9 +471,12 @@ declare class ArrayValueNode extends BaseValueNode implements ArrayValueNode$1 {
     move(fromIndex: number, toIndex: number): void;
     replaceAt(index: number, node: ValueNode): void;
     clear(): void;
-    setNodeFactory(factory: NodeFactory): void;
+    setNodeFactory(factory: NodeFactory$1): void;
     pushValue(value?: unknown): void;
     insertValueAt(index: number, value?: unknown): void;
+    setValue(value: unknown[], options?: {
+        internal?: boolean;
+    }): void;
     private createItemNode;
     private propagateFactory;
     get isDirty(): boolean;
@@ -773,4 +505,97 @@ declare class ForeignKeyValueNodeImpl extends StringValueNode implements Foreign
     getSchema(): Promise<JsonObjectSchema>;
 }
 
-export { type ArrayNodeOptions, ArrayToItemsTypeTransformer, ArrayValueNode, type ArrayValueNode$1 as ArrayValueNodeInterface, BasePrimitiveValueNode, BaseValueNode, BooleanValueNode, type CompositeTypeName, type DataModel, DataModelImpl, type DataModelOptions, DefaultTransformer, type DirtyTrackable, type FieldSchemaSpec, type FieldType, type FieldTypeSpec, type ForeignKeyLoader, type ForeignKeyLoaderResult, ForeignKeyNotFoundError, type ForeignKeyResolver, ForeignKeyResolverImpl, ForeignKeyResolverNotConfiguredError, type ForeignKeyResolverOptions, type ForeignKeyRowLoaderResult, type ForeignKeyValueNode, ForeignKeyValueNodeImpl, FormulaChangeDetector, type FormulaDefinition, FormulaDependency, FormulaDependencyIndex, FormulaPath, type FormulaWarning, type GenerateDefaultValueOptions, type IndirectFormulaChange, JsonSchemaStore, NodeFactory$1 as NodeFactory, type NodeFactoryFn, type NodeFactoryOptions, NodeFactoryRegistry, NumberValueNode, type ObjectNodeOptions, ObjectToArrayTransformer, ObjectValueNode, type ObjectValueNode$1 as ObjectValueNodeInterface, ParsedFormula, type PrimitiveNodeOptions, PrimitiveToArrayTransformer, type PrimitiveTypeName, type PrimitiveValueNode, type RefSchemas, RefTransformer, type ReplaceResult, type RowData, type RowModel, RowModelImpl, type RowModelOptions, type SchemaModel, type SchemaModelOptions, SchemaParser, type SimpleFieldType, StringValueNode, type TableModel, TableModelImpl, type TableModelLike, type TableModelOptions, type TransformContext, type TransformResult, TypeTransformChain, type TypeTransformChainOptions, type TypeTransformer, type ValueNode, NodeFactory as ValueNodeFactory, type ValueNodeOptions, type ValueTreeLike, ValueType, createDataModel, createDefaultRegistry, createForeignKeyResolver, createNodeFactory, createRowModel, createSchemaModel, createTableModel, createTypeTransformChain, equal, extractFormulaDefinition, fromArrayToObject, fromArrayTransformation, fromBooleanToNumber, fromBooleanToString, fromNumberToBoolean, fromNumberToString, fromObjectToArray, fromObjectToPrimitive, fromPrimitiveToObject, fromStringToBoolean, fromStringToNumber, generateDefaultValue, generateNodeId, getTransformation, isForeignKeyValueNode, resetNodeIdCounter, toArrayTransformation };
+interface FormulaArrayLevel {
+    readonly array: ArrayValueNode$1;
+    readonly index: number;
+}
+interface FormulaField {
+    readonly node: PrimitiveValueNode;
+    readonly expression: string;
+    readonly parent: ObjectValueNode$1 | null;
+    readonly dependencyNodes: readonly PrimitiveValueNode[];
+    readonly arrayLevels: readonly FormulaArrayLevel[];
+}
+interface FormulaEngineOptions {
+    onError?: (node: PrimitiveValueNode, error: Error) => void;
+    onWarning?: (node: PrimitiveValueNode, type: string, message: string) => void;
+}
+interface ValueTreeRoot {
+    readonly root: ValueNode;
+    getPlainValue(): unknown;
+}
+
+declare class FormulaEngine {
+    private readonly tree;
+    private readonly collector;
+    private readonly graph;
+    private readonly evaluator;
+    private formulas;
+    private dependencyMap;
+    private evaluationOrder;
+    private disposers;
+    constructor(tree: ValueTreeRoot, options?: FormulaEngineOptions);
+    reinitialize(): void;
+    dispose(): void;
+    getFormulas(): readonly FormulaField[];
+    getEvaluationOrder(): readonly FormulaField[];
+    private initialize;
+    private evaluateAll;
+    private setupReactions;
+    private setupArrayReactions;
+    private handleDependencyChange;
+    private handleStructureChange;
+    private disposeReactions;
+}
+
+declare class ValueTree implements ValueTreeLike {
+    private readonly _root;
+    private readonly index;
+    private readonly changeTracker;
+    private readonly _nodeChangeListener;
+    private _formulaEngine;
+    private _suppressEvents;
+    constructor(_root: ValueNode);
+    get root(): ValueNode;
+    nodeById(id: string): ValueNode | undefined;
+    pathOf(nodeOrId: ValueNode | string): ValuePath;
+    get(path: string): ValueNode | undefined;
+    getValue(path: string): unknown;
+    setValue(path: string, value: unknown, options?: {
+        internal?: boolean;
+    }): void;
+    getPlainValue(): unknown;
+    get isDirty(): boolean;
+    get isValid(): boolean;
+    get errors(): readonly Diagnostic[];
+    getPatches(): readonly JsonValuePatch[];
+    trackChange(change: Change): void;
+    commit(): void;
+    revert(): void;
+    rebuildIndex(): void;
+    registerNode(node: ValueNode): void;
+    invalidatePathsUnder(node: ValueNode): void;
+    setFormulaEngine(engine: FormulaEngine): void;
+    get formulaEngine(): FormulaEngine | null;
+    dispose(): void;
+    private handleNodeChange;
+    private toArrayItemChange;
+    private toArrayStructureChange;
+    private adoptNode;
+    private walkTree;
+    private subscribe;
+    private unsubscribe;
+}
+
+interface TypedValueTree<S> extends ValueTreeLike {
+    readonly root: InferNode<S>;
+    get<P extends SchemaPaths<S>>(path: P): NodeAtPath<S, P>;
+    getValue<P extends SchemaPaths<S>>(path: P): ValueAtPath<S, P>;
+    setValue<P extends SchemaPaths<S>>(path: P, value: ValueAtPath<S, P>, options?: {
+        internal?: boolean;
+    }): void;
+}
+declare function typedNode<S extends JsonSchema>(node: ValueNode): InferNode<S>;
+declare function createTypedTree<const S extends JsonSchema>(schema: S, data: InferValue<S>, options?: NodeFactoryOptions): TypedValueTree<S>;
+
+export { ArrayToItemsTypeTransformer, ArrayValueNode, ArrayValueNode$1 as ArrayValueNodeInterface, BasePrimitiveValueNode, BaseValueNode, BooleanValueNode, type DataModel, DataModelImpl, type DataModelOptions, DefaultTransformer, FieldType, FieldTypeSpec, type ForeignKeyLoader, ForeignKeyNotFoundError, ForeignKeyResolver, ForeignKeyResolverImpl, ForeignKeyResolverNotConfiguredError, type ForeignKeyResolverOptions, type ForeignKeyRowLoaderResult, type ForeignKeyValueNode, ForeignKeyValueNodeImpl, FormulaChangeDetector, FormulaDefinition, FormulaDependency, FormulaDependencyIndex, FormulaPath, FormulaWarning, type GenerateDefaultValueOptions, type IndirectFormulaChange, JsonSchemaStore, NodeFactory, NodeFactoryOptions, NumberValueNode, ObjectToArrayTransformer, ObjectValueNode, ObjectValueNode$1 as ObjectValueNodeInterface, ParsedFormula, PrimitiveToArrayTransformer, PrimitiveValueNode, RefSchemas$1 as RefSchemas, RefTransformer, RowData, RowModel, RowModelImpl, RowModelOptions, SchemaModel, SchemaModelOptions, SchemaParser, StringValueNode, TableModel, TableModelImpl, TableModelLike, TableModelOptions, TransformContext, TransformResult, TypeTransformChain, type TypeTransformChainOptions, TypeTransformer, type TypedRowData, type TypedRowModel, type TypedRowModelOptions, type TypedTableModel, type TypedTableModelOptions, type TypedValueTree, ValueNode, NodeFactory$1 as ValueNodeFactory, ValueTree, ValueTreeLike, ValueType, createDataModel, createForeignKeyResolver, createRowModel, createSchemaModel, createTableModel, createTypeTransformChain, createTypedTree, equal, fromArrayToObject, fromArrayTransformation, fromBooleanToNumber, fromBooleanToString, fromNumberToBoolean, fromNumberToString, fromObjectToArray, fromObjectToPrimitive, fromPrimitiveToObject, fromStringToBoolean, fromStringToNumber, generateDefaultValue, generateNodeId, getTransformation, isForeignKeyValueNode, resetNodeIdCounter, toArrayTransformation, typedNode };

package/dist/model/index.js

@@ -1,9 +1,4 @@
-export { ArrayToItemsTypeTransformer, ArrayValueNode, BasePrimitiveValueNode, BaseValueNode, BooleanValueNode, DataModelImpl, DefaultTransformer, ForeignKeyNotFoundError, ForeignKeyResolverImpl, ForeignKeyResolverNotConfiguredError, ForeignKeyValueNodeImpl, FormulaChangeDetector, FormulaDependencyIndex, FormulaPath, NodeFactory, NodeFactoryRegistry, NumberValueNode, ObjectToArrayTransformer, ObjectValueNode, ParsedFormula, PrimitiveToArrayTransformer, RefTransformer, RowModelImpl, SchemaParser, StringValueNode, TableModelImpl, TypeTransformChain, NodeFactory2 as ValueNodeFactory, ValueType, createDataModel, createDefaultRegistry, createForeignKeyResolver, createNodeFactory, createRowModel, createSchemaModel, createTableModel, createTypeTransformChain, extractFormulaDefinition, generateDefaultValue, generateNodeId, isForeignKeyValueNode, resetNodeIdCounter } from '../chunk-U5YDA3LA.js';
-export { FormulaPathBuilder, FormulaSerializer, ResolvedDependency } from '../chunk-3JZKQWQH.js';
-import '../chunk-3IKI64T2.js';
-import '../chunk-R4CFU33U.js';
-export { JsonArrayStore, JsonArrayValueStore, JsonBooleanStore, JsonBooleanValueStore, JsonNumberStore, JsonNumberValueStore, JsonObjectStore, JsonObjectValueStore, JsonStringStore, JsonStringValueStore, equal, fromArrayToObject, fromArrayTransformation, fromBooleanToNumber, fromBooleanToString, fromNumberToBoolean, fromNumberToString, fromObjectToArray, fromObjectToPrimitive, fromPrimitiveToObject, fromStringToBoolean, fromStringToNumber, getTransformation, toArrayTransformation } from '../chunk-55AMH44G.js';
-import '../chunk-ZBPUTF3Q.js';
-import '../chunk-MPF6VCB5.js';
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map
+export { ArrayToItemsTypeTransformer, ArrayValueNode, BasePrimitiveValueNode, BaseValueNode, BooleanValueNode, DataModelImpl, DefaultTransformer, ForeignKeyNotFoundError, ForeignKeyResolverImpl, ForeignKeyResolverNotConfiguredError, ForeignKeyValueNodeImpl, FormulaChangeDetector, FormulaDependencyIndex, FormulaPath, NodeFactory, NodeFactoryRegistry, NumberValueNode, ObjectToArrayTransformer, ObjectValueNode, ParsedFormula, PrimitiveToArrayTransformer, RefTransformer, RowModelImpl, SchemaParser, StringValueNode, TableModelImpl, TypeTransformChain, NodeFactory2 as ValueNodeFactory, ValueTree, ValueType, createDataModel, createDefaultRegistry, createForeignKeyResolver, createNodeFactory, createRowModel, createSchemaModel, createTableModel, createTypeTransformChain, createTypedTree, extractFormulaDefinition, generateDefaultValue, generateNodeId, isForeignKeyValueNode, resetNodeIdCounter, typedNode } from '../chunk-HFMZITNE.js';
+export { FormulaPathBuilder, FormulaSerializer, ResolvedDependency } from '../chunk-AWFMSOHM.js';
+import '../chunk-IZMBM36H.js';
+export { JsonArrayStore, JsonArrayValueStore, JsonBooleanStore, JsonBooleanValueStore, JsonNumberStore, JsonNumberValueStore, JsonObjectStore, JsonObjectValueStore, JsonStringStore, JsonStringValueStore, equal, fromArrayToObject, fromArrayTransformation, fromBooleanToNumber, fromBooleanToString, fromNumberToBoolean, fromNumberToString, fromObjectToArray, fromObjectToPrimitive, fromPrimitiveToObject, fromStringToBoolean, fromStringToNumber, getTransformation, toArrayTransformation } from '../chunk-FTBRJODD.js';