jotai-state-tree 1.1.1 → 1.1.2

package/dist/index.d.mts

@@ -1,318 +1,7 @@
-import * as jotai_vanilla_internals from 'jotai/vanilla/internals';
-import { WritableAtom, createStore } from 'jotai';
-
-/**
- * Core types for jotai-state-tree
- * These types mirror the MobX-State-Tree API
- */
-type SnapshotIn<T> = T extends IModelType<infer P, any, any, any> ? {
-    [K in keyof P]?: SnapshotInOfProperty<P[K]>;
-} : T extends IArrayType<infer I> ? SnapshotIn<I>[] : T extends IMapType<infer V> ? Record<string, SnapshotIn<V>> : T extends IReferenceType<any> ? string | number : T extends IType<infer C, any, any> ? C : T;
-type SnapshotInOfProperty<T> = T extends IType<infer C, any, any> ? C : never;
-type SnapshotOut<T> = T extends IModelType<infer P, any, any, any> ? {
-    [K in keyof P]: SnapshotOutOfProperty<P[K]>;
-} : T extends IArrayType<infer I> ? SnapshotOut<I>[] : T extends IMapType<infer V> ? Record<string, SnapshotOut<V>> : T extends IReferenceType<any> ? string | number : T extends IType<any, infer S, any> ? S : T;
-type SnapshotOutOfProperty<T> = T extends IType<any, infer S, any> ? S : never;
-type Instance<T> = T extends IType<any, any, infer O> ? O : never;
-interface IType<C, S, T> {
-    /** Name of this type */
-    readonly name: string;
-    /** The identifier attribute if this type has one */
-    readonly identifierAttribute?: string;
-    /** Create an instance of this type */
-    create(snapshot?: C, env?: unknown): T;
-    /** Check if a value is an instance of this type */
-    is(value: unknown): value is T;
-    /** Validate a value against this type */
-    validate(value: unknown, context: IValidationContext[]): IValidationResult;
-    /** Type discriminator */
-    readonly _kind: string;
-    readonly _C: C;
-    readonly _S: S;
-    readonly _T: T;
-}
-interface IValidationContext {
-    path: string;
-    type: IType<unknown, unknown, unknown>;
-    parent: unknown;
-}
-interface IValidationResult {
-    valid: boolean;
-    errors: IValidationError[];
-}
-interface IValidationError {
-    context: IValidationContext[];
-    value: unknown;
-    message: string;
-}
-interface ISimpleType<T> extends IType<T, T, T> {
-    readonly _kind: "simple";
-}
-type ModelProperties = Record<string, IType<unknown, unknown, unknown>>;
-type ModelCreationType<P extends ModelProperties> = {
-    [K in keyof P]?: P[K] extends IType<infer C, unknown, unknown> ? C : never;
-};
-type ModelSnapshotType<P extends ModelProperties> = {
-    [K in keyof P]: P[K] extends IType<unknown, infer S, unknown> ? S : never;
-};
-type ModelInstanceType<P extends ModelProperties> = {
-    [K in keyof P]: P[K] extends IType<unknown, unknown, infer T> ? T : never;
-};
-/** Represents a node in the state tree */
-interface IStateTreeNode<S = unknown> {
-    readonly $id: string;
-    readonly $type: IType<unknown, unknown, unknown>;
-    readonly $parent: IStateTreeNode | null;
-    readonly $path: string;
-    readonly $env: unknown;
-    readonly $isAlive: boolean;
-}
-type ModelInstance<P extends ModelProperties, V extends object, A extends object, Vol extends object> = ModelInstanceType<P> & {
-    /** Access to the tree node metadata */
-    readonly $treenode: IStateTreeNode;
-};
-type ModelViews<Self, V> = (self: Self) => V;
-type ModelActions<Self, A> = (self: Self) => A;
-type ModelVolatile<Self, Vol> = (self: Self) => Vol;
-interface IModelType<P extends ModelProperties, V extends object, A extends object, Vol extends object> extends IType<ModelCreationType<P>, ModelSnapshotType<P>, ModelInstance<P, V, A, Vol> & V & A & Vol> {
-    readonly _kind: "model";
-    readonly properties: P;
-    /** Create a new model type with a different name */
-    named(name: string): IModelType<P, V, A, Vol>;
-    /** Add properties to the model */
-    props<P2 extends ModelProperties>(properties: P2): IModelType<P & P2, V, A, Vol>;
-    /** Add computed views to the model */
-    views<V2 extends object>(fn: ModelViews<ModelInstance<P, V, A, Vol> & V & A & Vol, V2>): IModelType<P, V & V2, A, Vol>;
-    /** Add actions to the model */
-    actions<A2 extends object>(fn: ModelActions<ModelInstance<P, V, A, Vol> & V & A & Vol, A2>): IModelType<P, V, A & A2, Vol>;
-    /** Add volatile (non-serialized) state */
-    volatile<Vol2 extends object>(fn: ModelVolatile<ModelInstance<P, V, A, Vol> & V & A & Vol, Vol2>): IModelType<P, V, A, Vol & Vol2>;
-    /** Transform snapshot before creating instance */
-    preProcessSnapshot<NewC>(fn: (snapshot: NewC) => ModelCreationType<P>): IModelType<P, V, A, Vol>;
-    /** Transform snapshot after getting it */
-    postProcessSnapshot<NewS>(fn: (snapshot: ModelSnapshotType<P>) => NewS): IModelType<P, V, A, Vol>;
-    /** Extend the model with views, actions, and state in one call */
-    extend<V2 extends object = object, A2 extends object = object, Vol2 extends object = object>(fn: (self: ModelInstance<P, V, A, Vol> & V & A & Vol) => {
-        views?: V2;
-        actions?: A2;
-        state?: Vol2;
-    }): IModelType<P, V & V2, A & A2, Vol & Vol2>;
-    /** Add afterCreate lifecycle hook */
-    afterCreate(fn: (self: ModelInstance<P, V, A, Vol> & V & A & Vol) => void): IModelType<P, V, A, Vol>;
-    /** Add afterAttach lifecycle hook (called when node is attached to tree) */
-    afterAttach(fn: (self: ModelInstance<P, V, A, Vol> & V & A & Vol) => void): IModelType<P, V, A, Vol>;
-    /** Add beforeDetach lifecycle hook (called before node is detached from tree) */
-    beforeDetach(fn: (self: ModelInstance<P, V, A, Vol> & V & A & Vol) => void): IModelType<P, V, A, Vol>;
-    /** Add beforeDestroy lifecycle hook (called before node is destroyed) */
-    beforeDestroy(fn: (self: ModelInstance<P, V, A, Vol> & V & A & Vol) => void): IModelType<P, V, A, Vol>;
-    /**
-     * Apply a mixin to this model.
-     * The mixin's requirements must be satisfied by this model's properties.
-     *
-     * @example
-     * const Timestamped = types.mixin({
-     *   requires: { createdAt: types.number },
-     *   views: (self) => ({ get formattedDate() { ... } }),
-     * });
-     *
-     * const MyModel = types
-     *   .model({ name: types.string, createdAt: types.number })
-     *   .apply(Timestamped);
-     */
-    apply<RequiredProps extends ModelProperties, MV extends object, MA extends object, MVol extends object>(mixin: IMixin<RequiredProps, MV, MA, MVol>): P extends RequiredProps ? IModelType<P, V & MV, A & MA, Vol & MVol> : never;
-}
-/**
- * MST Array interface that allows both instance types and snapshot/creation types
- * for mutation methods like push(), unshift(), splice(), etc.
- *
- * @template T - The instance type of array items
- * @template C - The creation/snapshot type of array items (defaults to T)
- */
-interface IMSTArray<T, C = T> extends Omit<Array<T>, "push" | "unshift" | "splice" | "fill"> {
-    /** Array length */
-    readonly length: number;
-    /** Push items (accepts both instances and snapshots) */
-    push(...items: (T | C)[]): number;
-    /** Unshift items (accepts both instances and snapshots) */
-    unshift(...items: (T | C)[]): number;
-    /** Splice items (accepts both instances and snapshots for new items) */
-    splice(start: number, deleteCount?: number, ...items: (T | C)[]): T[];
-    /** Fill with value */
-    fill(value: T | C, start?: number, end?: number): this;
-    /** Replace all items */
-    replace(items: (T | C)[]): void;
-    /** Remove all items */
-    clear(): void;
-    /** Remove a specific item */
-    remove(item: T): boolean;
-    /** Splice with array argument */
-    spliceWithArray(index: number, deleteCount?: number, newItems?: (T | C)[]): T[];
-    /** Convert to JSON */
-    toJSON(): T[];
-    /** Index access */
-    [index: number]: T;
-    /** Iterator */
-    [Symbol.iterator](): IterableIterator<T>;
-}
-interface IArrayType<T extends IType<unknown, unknown, unknown>> extends IType<Array<T extends IType<infer C, unknown, unknown> ? C : never>, Array<T extends IType<unknown, infer S, unknown> ? S : never>, IMSTArray<T extends IType<unknown, unknown, infer I> ? I : never, T extends IType<infer C, unknown, unknown> ? C : never>> {
-    readonly _kind: "array";
-    readonly _subType: T;
-}
-interface IMSTMap<V> extends Map<string, V> {
-    /** Put a value, returning it */
-    put(value: V): V;
-    /** Merge values into the map */
-    merge(values: Record<string, V> | Map<string, V>): this;
-    /** Replace all values */
-    replace(values: Record<string, V> | Map<string, V>): this;
-    /** Convert to JSON */
-    toJSON(): Record<string, V>;
-}
-interface IMapType<T extends IType<unknown, unknown, unknown>> extends IType<Record<string, T extends IType<infer C, unknown, unknown> ? C : never>, Record<string, T extends IType<unknown, infer S, unknown> ? S : never>, IMSTMap<T extends IType<unknown, unknown, infer I> ? I : never>> {
-    readonly _kind: "map";
-    readonly _subType: T;
-}
-interface IOptionalType<T extends IType<unknown, unknown, unknown>, Default> extends IType<(T extends IType<infer C, unknown, unknown> ? C : never) | undefined, T extends IType<unknown, infer S, unknown> ? S : never, T extends IType<unknown, unknown, infer I> ? I : never> {
-    readonly _kind: "optional";
-    readonly _subType: T;
-    readonly _defaultValue: Default | (() => Default);
-}
-interface IMaybeType<T extends IType<unknown, unknown, unknown>> extends IType<(T extends IType<infer C, unknown, unknown> ? C : never) | undefined, (T extends IType<unknown, infer S, unknown> ? S : never) | undefined, (T extends IType<unknown, unknown, infer I> ? I : never) | undefined> {
-    readonly _kind: "maybe";
-    readonly _subType: T;
-}
-interface IMaybeNullType<T extends IType<unknown, unknown, unknown>> extends IType<(T extends IType<infer C, unknown, unknown> ? C : never) | null, (T extends IType<unknown, infer S, unknown> ? S : never) | null, (T extends IType<unknown, unknown, infer I> ? I : never) | null> {
-    readonly _kind: "maybeNull";
-    readonly _subType: T;
-}
-interface IReferenceType<T extends IAnyModelType> extends IType<string | number, string | number, Instance<T>> {
-    readonly _kind: "reference";
-    readonly _targetType: T;
-}
-interface ReferenceOptions<T extends IAnyModelType> {
-    get?(identifier: string | number, parent: unknown): Instance<T> | undefined;
-    set?(value: Instance<T>, parent: unknown): string | number;
-    onInvalidated?: (event: {
-        parent: unknown;
-        invalidId: string | number;
-        replaceRef: (newRef: Instance<T> | null) => void;
-        removeRef: () => void;
-        cause: "destroy" | "invalidSnapshotReference" | "detach";
-    }) => void;
-}
-interface ISafeReferenceType<T extends IAnyModelType> extends IType<string | number | undefined, string | number | undefined, Instance<T> | undefined> {
-    readonly _kind: "safeReference";
-    readonly _targetType: T;
-}
-type UnionOptions = {
-    dispatcher?: (snapshot: unknown) => IType<unknown, unknown, unknown>;
-    eager?: boolean;
-};
-interface IUnionType<Types extends IType<unknown, unknown, unknown>[]> extends IType<Types[number] extends IType<infer C, unknown, unknown> ? C : never, Types[number] extends IType<unknown, infer S, unknown> ? S : never, Types[number] extends IType<unknown, unknown, infer T> ? T : never> {
-    readonly _kind: "union";
-    readonly _types: Types;
-}
-interface ILiteralType<T extends string | number | boolean> extends IType<T, T, T> {
-    readonly _kind: "literal";
-    readonly _value: T;
-}
-interface IEnumerationType<E extends string> extends IType<E, E, E> {
-    readonly _kind: "enumeration";
-    readonly _options: readonly E[];
-}
-interface IFrozenType<T> extends IType<T, T, T> {
-    readonly _kind: "frozen";
-}
-interface ILateType<T extends IType<unknown, unknown, unknown>> extends IType<T extends IType<infer C, unknown, unknown> ? C : never, T extends IType<unknown, infer S, unknown> ? S : never, T extends IType<unknown, unknown, infer I> ? I : never> {
-    readonly _kind: "late";
-    readonly _definition: () => T;
-}
-interface IRefinementType<T extends IType<unknown, unknown, unknown>> extends IType<T extends IType<infer C, unknown, unknown> ? C : never, T extends IType<unknown, infer S, unknown> ? S : never, T extends IType<unknown, unknown, infer I> ? I : never> {
-    readonly _kind: "refinement";
-    readonly _subType: T;
-    readonly _predicate: (value: unknown) => boolean;
-}
-interface CustomTypeOptions$1<C, S, T> {
-    name: string;
-    fromSnapshot(snapshot: S): T;
-    toSnapshot(value: T): S;
-    isTargetType(value: unknown): boolean;
-    getValidationMessage(value: unknown): string;
-}
-interface IIdentifierType extends IType<string, string, string> {
-    readonly _kind: "identifier";
-    readonly identifierAttribute: string;
-}
-interface IIdentifierNumberType extends IType<number, number, number> {
-    readonly _kind: "identifierNumber";
-    readonly identifierAttribute: string;
-}
-interface IJsonPatch {
-    op: "replace" | "add" | "remove";
-    path: string;
-    value?: unknown;
-}
-interface IReversibleJsonPatch extends IJsonPatch {
-    oldValue?: unknown;
-}
-type IAnyType = IType<unknown, unknown, unknown>;
-type IAnyModelType = IModelType<ModelProperties, object, object, object>;
-type IAnyComplexType = IAnyModelType | IArrayType<IAnyType> | IMapType<IAnyType>;
-/**
- * Extract the full "self" type from a model type.
- * This includes properties, views, actions, and volatile state.
- *
- * @example
- * const User = types.model({ name: types.string }).views(self => ({ ... }));
- * type UserSelf = ModelSelf<typeof User>; // includes name + all views
- */
-type ModelSelf<M> = M extends IModelType<infer P, infer V, infer A, infer Vol> ? ModelInstance<P, V, A, Vol> & V & A & Vol : never;
-/**
- * Configuration for creating a mixin.
- * @template RequiredProps - Properties the mixin requires from the base model
- * @template V - Views the mixin provides
- * @template A - Actions the mixin provides
- * @template Vol - Volatile state the mixin provides
- */
-interface MixinConfig<RequiredProps extends ModelProperties, V extends object = object, A extends object = object, Vol extends object = object> {
-    /** Properties the mixin requires from any model it's applied to */
-    requires?: RequiredProps;
-    /** Views to add to the model */
-    views?: (self: ModelInstanceType<RequiredProps>) => V;
-    /** Actions to add to the model */
-    actions?: (self: ModelInstanceType<RequiredProps> & V) => A;
-    /** Volatile state to add to the model */
-    volatile?: (self: ModelInstanceType<RequiredProps> & V & A) => Vol;
-}
-/**
- * A mixin that can be applied to models to add views, actions, and volatile state.
- * Mixins declare what properties they require and what they provide.
- *
- * @template RequiredProps - Properties the mixin requires
- * @template V - Views the mixin provides
- * @template A - Actions the mixin provides
- * @template Vol - Volatile state the mixin provides
- */
-interface IMixin<RequiredProps extends ModelProperties, V extends object = object, A extends object = object, Vol extends object = object> {
-    readonly _kind: "mixin";
-    /** Properties the mixin requires from the base model */
-    readonly requires: RequiredProps;
-    /** Function to create views */
-    readonly views?: (self: ModelInstanceType<RequiredProps>) => V;
-    /** Function to create actions */
-    readonly actions?: (self: ModelInstanceType<RequiredProps> & V) => A;
-    /** Function to create volatile state */
-    readonly volatile?: (self: ModelInstanceType<RequiredProps> & V & A) => Vol;
-    /** Phantom types for inference */
-    readonly _V: V;
-    readonly _A: A;
-    readonly _Vol: Vol;
-}
-/** Any mixin type */
-type IAnyMixin = IMixin<ModelProperties, object, object, object>;
-interface IDisposer {
-    (): void;
-}
+import { I as ISimpleType, a as IType, b as IIdentifierType, c as IIdentifierNumberType, d as ILiteralType, e as IEnumerationType, f as IFrozenType, M as ModelProperties, g as IModelType, h as MixinConfig, i as IMixin, j as IAnyType, k as IArrayType, l as IMapType, m as IOptionalType, n as IMaybeType, o as IMaybeNullType, p as IUnionType, U as UnionOptions, q as ILateType, r as IAnyModelType, R as ReferenceOptions, s as IReferenceType, t as ISafeReferenceType, u as IRefinementType, v as IDisposer, S as SnapshotIn, w as Instance, x as IReversibleJsonPatch } from './tree-CDmXgtM5.mjs';
+export { L as CustomTypeOptions, D as IAnyComplexType, E as IAnyMixin, G as IJsonPatch, z as IMSTArray, A as IMSTMap, y as IStateTreeNode, H as IValidationContext, K as IValidationError, J as IValidationResult, B as ModelInstance, F as ModelSelf, C as SnapshotOut, T as applyPatch, O as applySnapshot, aw as cleanupStaleEntries, ax as clearAllRegistries, aa as clone, aq as cloneDeep, a8 as destroy, a9 as detach, am as findAll, an as findFirst, as as freeze, a2 as getEnv, ag as getGlobalStore, a4 as getIdentifier, af as getMembers, ar as getOrCreatePath, Y as getParent, $ as getParentOfType, a0 as getPath, a1 as getPathParts, av as getRegistryStats, aj as getRelativePath, X as getRoot, N as getSnapshot, ap as getTreeStats, a3 as getType, _ as hasParent, al as haveSameRoot, a5 as isAlive, ak as isAncestor, at as isFrozen, a6 as isRoot, a7 as isStateTreeNode, ao as isValidReference, W as onAction, ay as onLifecycleChange, Q as onPatch, P as onSnapshot, V as recordPatches, ai as resetGlobalStore, ae as resolveIdentifier, ac as resolvePath, ah as setGlobalStore, Z as tryGetParent, ad as tryResolve, au as unfreeze, ab as walk } from './tree-CDmXgtM5.mjs';
+import 'jotai/vanilla/internals';
+import 'jotai';
 
 /**
  * Primitive types implementation
@@ -648,193 +337,6 @@ declare function dynamicReference<T extends IAnyType = IAnyType>(modelName: stri
  */
 declare function safeDynamicReference<T extends IAnyType = IAnyType>(modelName: string, options?: DynamicReferenceOptions<T>): IType<string | number | undefined, string | number | undefined, (T extends IType<unknown, unknown, infer I> ? I : unknown) | undefined>;
 
