jotai-state-tree 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,1109 @@
+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>;
+}
+/**
+ * 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>;
+interface IDisposer {
+    (): void;
+}
+
+/**
+ * Primitive types implementation
+ * string, number, boolean, integer, Date, identifier, etc.
+ */
+
+/** String type */
+declare const string: ISimpleType<string>;
+/** Number type (includes floats) */
+declare const number: ISimpleType<number>;
+/** Integer type */
+declare const integer: ISimpleType<number>;
+/** Boolean type */
+declare const boolean: ISimpleType<boolean>;
+/** Date type - stores as number, exposes as Date */
+declare const DatePrimitive: IType<number | Date, number, Date>;
+/** Null type */
+declare const nullType: ISimpleType<null>;
+/** Undefined type */
+declare const undefinedType: ISimpleType<undefined>;
+/** String identifier type */
+declare const identifier: IIdentifierType;
+/** Number identifier type */
+declare const identifierNumber: IIdentifierNumberType;
+declare function literal<T extends string | number | boolean>(value: T): ILiteralType<T>;
+declare function enumeration<E extends string>(name: string, options: readonly E[]): IEnumerationType<E>;
+declare function enumeration<E extends string>(options: readonly E[]): IEnumerationType<E>;
+declare function frozen<T = unknown>(): IFrozenType<T>;
+declare function frozen<T>(defaultValue: T): IFrozenType<T>;
+interface CustomTypeOptions<C, S, T> {
+    name: string;
+    fromSnapshot(snapshot: S): T;
+    toSnapshot(value: T): S;
+    isTargetType(value: unknown): value is T;
+    getValidationMessage(value: unknown): string;
+}
+declare function custom<C, S, T>(options: CustomTypeOptions<C, S, T>): IType<C, S, T>;
+/** Finite number type (excludes Infinity and -Infinity) */
+declare const finite: ISimpleType<number>;
+/** Float type (alias for number) */
+declare const float: ISimpleType<number>;
+
+/**
+ * Model type implementation
+ * This is the core of jotai-state-tree
+ *
+ * MEMORY MANAGEMENT:
+ * - View and action caches are bounded with LRU eviction
+ * - Caches are instance-scoped, so they're GC'd with the instance
+ * - No global caches that could accumulate entries
+ */
+
+declare function model<P extends ModelProperties>(name: string, properties: P): IModelType<P, object, object, object>;
+declare function model<P extends ModelProperties>(properties: P): IModelType<P, object, object, object>;
+declare function compose<PA extends ModelProperties, PB extends ModelProperties, VA extends object, VB extends object, AA extends object, AB extends object, VolA extends object, VolB extends object>(name: string, a: IModelType<PA, VA, AA, VolA>, b: IModelType<PB, VB, AB, VolB>): IModelType<PA & PB, VA & VB, AA & AB, VolA & VolB>;
+declare function compose<PA extends ModelProperties, PB extends ModelProperties, VA extends object, VB extends object, AA extends object, AB extends object, VolA extends object, VolB extends object>(a: IModelType<PA, VA, AA, VolA>, b: IModelType<PB, VB, AB, VolB>): IModelType<PA & PB, VA & VB, AA & AB, VolA & VolB>;
+
+/**
+ * Array type implementation
+ */
+
+declare function array<T extends IAnyType>(itemType: T): IArrayType<T>;
+
+/**
+ * Map type implementation
+ */
+
+declare function map<T extends IAnyType>(valueType: T): IMapType<T>;
+
+/**
+ * Utility types implementation
+ * optional, maybe, maybeNull, union, late, refinement, reference, safeReference
+ */
+
+declare function optional<T extends IAnyType, D extends T extends IType<infer C, unknown, unknown> ? C : never>(type: T, defaultValue: D | (() => D)): IOptionalType<T, D>;
+declare function maybe<T extends IAnyType>(type: T): IMaybeType<T>;
+declare function maybeNull<T extends IAnyType>(type: T): IMaybeNullType<T>;
+declare function union<Types extends IAnyType[]>(...types: Types): IUnionType<Types>;
+declare function union<Types extends IAnyType[]>(options: UnionOptions, ...types: Types): IUnionType<Types>;
+declare function late<T extends IAnyType>(definition: () => T): ILateType<T>;
+declare function late<T extends IAnyType>(name: string, definition: () => T): ILateType<T>;
+declare function refinement<T extends IAnyType>(type: T, predicate: (value: T extends IType<unknown, unknown, infer I> ? I : never) => boolean, message?: string | ((value: unknown) => string)): IRefinementType<T>;
+declare function reference<T extends IAnyModelType>(targetType: T, options?: ReferenceOptions<T>): IReferenceType<T>;
+declare function safeReference<T extends IAnyModelType>(targetType: T, options?: ReferenceOptions<T> & {
+    acceptsUndefined?: boolean;
+}): ISafeReferenceType<T>;
+declare function snapshotProcessor<IT extends IAnyType, CustomC = IT extends IType<infer C, unknown, unknown> ? C : never, CustomS = IT extends IType<unknown, infer S, unknown> ? S : never>(type: IT, processors: {
+    preProcessor?: (snapshot: CustomC) => IT extends IType<infer C, unknown, unknown> ? C : never;
+    postProcessor?: (snapshot: IT extends IType<unknown, infer S, unknown> ? S : never) => CustomS;
+}): IType<CustomC, CustomS, IT extends IType<unknown, unknown, infer T> ? T : never>;
+
+/**
+ * Model Registry for Dynamic Model Registration
+ *
+ * Enables plugin architectures, code splitting, and lazy loading of models.
+ * Models can be registered at runtime and resolved dynamically.
+ *
+ * @example
+ * // In a plugin or lazy-loaded module:
+ * registerModel("UserProfile", UserProfileModel);
+ *
+ * // In main app, before plugin loads:
+ * const LazyUserProfile = types.lateModel("UserProfile");
+ *
+ * // Reference that resolves dynamically:
+ * const ref = types.dynamicReference("UserProfile", userId);
+ */
+
+/**
+ * Register a model type with a name for dynamic resolution.
+ *
+ * @param name - Unique name for the model
+ * @param type - The model type to register
+ * @param metadata - Optional metadata to associate with the model
+ * @throws Error if a model with the same name is already registered
+ *
+ * @example
+ * const UserModel = types.model("User", { id: types.identifier, name: types.string });
+ * registerModel("User", UserModel);
+ *
+ * // Later, in a plugin:
+ * registerModel("UserProfile", types.model("UserProfile", {
+ *   user: types.reference(resolveModel("User")),
+ *   bio: types.string
+ * }));
+ */
+declare function registerModel(name: string, type: IAnyType, metadata?: Record<string, unknown>): void;
+/**
+ * Unregister a model type.
+ *
+ * @param name - Name of the model to unregister
+ * @returns true if the model was unregistered, false if it wasn't registered
+ *
+ * @example
+ * unregisterModel("UserProfile");
+ */
+declare function unregisterModel(name: string): boolean;
+/**
+ * Check if a model is registered.
+ *
+ * @param name - Name of the model to check
+ * @returns true if the model is registered
+ */
+declare function isModelRegistered(name: string): boolean;
+/**
+ * Resolve a model type by name (synchronous).
+ *
+ * @param name - Name of the model to resolve
+ * @returns The registered model type
+ * @throws Error if the model is not registered
+ *
+ * @example
+ * const UserModel = resolveModel("User");
+ * const instance = UserModel.create({ id: "1", name: "John" });
+ */
+declare function resolveModel<T extends IAnyType = IAnyType>(name: string): T;
+/**
+ * Try to resolve a model type by name (returns undefined if not registered).
+ *
+ * @param name - Name of the model to resolve
+ * @returns The registered model type or undefined
+ *
+ * @example
+ * const UserModel = tryResolveModel("User");
+ * if (UserModel) {
+ *   const instance = UserModel.create({ id: "1", name: "John" });
+ * }
+ */
+declare function tryResolveModel<T extends IAnyType = IAnyType>(name: string): T | undefined;
+/**
+ * Resolve a model type by name (asynchronous).
+ * Waits for the model to be registered if it isn't already.
+ *
+ * @param name - Name of the model to resolve
+ * @param timeout - Optional timeout in milliseconds (default: 30000)
+ * @returns Promise that resolves to the model type
+ * @throws Error if timeout is reached
+ *
+ * @example
+ * // Wait for a plugin to register its model
+ * const UserProfileModel = await resolveModelAsync("UserProfile");
+ */
+declare function resolveModelAsync<T extends IAnyType = IAnyType>(name: string, timeout?: number): Promise<T>;
+/**
+ * Get metadata for a registered model.
+ *
+ * @param name - Name of the model
+ * @returns The metadata or undefined
+ */
+declare function getModelMetadata(name: string): Record<string, unknown> | undefined;
+/**
+ * Get all registered model names.
+ *
+ * @returns Array of registered model names
+ */
+declare function getRegisteredModelNames(): string[];
+/**
+ * Listen for model registration events.
+ *
+ * @param listener - Callback invoked when a model is registered
+ * @returns Disposer function to remove the listener
+ *
+ * @example
+ * const disposer = onModelRegistered((name, type) => {
+ *   console.log(`Model ${name} was registered`);
+ * });
+ * // Later:
+ * disposer();
+ */
+declare function onModelRegistered(listener: (name: string, type: IAnyType) => void): () => void;
+/**
+ * Clear all registered models.
+ * Primarily useful for testing.
+ */
+declare function clearModelRegistry(): void;
+/**
+ * Create a late-resolving type that looks up the model from the registry.
+ * This allows you to reference models that may not be registered yet.
+ *
+ * @param modelName - Name of the model in the registry
+ * @returns A type that resolves from the registry when used
+ *
+ * @example
+ * // Define a type that references a model not yet registered
+ * const PostStore = types.model("PostStore", {
+ *   posts: types.array(types.lateModel("Post")),
+ *   author: types.reference(types.lateModel("User"))
+ * });
+ *
+ * // Later, register the models (e.g., from a plugin)
+ * registerModel("Post", PostModel);
+ * registerModel("User", UserModel);
+ *
+ * // Now PostStore.create() will work
+ */
+declare function lateModel<T extends IAnyType = IAnyType>(modelName: string): IType<T extends IType<infer C, unknown, unknown> ? C : unknown, T extends IType<unknown, infer S, unknown> ? S : unknown, T extends IType<unknown, unknown, infer I> ? I : unknown>;
+/** Options for dynamic references */
+interface DynamicReferenceOptions<T extends IAnyType> {
+    /**
+     * Custom getter to resolve the reference.
+     * If not provided, uses the default identifier-based resolution.
+     *
+     * @param identifier - The stored identifier value
+     * @param parent - The parent node containing the reference
+     * @returns The resolved instance or undefined
+     */
+    get?: (identifier: string | number, parent: unknown) => (T extends IType<unknown, unknown, infer I> ? I : unknown) | undefined;
+    /**
+     * Custom setter to extract the identifier from a value.
+     * If not provided, uses the identifier property of the value.
+     *
+     * @param value - The value being set
+     * @param parent - The parent node containing the reference
+     * @returns The identifier to store
+     */
+    set?: (value: T extends IType<unknown, unknown, infer I> ? I : unknown, parent: unknown) => string | number;
+    /**
+     * Called when resolution fails.
+     * Can return a fallback value or throw an error.
+     */
+    onInvalidated?: (identifier: string | number, parent: unknown) => (T extends IType<unknown, unknown, infer I> ? I : unknown) | undefined;
+}
+/**
+ * Create a dynamic reference that resolves from the model registry.
+ * Supports custom get/set resolvers for advanced use cases like API fetching.
+ *
+ * @param modelName - Name of the model in the registry
+ * @param options - Optional custom resolution options
+ * @returns A reference type
+ *
+ * @example
+ * // Basic usage - resolves from registry
+ * const PostStore = types.model("PostStore", {
+ *   author: types.dynamicReference("User")
+ * });
+ *
+ * // With custom resolver (e.g., API fetching)
+ * const PostStore = types.model("PostStore", {
+ *   author: types.dynamicReference("User", {
+ *     get(id, parent) {
+ *       return userCache.get(id) ?? fetchUserSync(id);
+ *     },
+ *     set(user) {
+ *       return user.id;
+ *     },
+ *     onInvalidated(id) {
+ *       console.warn(`User ${id} not found`);
+ *       return undefined;
+ *     }
+ *   })
+ * });
+ */
+declare function dynamicReference<T extends IAnyType = IAnyType>(modelName: string, options?: DynamicReferenceOptions<T>): IType<string | number, string | number, T extends IType<unknown, unknown, infer I> ? I : unknown>;
+/**
+ * Create a safe dynamic reference that returns undefined instead of throwing.
+ *
+ * @param modelName - Name of the model in the registry
+ * @param options - Optional custom resolution options
+ * @returns A safe reference type
+ */
+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;
+    /** 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.
+ *
+ * MEMORY MANAGEMENT:
+ * - Uses WeakMap for all node-keyed registries to allow GC
+ * - Action recorders are stored in WeakMap to prevent memory leaks
+ * - All registries automatically clean up when nodes are garbage collected
+ */
+
+interface IMiddlewareEvent {
+    type: "action" | "flow_spawn" | "flow_resume" | "flow_resume_error" | "flow_return" | "flow_throw";
+    name: string;
+    id: number;
+    parentId: number;
+    rootId: number;
+    context: unknown;
+    tree: unknown;
+    args: unknown[];
+    parentEvent?: IMiddlewareEvent;
+}
+interface IMiddlewareHandler {
+    (call: IMiddlewareEvent, next: (call: IMiddlewareEvent, callback?: (value: unknown) => unknown) => unknown, abort: (value: unknown) => unknown): unknown;
+}
+/**
+ * Add middleware to the global stack
+ */
+declare function addMiddleware(target: unknown, handler: IMiddlewareHandler, includeHooks?: boolean): IDisposer;
+interface ISerializedActionCall {
+    name: string;
+    path: string;
+    args: unknown[];
+}
+/**
+ * Record all actions on a subtree
+ *
+ * MEMORY SAFETY: Uses WeakMap so nodes can be garbage collected
+ * even while recording is active. The stop() function properly
+ * cleans up the recorder from the Set.
+ */
+declare function recordActions(target: unknown): {
+    actions: ISerializedActionCall[];
+    stop: () => void;
+    replay: (target: unknown) => void;
+};
+/**
+ * Protect a node from direct mutations outside of actions
+ */
+declare function protect(target: unknown): void;
+/**
+ * Unprotect a node to allow direct mutations
+ */
+declare function unprotect(target: unknown): void;
+/**
+ * Check if a node is protected
+ */
+declare function isProtected(target: unknown): boolean;
+/**
+ * Apply an action call to a target
+ */
+declare function applyAction(target: unknown, action: ISerializedActionCall): unknown;
+/**
+ * Escape a JSON pointer segment
+ */
+declare function escapeJsonPath(path: string): string;
+/**
+ * Unescape a JSON pointer segment
+ */
+declare function unescapeJsonPath(path: string): string;
+/**
+ * Split a path into segments
+ */
+declare function splitJsonPath(path: string): string[];
+/**
+ * Join path segments
+ */
+declare function joinJsonPath(parts: string[]): string;
+
+/**
+ * Additional MST compatibility utilities
+ * These utilities help with edge cases and compatibility
+ */
+
+/**
+ * Check if the given value looks like a type (has the type interface)
+ */
+declare function isType(value: unknown): value is IAnyType;
+/**
+ * Check if a value is a primitive type
+ */
+declare function isPrimitiveType(type: unknown): boolean;
+/**
+ * Get the string name of a type
+ */
+declare function getTypeName(type: IAnyType): string;
+/**
+ * Check if value could be a valid snapshot for the given type
+ */
+declare function isValidSnapshot<T extends IAnyType>(type: T, value: unknown): value is SnapshotIn<T>;
+/**
+ * Get a human-readable validation error message
+ */
+declare function getValidationError(type: IAnyType, value: unknown): string | null;
+/**
+ * Check if value is an instance of a specific model type
+ */
+declare function isInstanceOf<T extends IAnyModelType>(value: unknown, type: T): value is Instance<T>;
+/**
+ * Get the live instance from a snapshot, or create one if needed
+ */
+declare function getOrCreate<T extends IAnyType>(type: T, snapshotOrInstance: SnapshotIn<T> | Instance<T>, env?: unknown): Instance<T>;
+/**
+ * Get a debug-friendly representation of a state tree node
+ */
+declare function getDebugInfo(target: unknown): {
+    typeName: string;
+    path: string;
+    identifier: string | number | null;
+    isAlive: boolean;
+    snapshot: unknown;
+};
+/**
+ * Print a tree structure for debugging
+ */
+declare function printTree(target: unknown, indent?: number): string;
+/**
+ * Check if a model type has an identifier
+ */
+declare function hasIdentifier(type: IAnyModelType): boolean;
+/**
+ * Get the identifier attribute name for a model type
+ */
+declare function getIdentifierAttribute(type: IAnyModelType): string | undefined;
+/**
+ * Create a type that is a union of all provided types
+ * but where null/undefined are always valid
+ */
+declare function nullable<T extends IAnyType>(type: T): IType<(T extends IType<infer C, unknown, unknown> ? C : never) | null | undefined, (T extends IType<unknown, infer S, unknown> ? S : never) | null | undefined, (T extends IType<unknown, unknown, infer I> ? I : never) | null | undefined>;
+/**
+ * Deep clone a frozen value
+ */
+declare function cloneFrozen<T>(value: T): T;
+/**
+ * Safely create an instance, returning undefined on failure
+ */
+declare function safeCreate<T extends IAnyType>(type: T, snapshot: unknown, env?: unknown): Instance<T> | undefined;
+/**
+ * Create an instance with defaults for missing values
+ */
+declare function createWithDefaults<T extends IAnyType>(type: T, snapshot?: Partial<SnapshotIn<T>>, env?: unknown): Instance<T>;
+
+/**
+ * Undo/Redo Manager for jotai-state-tree
+ * Provides time-travel debugging capabilities
+ */
+
+interface IUndoManagerOptions {
+    /** Maximum number of history entries to keep */
+    maxHistoryLength?: number;
+    /** Whether to group rapid changes together */
+    groupByTime?: boolean;
+    /** Time window for grouping changes (ms) */
+    groupingWindow?: number;
+}
+interface IHistoryEntry {
+    /** Patches to apply to undo this entry */
+    patches: IReversibleJsonPatch[];
+    /** Patches to apply to redo this entry */
+    inversePatches: IReversibleJsonPatch[];
+    /** Timestamp when this entry was created */
+    timestamp: number;
+}
+interface IUndoManager {
+    /** Whether there are entries that can be undone */
+    readonly canUndo: boolean;
+    /** Whether there are entries that can be redone */
+    readonly canRedo: boolean;
+    /** Number of undo entries available */
+    readonly undoLevels: number;
+    /** Number of redo entries available */
+    readonly redoLevels: number;
+    /** The full history */
+    readonly history: IHistoryEntry[];
+    /** Current position in history */
+    readonly historyIndex: number;
+    /** Undo the last change */
+    undo(): void;
+    /** Redo the last undone change */
+    redo(): void;
+    /** Clear all history */
+    clear(): void;
+    /** Start grouping changes */
+    startGroup(): void;
+    /** End grouping changes */
+    endGroup(): void;
+    /** Execute a function without recording history */
+    withoutUndo<T>(fn: () => T): T;
+    /** Stop tracking changes */
+    dispose(): void;
+}
+/**
+ * Create an undo manager for a state tree
+ */
+declare function createUndoManager(target: unknown, options?: IUndoManagerOptions): IUndoManager;
+interface ITimeTravelManager {
+    /** Current snapshot index */
+    readonly currentIndex: number;
+    /** Total number of snapshots */
+    readonly snapshotCount: number;
+    /** Whether we can go back */
+    readonly canGoBack: boolean;
+    /** Whether we can go forward */
+    readonly canGoForward: boolean;
+    /** Record the current snapshot */
+    record(): void;
+    /** Go back to previous snapshot */
+    goBack(): void;
+    /** Go forward to next snapshot */
+    goForward(): void;
+    /** Go to a specific snapshot index */
+    goTo(index: number): void;
+    /** Get snapshot at index */
+    getSnapshot(index: number): unknown;
+    /** Clear all snapshots */
+    clear(): void;
+    /** Dispose and clean up */
+    dispose(): void;
+}
+/**
+ * Create a time travel manager for snapshot-based history
+ */
+declare function createTimeTravelManager(target: unknown, options?: {
+    maxSnapshots?: number;
+    autoRecord?: boolean;
+}): ITimeTravelManager;
+interface IActionRecording {
+    /** Name of the action */
+    name: string;
+    /** Path to the node where action was called */
+    path: string;
+    /** Arguments passed to the action */
+    args: unknown[];
+    /** Timestamp */
+    timestamp: number;
+}
+interface IActionRecorder {
+    /** Whether currently recording */
+    readonly isRecording: boolean;
+    /** All recorded actions */
+    readonly actions: IActionRecording[];
+    /** Start recording */
+    start(): void;
+    /** Stop recording */
+    stop(): void;
+    /** Clear recorded actions */
+    clear(): void;
+    /** Replay actions on a target */
+    replay(target: unknown): void;
+    /** Export actions as JSON */
+    export(): string;
+    /** Import actions from JSON */
+    import(json: string): void;
+    /** Dispose and clean up */
+    dispose(): void;
+}
+/**
+ * Create an action recorder for debugging and testing
+ */
+declare function createActionRecorder(target: unknown): IActionRecorder;
+
+/**
+ * The `types` namespace contains all type constructors.
+ * This matches the MobX-State-Tree API.
+ */
+declare const types: {
+    string: ISimpleType<string>;
+    number: ISimpleType<number>;
+    integer: ISimpleType<number>;
+    boolean: ISimpleType<boolean>;
+    Date: IType<number | Date, number, Date>;
+    null: ISimpleType<null>;
+    undefined: ISimpleType<undefined>;
+    finite: ISimpleType<number>;
+    float: ISimpleType<number>;
+    identifier: IIdentifierType;
+    identifierNumber: IIdentifierNumberType;
+    literal: typeof literal;
+    enumeration: typeof enumeration;
+    frozen: typeof frozen;
+    custom: typeof custom;
+    model: typeof model;
+    compose: typeof compose;
+    array: typeof array;
+    map: typeof map;
+    optional: typeof optional;
+    maybe: typeof maybe;
+    maybeNull: typeof maybeNull;
+    union: typeof union;
+    late: typeof late;
+    reference: typeof reference;
+    safeReference: typeof safeReference;
+    refinement: typeof refinement;
+    snapshotProcessor: typeof snapshotProcessor;
+    lateModel: typeof lateModel;
+    dynamicReference: typeof dynamicReference;
+    safeDynamicReference: typeof safeDynamicReference;
+};
+
+/**
+ * Creates an async action (generator function) that can be yielded.
+ * Compatible with MST's flow().
+ */
+declare function flow<Args extends unknown[], R>(generator: (...args: Args) => Generator<Promise<unknown>, R, unknown>): (...args: Args) => Promise<R>;
+/**
+ * Cast a value to a different type.
+ * Useful for working around TypeScript limitations.
+ */
+declare function cast<T>(value: unknown): T;
+/**
+ * Cast a value to a snapshot type.
+ */
+declare function castToSnapshot<T>(value: T): T;
+/**
+ * Cast a value to a reference snapshot (identifier).
+ */
+declare function castToReferenceSnapshot<T>(value: T): string | number;
+/**
+ * Check if a value is a valid identifier.
+ */
+declare function isIdentifierType(type: unknown): type is typeof identifier | typeof identifierNumber;
+/**
+ * Check if a type is a model type.
+ */
+declare function isModelType(type: unknown): boolean;
+/**
+ * Check if a type is an array type.
+ */
+declare function isArrayType(type: unknown): boolean;
+/**
+ * Check if a type is a map type.
+ */
+declare function isMapType(type: unknown): boolean;
+/**
+ * Check if a type is a reference type.
+ */
+declare function isReferenceType(type: unknown): boolean;
+/**
+ * Check if a type is a union type.
+ */
+declare function isUnionType(type: unknown): boolean;
+/**
+ * Check if a type is an optional type.
+ */
+declare function isOptionalType(type: unknown): boolean;
+/**
+ * Check if a type is a late type.
+ */
+declare function isLateType(type: unknown): boolean;
+/**
+ * Check if a type is a frozen type.
+ */
+declare function isFrozenType(type: unknown): boolean;
+/**
+ * Check if a type is a literal type.
+ */
+declare function isLiteralType(type: unknown): boolean;
+/**
+ * Get the type of a value, or undefined if not a state tree node.
+ */
+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 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 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 ModelInstance, type ModelProperties, 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, 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 };