-/** Get the global store */
-declare function getGlobalStore(): jotai_vanilla_internals.INTERNAL_Store;
-/** Set a custom global store (useful for testing) */
-declare function setGlobalStore(store: ReturnType<typeof createStore>): void;
-/** Reset the global store (useful for testing) */
-declare function resetGlobalStore(): void;
-/** Subscribe to lifecycle changes of a node */
-declare function onLifecycleChange(node: StateTreeNode, listener: (isAlive: boolean) => void): IDisposer;
-declare class StateTreeNode implements IStateTreeNode {
-    readonly $id: string;
-    readonly $type: IAnyType;
-    $parent: StateTreeNode | null;
-    $path: string;
-    $env: unknown;
-    $isAlive: boolean;
-    /** Child nodes - uses Map but children are explicitly destroyed */
-    private children;
-    /** Atom storing the raw value/snapshot */
-    valueAtom: WritableAtom<unknown, [unknown], void>;
-    /** Snapshot listeners */
-    private snapshotListeners;
-    /** Patch listeners */
-    private patchListeners;
-    /** Volatile state (non-serialized) */
-    volatileState: Record<string, unknown>;
-    /** Pre/post process snapshot functions */
-    preProcessor?: (snapshot: unknown) => unknown;
-    postProcessor?: (snapshot: unknown) => unknown;
-    /** Identifier value if this node has one */
-    identifierValue?: string | number;
-    /** Type name for identifier registry */
-    identifierTypeName?: string;
-    constructor(type: IAnyType, initialValue: unknown, env?: unknown, parent?: StateTreeNode, pathSegment?: string);
-    /** Set the instance reference */
-    setInstance(instance: unknown): void;
-    /** Get the instance */
-    getInstance(): unknown;
-    /** Get current value from atom */
-    getValue(): unknown;
-    /** Set value on atom */
-    setValue(value: unknown): void;
-    /** Add a child node */
-    addChild(key: string, child: StateTreeNode): void;
-    /** Recursively update the path of a node and all its children */
-    private updatePathRecursively;
-    /** Remove a child node */
-    removeChild(key: string): void;
-    /** Get a child node */
-    getChild(key: string): StateTreeNode | undefined;
-    /** Get all children */
-    getChildren(): Map<string, StateTreeNode>;
-    /** Register identifier */
-    registerIdentifier(typeName: string, identifier: string | number): void;
-    /** Unregister identifier */
-    unregisterIdentifier(): void;
-    /** Subscribe to snapshot changes */
-    onSnapshot(listener: (snapshot: unknown) => void): IDisposer;
-    /** Subscribe to patches */
-    onPatch(listener: (patch: IJsonPatch, reversePatch: IReversibleJsonPatch) => void): IDisposer;
-    /** Notify patch listeners */
-    private notifyPatch;
-    /** Notify snapshot listeners */
-    private notifySnapshotChange;
-    /** Notify about a property change (for use by model proxy) */
-    notifyPropertyChange(propName: string, newValue: unknown, oldValue: unknown): void;
-    /** Notify about a volatile state change (triggers snapshot listeners without patches) */
-    notifyVolatileChange(): void;
-    /** Get root node */
-    getRoot(): StateTreeNode;
-    /** Destroy this node and all children */
-    destroy(): void;
-    /** Detach from parent */
-    detach(): void;
-}
-/** Look up a node by identifier */
-declare function resolveIdentifier(typeName: string, identifier: string | number): StateTreeNode | undefined;
-/** Get statistics about the registries - useful for debugging memory issues */
-declare function getRegistryStats(): {
-    nodeRegistrySize: number;
-    identifierRegistrySize: number;
-    identifierTypeCount: number;
-    liveNodeCount: number;
-    staleNodeCount: number;
-};
-/** Clean up stale entries from registries - call periodically if needed */
-declare function cleanupStaleEntries(): number;
-/** Clear all registries - useful for testing */
-declare function clearAllRegistries(): void;
-/** Get the root of the tree */
-declare function getRoot<T>(target: T): T;
-/** Get the parent of a node */
-declare function getParent<T = unknown>(target: unknown, depth?: number): T;
-/** Try to get the parent, returns undefined if at root */
-declare function tryGetParent<T = unknown>(target: unknown, depth?: number): T | undefined;
-/** Check if a node has a parent */
-declare function hasParent(target: unknown, depth?: number): boolean;
-/** Get parent of specific type */
-declare function getParentOfType<T extends IAnyModelType>(target: unknown, type: T): T extends IType<unknown, unknown, infer I> ? I : never;
-/** Get the path of a node */
-declare function getPath(target: unknown): string;
-/** Get path parts as array */
-declare function getPathParts(target: unknown): string[];
-/** Get the environment */
-declare function getEnv<E = unknown>(target: unknown): E;
-/** Check if node is alive */
-declare function isAlive(target: unknown): boolean;
-/** Check if node is root */
-declare function isRoot(target: unknown): boolean;
-/** Get the type of a node */
-declare function getType(target: unknown): IAnyType;
-/** Check if value is a state tree node */
-declare function isStateTreeNode(value: unknown): boolean;
-/** Get identifier of a node */
-declare function getIdentifier(target: unknown): string | number | null;
-/** Destroy a node */
-declare function destroy(target: unknown): void;
-/** Detach a node from its parent */
-declare function detach<T>(target: T): T;
-/** Clone a node */
-declare function clone<T>(target: T, keepEnvironment?: boolean): T;
-/** Get snapshot from an instance */
-declare function getSnapshot<S>(target: unknown): S;
-/** Apply snapshot to an instance */
-declare function applySnapshot<S>(target: unknown, snapshot: S): void;
-/** Subscribe to snapshots */
-declare function onSnapshot<S>(target: unknown, listener: (snapshot: S) => void): IDisposer;
-/** Subscribe to patches */
-declare function onPatch(target: unknown, listener: (patch: IJsonPatch, reversePatch: IReversibleJsonPatch) => void): IDisposer;
-/** Apply a single patch */
-declare function applyPatch(target: unknown, patch: IJsonPatch | IJsonPatch[]): void;
-/** Record patches during a function execution */
-declare function recordPatches(target: unknown): {
-    patches: IJsonPatch[];
-    inversePatches: IReversibleJsonPatch[];
-    stop: () => void;
-    resume: () => void;
-    replay: (target: unknown) => void;
-    undo: (target: unknown) => void;
-};
-interface ActionCall {
-    name: string;
-    path: string;
-    args: unknown[];
-}
-/** Subscribe to action calls */
-declare function onAction(target: unknown, listener: (call: ActionCall) => void): IDisposer;
-/** Walk the tree */
-declare function walk(target: unknown, visitor: (node: unknown) => void): void;
-/** Get all members (properties) of a node */
-declare function getMembers(target: unknown): {
-    name: string;
-    type: "view" | "action" | "property" | "volatile";
-    value: unknown;
-}[];
-/** Resolve a path to a node */
-declare function resolvePath(target: unknown, path: string): unknown;
-/** Try to resolve a path */
-declare function tryResolve(target: unknown, path: string): unknown | undefined;
-/** Get the relative path from one node to another */
-declare function getRelativePath(from: unknown, to: unknown): string;
-/** Check if a node is an ancestor of another */
-declare function isAncestor(ancestor: unknown, descendant: unknown): boolean;
-/** Check if two nodes share a common root */
-declare function haveSameRoot(a: unknown, b: unknown): boolean;
-/** Get all nodes of a specific type in the tree */
-declare function findAll<T>(target: unknown, predicate: (node: unknown) => node is T): T[];
-/** Get the first node matching a predicate */
-declare function findFirst<T>(target: unknown, predicate: (node: unknown) => node is T): T | undefined;
-/** Check if a value is a valid reference target */
-declare function isValidReference(target: unknown, identifier: string | number): boolean;
-/** Get statistics about the tree */
-declare function getTreeStats(target: unknown): {
-    nodeCount: number;
-    depth: number;
-    types: Record<string, number>;
-};
-/** Create a deep observable copy of a tree */
-declare function cloneDeep<T>(target: T): T;
-/** Get or create a node by path */
-declare function getOrCreatePath(target: unknown, path: string, creator: () => unknown): unknown;
-/** Freeze a node, making it read-only */
-declare function freeze(target: unknown): void;
-/** Check if a node is frozen */
-declare function isFrozen(target: unknown): boolean;
-/** Unfreeze a node */
-declare function unfreeze(target: unknown): void;
-
 /**
  * Lifecycle hooks and middleware system
  * Implements afterCreate, beforeDestroy, afterAttach, beforeDetach, etc.
@@ -1209,4 +711,4 @@ declare function typecheck<T>(type: {
     is(v: unknown): v is T;
 }, value: unknown): void;
 
-export { type CustomTypeOptions$1 as CustomTypeOptions, DatePrimitive as Date, type DynamicReferenceOptions, type IActionRecorder, type IActionRecording, type IAnyComplexType, type IAnyMixin, type IAnyModelType, type IAnyType, type IArrayType, type IDisposer, type IEnumerationType, type IFrozenType, type IHistoryEntry, type IIdentifierNumberType, type IIdentifierType, type IJsonPatch, type ILateType, type ILiteralType, type IMSTArray, type IMSTMap, type IMapType, type IMaybeNullType, type IMaybeType, type IMiddlewareEvent, type IMiddlewareHandler, type IMixin, type IModelType, type IOptionalType, type IReferenceType, type IRefinementType, type IReversibleJsonPatch, type ISafeReferenceType, type ISerializedActionCall, type ISimpleType, type IStateTreeNode, type ITimeTravelManager, type IType, type IUndoManager, type IUndoManagerOptions, type IUnionType, type IValidationContext, type IValidationError, type IValidationResult, type Instance, type MixinConfig, type ModelInstance, type ModelProperties, type ModelSelf, type ReferenceOptions, type SnapshotIn, type SnapshotOut, type UnionOptions, addMiddleware, applyAction, applyPatch, applySnapshot, array, boolean, cast, castToReferenceSnapshot, castToSnapshot, cleanupStaleEntries, clearAllRegistries, clearModelRegistry, clone, cloneDeep, cloneFrozen, compose, createActionRecorder, createTimeTravelManager, createUndoManager, createWithDefaults, custom, types as default, destroy, detach, dynamicReference, enumeration, escapeJsonPath, findAll, findFirst, finite, float, flow, freeze, frozen, getDebugInfo, getEnv, getGlobalStore, getIdentifier, getIdentifierAttribute, getMembers, getModelMetadata, getOrCreate, getOrCreatePath, getParent, getParentOfType, getPath, getPathParts, getRegisteredModelNames, getRegistryStats, getRelativePath, getRoot, getSnapshot, getTreeStats, getType, getTypeName, getValidationError, hasIdentifier, hasParent, haveSameRoot, identifier, identifierNumber, integer, isAlive, isAncestor, isArrayType, isFrozen, isFrozenType, isIdentifierType, isInstanceOf, isLateType, isLiteralType, isMapType, isModelRegistered, isModelType, isOptionalType, isPrimitiveType, isProtected, isReferenceType, isRoot, isStateTreeNode, isType, isUnionType, isValidReference, isValidSnapshot, joinJsonPath, late, lateModel, literal, map, maybe, maybeNull, mixin, model, nullType, nullable, number, onAction, onLifecycleChange, onModelRegistered, onPatch, onSnapshot, optional, printTree, protect, recordActions, recordPatches, reference, refinement, registerModel, resetGlobalStore, resolveIdentifier, resolveModel, resolveModelAsync, resolvePath, safeCreate, safeDynamicReference, safeReference, setGlobalStore, snapshotProcessor, splitJsonPath, string, tryGetParent, tryResolve, tryResolveModel, typecheck, types, undefinedType, unescapeJsonPath, unfreeze, union, unprotect, unregisterModel, walk };
+export { DatePrimitive as Date, type DynamicReferenceOptions, type IActionRecorder, type IActionRecording, IAnyModelType, IAnyType, IArrayType, IDisposer, IEnumerationType, IFrozenType, type IHistoryEntry, IIdentifierNumberType, IIdentifierType, ILateType, ILiteralType, IMapType, IMaybeNullType, IMaybeType, type IMiddlewareEvent, type IMiddlewareHandler, IMixin, IModelType, IOptionalType, IReferenceType, IRefinementType, IReversibleJsonPatch, ISafeReferenceType, type ISerializedActionCall, ISimpleType, type ITimeTravelManager, IType, type IUndoManager, type IUndoManagerOptions, IUnionType, Instance, MixinConfig, ModelProperties, ReferenceOptions, SnapshotIn, UnionOptions, addMiddleware, applyAction, array, boolean, cast, castToReferenceSnapshot, castToSnapshot, clearModelRegistry, cloneFrozen, compose, createActionRecorder, createTimeTravelManager, createUndoManager, createWithDefaults, custom, types as default, dynamicReference, enumeration, escapeJsonPath, finite, float, flow, frozen, getDebugInfo, getIdentifierAttribute, getModelMetadata, getOrCreate, getRegisteredModelNames, getTypeName, getValidationError, hasIdentifier, identifier, identifierNumber, integer, isArrayType, isFrozenType, isIdentifierType, isInstanceOf, isLateType, isLiteralType, isMapType, isModelRegistered, isModelType, isOptionalType, isPrimitiveType, isProtected, isReferenceType, isType, isUnionType, isValidSnapshot, joinJsonPath, late, lateModel, literal, map, maybe, maybeNull, mixin, model, nullType, nullable, number, onModelRegistered, optional, printTree, protect, recordActions, reference, refinement, registerModel, resolveModel, resolveModelAsync, safeCreate, safeDynamicReference, safeReference, snapshotProcessor, splitJsonPath, string, tryResolveModel, typecheck, types, undefinedType, unescapeJsonPath, union, unprotect, unregisterModel };