mobx-keystone 0.67.4 → 0.68.1-alpha

package/src/dist/ref/rootRef.d.ts

@@ -0,0 +1,33 @@
+import { RefIdResolver, RefOnResolvedValueChange } from "./core";
+import type { RefConstructor } from "./Ref";
+/**
+ * Custom reference options.
+ */
+export interface RootRefOptions<T extends object> {
+    /**
+     * Must return the ID associated to the given target object, or `undefined` if it has no ID.
+     * If not provided it will try to get the reference id from the model `getRefId()` method.
+     *
+     * @param target Target object.
+     */
+    getId?: RefIdResolver;
+    /**
+     * What should happen when the resolved value changes.
+     *
+     * @param ref Reference object.
+     * @param newValue New resolved value.
+     * @param oldValue Old resolved value.
+     */
+    onResolvedValueChange?: RefOnResolvedValueChange<T>;
+}
+/**
+ * Creates a root ref to an object, which in its snapshot form has an id.
+ * A root ref will only be able to resolve references as long as both the Ref
+ * and the referenced object share a common root.
+ *
+ * @typeparam T Target object type.
+ * @param modelTypeId Unique model type id.
+ * @param [options] Root reference options.
+ * @returns A function that allows you to construct that type of root reference.
+ */
+export declare const rootRef: <T extends object>(modelTypeId: string, options?: RootRefOptions<T> | undefined) => RefConstructor<T>;

package/src/dist/rootStore/attachDetach.d.ts

@@ -0,0 +1 @@
+export {};

package/src/dist/rootStore/index.d.ts

@@ -0,0 +1 @@
+export * from "./rootStore";

package/src/dist/rootStore/rootStore.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Registers a model / tree node object as a root store tree.
+ * Marking a model object as a root store tree serves several purposes:
+ * - It allows the `onAttachedToRootStore` hook (plus disposer) to be invoked on models once they become part of this tree.
+ *   These hooks can be used for example to attach effects and serve as some sort of initialization.
+ * - It allows auto detachable references to work properly.
+ *
+ * @typeparam T Object type.
+ * @param node Node object to register as root store.
+ * @returns The same model object that was passed.
+ */
+export declare const registerRootStore: <T extends object>(node: T) => T;
+/**
+ * Unregisters an object to mark it as no longer a root store.
+ *
+ * @param node Node object to unregister as root store.
+ */
+export declare const unregisterRootStore: (node: object) => void;
+/**
+ * Checks if a given object is marked as a root store.
+ *
+ * @param node Object.
+ * @returns
+ */
+export declare function isRootStore(node: object): boolean;
+/**
+ * Gets the root store of a given tree child, or undefined if none.
+ *
+ * @typeparam T Root store type.
+ * @param node Target to find the root store for.
+ * @returns
+ */
+export declare function getRootStore<T extends object>(node: object): T | undefined;

package/src/dist/snapshot/SnapshotOf.d.ts

@@ -0,0 +1,47 @@
+import type { Frozen, frozenKey } from "../frozen/Frozen";
+import type { AnyModel } from "../model/BaseModel";
+import type { modelIdKey, modelTypeKey } from "../model/metadata";
+import type { ModelFromSnapshot, ModelToSnapshot } from "../modelShared/BaseModelShared";
+import type { ArraySet, ObjectMap } from "../wrappers";
+export declare type SnapshotOutOfObject<T> = {
+    [k in keyof T]: SnapshotOutOf<T[k]> extends infer R ? R : never;
+};
+export declare type SnapshotOutOfModel<M extends AnyModel> = ModelToSnapshot<M>;
+export declare type SnapshotOutOfFrozen<F extends Frozen<any>> = {
+    [frozenKey]: true;
+    data: F["data"];
+};
+export interface SnapshotOutOfObjectMap<V> {
+    items: {
+        [k: string]: SnapshotOutOf<V>;
+    };
+    [modelTypeKey]?: string;
+    [modelIdKey]: string;
+}
+export interface SnapshotOutOfArraySet<V> {
+    items: SnapshotOutOf<V>[];
+    [modelTypeKey]?: string;
+    [modelIdKey]: string;
+}
+export declare type SnapshotOutOf<T> = T extends ObjectMap<infer V> ? SnapshotOutOfObjectMap<V> extends infer R ? R : never : T extends ArraySet<infer V> ? SnapshotOutOfArraySet<V> extends infer R ? R : never : T extends AnyModel ? SnapshotOutOfModel<T> extends infer R ? R : never : T extends Frozen<any> ? SnapshotOutOfFrozen<T> extends infer R ? R : never : T extends object ? SnapshotOutOfObject<T> extends infer R ? R : never : T;
+export declare type SnapshotInOfObject<T> = {
+    [k in keyof T]: SnapshotInOf<T[k]> extends infer R ? R : never;
+};
+export declare type SnapshotInOfModel<M extends AnyModel> = ModelFromSnapshot<M>;
+export declare type SnapshotInOfFrozen<F extends Frozen<any>> = {
+    [frozenKey]: true;
+    data: F["data"];
+};
+export interface SnapshotInOfObjectMap<V> {
+    items?: {
+        [k: string]: SnapshotOutOf<V>;
+    };
+    [modelTypeKey]?: string;
+    [modelIdKey]: string;
+}
+export interface SnapshotInOfArraySet<V> {
+    items?: SnapshotOutOf<V>[];
+    [modelTypeKey]?: string;
+    [modelIdKey]: string;
+}
+export declare type SnapshotInOf<T> = T extends ObjectMap<infer V> ? SnapshotInOfObjectMap<V> extends infer R ? R : never : T extends ArraySet<infer V> ? SnapshotInOfArraySet<V> extends infer R ? R : never : T extends AnyModel ? SnapshotInOfModel<T> extends infer R ? R : never : T extends Frozen<any> ? SnapshotInOfFrozen<T> extends infer R ? R : never : T extends object ? SnapshotInOfObject<T> extends infer R ? R : never : T;

package/src/dist/snapshot/SnapshotterAndReconcilerPriority.d.ts

@@ -0,0 +1 @@
+export {};

package/src/dist/snapshot/applySnapshot.d.ts

@@ -0,0 +1,17 @@
+import type { SnapshotInOf, SnapshotOutOf } from "./SnapshotOf";
+/**
+ * Applies a full snapshot over an object, reconciling it with the current contents of the object.
+ *
+ * @typeparam T Object type.
+ * @param node Target object (model object, object or array).
+ * @param snapshot Snapshot to apply.
+ */
+export declare function applySnapshot<T extends object>(node: T, snapshot: SnapshotInOf<T>): void;
+/**
+ * Applies a full snapshot over an object, reconciling it with the current contents of the object.
+ *
+ * @typeparam T Object type.
+ * @param node Target object (model object, object or array).
+ * @param snapshot Snapshot to apply.
+ */
+export declare function applySnapshot<T extends object>(node: T, snapshot: SnapshotOutOf<T>): void;

package/src/dist/snapshot/clone.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Clone options.
+ */
+export interface CloneOptions {
+    /**
+     * Pass `true` to generate new internal ids for models rather than reusing them. (Default is `true`)
+     */
+    generateNewIds: boolean;
+}
+/**
+ * Clones an object by doing a `fromSnapshot(getSnapshot(value), { generateNewIds: true })`.
+ *
+ * @typeparam T Object type.
+ * @param node Object to clone.
+ * @param [options] Options.
+ * @returns The cloned object.
+ */
+export declare function clone<T extends object>(node: T, options?: Partial<CloneOptions>): T;

package/src/dist/snapshot/fromArraySnapshot.d.ts

@@ -0,0 +1 @@
+export {};

package/src/dist/snapshot/fromFrozenSnapshot.d.ts

@@ -0,0 +1 @@
+export {};

package/src/dist/snapshot/fromModelSnapshot.d.ts

@@ -0,0 +1 @@
+export {};

package/src/dist/snapshot/fromPlainObjectSnapshot.d.ts

@@ -0,0 +1 @@
+export {};

package/src/dist/snapshot/fromSnapshot.d.ts

@@ -0,0 +1,36 @@
+import type { AnyDataModel } from "../dataModel/BaseDataModel";
+import type { AnyModel } from "../model/BaseModel";
+import type { ModelClass } from "../modelShared/BaseModelShared";
+import type { AnyStandardType, TypeToData } from "../types/schemas";
+import type { SnapshotInOf, SnapshotOutOf } from "./SnapshotOf";
+/**
+ * From snapshot options.
+ */
+export interface FromSnapshotOptions {
+    /**
+     * Pass `true` to generate new internal ids for models rather than reusing them. (Default is `false`)
+     */
+    generateNewIds: boolean;
+}
+/**
+ * Given a type deserializes a data structure from its snapshot form.
+ *
+ * @typeparam TType Object type.
+ * @param type Type.
+ * @param snapshot Snapshot, even if a primitive.
+ * @param options Options.
+ * @returns The deserialized object.
+ */
+export declare function fromSnapshot<TType extends AnyStandardType | ModelClass<AnyModel> | ModelClass<AnyDataModel>>(type: TType, snapshot: SnapshotInOf<TypeToData<TType>>, options?: Partial<FromSnapshotOptions>): TypeToData<TType>;
+/**
+ * Deserializes a data structure from its snapshot form.
+ *
+ * @typeparam T Object type.
+ * @param snapshot Snapshot, even if a primitive.
+ * @param options Options.
+ * @returns The deserialized object.
+ */
+export declare function fromSnapshot<T>(snapshot: SnapshotInOf<T> | SnapshotOutOf<T>, options?: Partial<FromSnapshotOptions>): T;
+export declare const observableOptions: {
+    deep: boolean;
+};

package/src/dist/snapshot/getSnapshot.d.ts

@@ -0,0 +1,22 @@
+import { AnyType, TypeToData } from "../types/schemas";
+import type { SnapshotOutOf } from "./SnapshotOf";
+/**
+ * Retrieves an immutable snapshot for a data structure.
+ * Since returned snapshots are immutable they will respect shallow equality, this is,
+ * if no changes are made then the snapshot will be kept the same.
+ *
+ * @typeparam T Object type.
+ * @param nodeOrPrimitive Data structure, including primtives.
+ * @returns The snapshot.
+ */
+export declare function getSnapshot<T extends AnyType>(type: T, nodeOrPrimitive: TypeToData<T>): SnapshotOutOf<TypeToData<T>>;
+/**
+ * Retrieves an immutable snapshot for a data structure.
+ * Since returned snapshots are immutable they will respect shallow equality, this is,
+ * if no changes are made then the snapshot will be kept the same.
+ *
+ * @typeparam T Object type.
+ * @param nodeOrPrimitive Data structure, including primtives.
+ * @returns The snapshot.
+ */
+export declare function getSnapshot<T>(nodeOrPrimitive: T): SnapshotOutOf<T>;

package/src/dist/snapshot/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./applySnapshot";
+export * from "./clone";
+export * from "./fromSnapshot";
+export * from "./getSnapshot";
+export * from "./onSnapshot";
+export * from "./SnapshotOf";

package/src/dist/snapshot/internal.d.ts

@@ -0,0 +1 @@
+export {};

package/src/dist/snapshot/onSnapshot.d.ts

@@ -0,0 +1,18 @@
+import type { SnapshotOutOf } from "./SnapshotOf";
+/**
+ * Listener function for onSnapshot.
+ */
+export declare type OnSnapshotListener<T> = (sn: SnapshotOutOf<T>, prevSn: SnapshotOutOf<T>) => void;
+/**
+ * Disposer function for onSnapshot.
+ */
+export declare type OnSnapshotDisposer = () => void;
+/**
+ * Adds a reaction that will trigger every time an snapshot changes.
+ *
+ * @typeparam T Object type.
+ * @param nodeOrFn Object to get the snapshot from or a function to get it.
+ * @param listener Function that will be triggered when the snapshot changes.
+ * @returns A disposer.
+ */
+export declare function onSnapshot<T extends object>(nodeOrFn: T | (() => T), listener: OnSnapshotListener<T>): OnSnapshotDisposer;

package/src/dist/snapshot/reconcileArraySnapshot.d.ts

@@ -0,0 +1 @@
+export {};

package/src/dist/snapshot/reconcileFrozenSnapshot.d.ts

@@ -0,0 +1 @@
+export {};

package/src/dist/snapshot/reconcileModelSnapshot.d.ts

@@ -0,0 +1 @@
+export {};

package/src/dist/snapshot/reconcilePlainObjectSnapshot.d.ts

@@ -0,0 +1 @@
+export {};

package/src/dist/snapshot/reconcileSnapshot.d.ts

@@ -0,0 +1 @@
+export {};

package/src/dist/snapshot/registerDefaultReconcilers.d.ts

@@ -0,0 +1 @@
+export {};

package/src/dist/snapshot/registerDefaultSnapshotters.d.ts

@@ -0,0 +1 @@
+export {};

package/src/dist/standardActions/actions.d.ts

@@ -0,0 +1 @@
+export {};

package/src/dist/standardActions/arrayActions.d.ts

@@ -0,0 +1,18 @@
+export declare const arrayActions: {
+    set: <T>(array: T[], index: number, value: any) => void;
+    delete: <T_1>(array: T_1[], index: number) => boolean;
+    setLength: <T_2>(array: T_2[], length: number) => void;
+    concat: <T_3>(array: T_3[], ...items: ConcatArray<T_3>[]) => T_3[];
+    copyWithin: <T_4>(array: T_4[], target: number, start: number, end?: number | undefined) => T_4[];
+    fill: <T_5>(array: T_5[], value: T_5, start?: number | undefined, end?: number | undefined) => T_5[];
+    pop: <T_6>(array: T_6[]) => T_6 | undefined;
+    push: <T_7>(array: T_7[], ...items: T_7[]) => number;
+    reverse: <T_8>(array: T_8[]) => T_8[];
+    shift: <T_9>(array: T_9[]) => T_9 | undefined;
+    slice: <T_10>(array: T_10[], start?: number | undefined, end?: number | undefined) => T_10[];
+    sort: <T_11>(array: T_11[], compareFn?: ((a: T_11, b: T_11) => number) | undefined) => T_11[];
+    splice: (<T_12>(array: T_12[], start: number, deleteCount?: number | undefined) => T_12[]) | (<T_13>(array: T_13[], start: number, deleteCount: number, ...items: T_13[]) => T_13[]);
+    unshift: <T_14>(array: T_14[], ...items: T_14[]) => number;
+    swap: <T_15>(array: T_15[], index1: number, index2: number) => boolean;
+    create: <T_16>(data: T_16[]) => T_16[];
+};

package/src/dist/standardActions/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./arrayActions";
+export * from "./objectActions";
+export * from "./standaloneActions";

package/src/dist/standardActions/objectActions.d.ts

@@ -0,0 +1,7 @@
+export declare const objectActions: {
+    set: <T extends object, K extends keyof T>(target: T, key: K, value: T[K]) => void;
+    assign: <T_1 extends object>(target: T_1, partialObject: Partial<T_1>) => void;
+    delete: <T_2 extends object, K_1 extends keyof T_2>(target: T_2, key: K_1) => boolean;
+    call: <T_3 extends object, K_2 extends keyof T_3>(target: T_3, methodName: K_2, ...args: T_3[K_2] extends (...args: any[]) => any ? Parameters<T_3[K_2]> : never) => T_3[K_2] extends (...args: any[]) => any ? ReturnType<T_3[K_2]> : never;
+    create: <T_4 extends object>(data: T_4) => T_4;
+};

package/src/dist/standardActions/standaloneActions.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Creates a standalone action. A standalone action must always take an existing tree node as first argument.
+ *
+ * @param actionName Unique action name.
+ * @param fn Function.
+ * @returns The function as an standalone action.
+ */
+export declare function standaloneAction<FN extends (target: any, ...args: any[]) => any>(actionName: string, fn: FN): FN;
+/**
+ * Creates a standalone flow. A standalone flow must always take an existing tree node as first argument.
+ *
+ * @param actionName Unique action name.
+ * @param fn Function.
+ * @returns The function as an standalone flow.
+ */
+export declare function standaloneFlow<FN extends (target: any, ...args: any[]) => Generator<any, any, any>>(actionName: string, fn: FN): FN;

package/src/dist/transforms/ImmutableDate.d.ts

@@ -0,0 +1 @@
+export {};

package/src/dist/transforms/asMap.d.ts

@@ -0,0 +1,3 @@
+import type { ModelPropTransform } from "../modelShared/prop";
+export declare const objectToMapTransform: <T>() => ModelPropTransform<Record<string, T>, Map<string, T>>;
+export declare const arrayToMapTransform: <K, V>() => ModelPropTransform<[K, V][], Map<K, V>>;

package/src/dist/transforms/asSet.d.ts

@@ -0,0 +1,2 @@
+import type { ModelPropTransform } from "../modelShared/prop";
+export declare const arrayToSetTransform: <T>() => ModelPropTransform<T[], Set<T>>;

package/src/dist/transforms/bigint.d.ts

@@ -0,0 +1,2 @@
+import type { ModelPropTransform } from "../modelShared/prop";
+export declare const stringToBigIntTransform: () => ModelPropTransform<string, bigint>;

package/src/dist/transforms/date.d.ts

@@ -0,0 +1,3 @@
+import type { ModelPropTransform } from "../modelShared/prop";
+export declare const timestampToDateTransform: () => ModelPropTransform<number, Date>;
+export declare const isoStringToDateTransform: () => ModelPropTransform<string, Date>;

package/src/dist/transforms/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./asMap";
+export * from "./asSet";
+export * from "./bigint";
+export * from "./date";

package/src/dist/treeUtils/deepEquals.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Deeply compares two values.
+ *
+ * Supported values are:
+ * - Primitives
+ * - Boxed observables
+ * - Objects, observable objects
+ * - Arrays, observable arrays
+ * - Typed arrays
+ * - Maps, observable maps
+ * - Sets, observable sets
+ * - Tree nodes (optimized by using snapshot comparison internally)
+ *
+ * Note that in the case of models the result will be false if their model IDs are different.
+ *
+ * @param a First value to compare.
+ * @param b Second value to compare.
+ * @returns `true` if they are the equivalent, `false` otherwise.
+ */
+export declare function deepEquals(a: any, b: any): boolean;

package/src/dist/treeUtils/draft.d.ts

@@ -0,0 +1,70 @@
+import type { Path } from "../parent/pathTypes";
+/**
+ * A class with the implementationm of draft.
+ * Use `draft` to create an instance of this class.
+ *
+ * @typeparam T Data type.
+ */
+export declare class Draft<T extends object> {
+    /**
+     * Draft data object.
+     */
+    readonly data: T;
+    /**
+     * Commits current draft changes to the original object.
+     */
+    commit(): void;
+    /**
+     * Partially commits current draft changes to the original object.
+     * If the path cannot be resolved in either the draft or the original object it will throw.
+     * Note that model IDs are checked to be the same when resolving the paths.
+     *
+     * @param path Path to commit.
+     */
+    commitByPath(path: Path): void;
+    /**
+     * Resets the draft to be an exact copy of the current state of the original object.
+     */
+    reset(): void;
+    /**
+     * Partially resets current draft changes to be the same as the original object.
+     * If the path cannot be resolved in either the draft or the original object it will throw.
+     * Note that model IDs are checked to be the same when resolving the paths.
+     *
+     * @param path Path to reset.
+     */
+    resetByPath(path: Path): void;
+    /**
+     * Returns `true` if the draft has changed compared to the original object, `false` otherwise.
+     */
+    get isDirty(): boolean;
+    /**
+     * Returns `true` if the value at the given path of the draft has changed compared to the original object.
+     * If the path cannot be resolved in the draft it will throw.
+     * If the path cannot be resolved in the original object it will return `true`.
+     * Note that model IDs are checked to be the same when resolving the paths.
+     *
+     * @param path Path to check.
+     */
+    isDirtyByPath(path: Path): boolean;
+    /**
+     * Original data object.
+     */
+    readonly originalData: T;
+    private get originalSnapshot();
+    /**
+     * Creates an instance of Draft.
+     * Do not use directly, use `draft` instead.
+     *
+     * @param original
+     */
+    constructor(original: T);
+}
+/**
+ * Creates a draft copy of a tree node and all its children.
+ *
+ * @typeparam T Data type.
+ * @param original Original node.
+ * @returns The draft object.
+ */
+export declare function draft<T extends object>(original: T): Draft<T>;

package/src/dist/treeUtils/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./deepEquals";
+export * from "./draft";
+export * from "./sandbox";

package/src/dist/treeUtils/sandbox.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Returns the sandbox manager of a node, or `undefined` if none.
+ *
+ * @param node Node to check.
+ * @returns The sandbox manager of a node, or `undefined` if none.
+ */
+export declare function getNodeSandboxManager(node: object): SandboxManager | undefined;
+/**
+ * Returns if a given node is a sandboxed node.
+ *
+ * @param node Node to check.
+ * @returns `true` if it is sandboxed, `false`
+ */
+export declare function isSandboxedNode(node: object): boolean;
+/**
+ * Callback function for `SandboxManager.withSandbox`.
+ */
+export declare type WithSandboxCallback<T extends readonly [object, ...object[]], R> = (...nodes: T) => boolean | {
+    commit: boolean;
+    return: R;
+};
+/**
+ * Manager class returned by `sandbox` that allows you to make changes to a sandbox copy of the
+ * original subtree and apply them to the original subtree or reject them.
+ */
+export declare class SandboxManager {
+    private readonly subtreeRoot;
+    /**
+     * The sandbox copy of the original subtree.
+     */
+    private readonly subtreeRootClone;
+    /**
+     * The internal disposer.
+     */
+    private disposer;
+    /**
+     * The internal `withSandbox` patch recorder. If `undefined`, no `withSandbox` call is being
+     * executed.
+     */
+    private withSandboxPatchRecorder;
+    /**
+     * Function from `readonlyMiddleware` that will allow actions to be started inside the provided
+     * code block on a readonly node.
+     */
+    private allowWrite;
+    /**
+     * Whether changes made in the sandbox are currently being committed to the original subtree.
+     */
+    private isCommitting;
+    /**
+     * Creates an instance of `SandboxManager`.
+     * Do not use directly, use `sandbox` instead.
+     *
+     * @param subtreeRoot Subtree root target object.
+     */
+    constructor(subtreeRoot: object);
+    /**
+     * Executes `fn` with sandbox copies of the elements of `nodes`. The changes made to the sandbox
+     * in `fn` can be accepted, i.e. applied to the original subtree, or rejected.
+     *
+     * @typeparam T Object type.
+     * @typeparam R Return type.
+     * @param nodes Tuple of objects for which to obtain sandbox copies.
+     * @param fn Function that is called with sandbox copies of the elements of `nodes`. Any changes
+     * made to the sandbox are applied to the original subtree when `fn` returns `true` or
+     * `{ commit: true, ... }`. When `fn` returns `false` or `{ commit: false, ... }` the changes made
+     * to the sandbox are rejected.
+     * @returns Value of type `R` when `fn` returns an object of type `{ commit: boolean; return: R }`
+     * or `void` when `fn` returns a boolean.
+     */
+    withSandbox<T extends readonly [object, ...object[]], R = void>(nodes: T, fn: WithSandboxCallback<T, R>): R;
+    /**
+     * Disposes of the sandbox.
+     */
+    dispose(): void;
+    private prepareSandboxChanges;
+}
+/**
+ * Creates a sandbox.
+ *
+ * @param subtreeRoot Subtree root target object.
+ * @returns A `SandboxManager` which allows you to manage the sandbox operations and dispose of the
+ * sandbox.
+ */
+export declare function sandbox(subtreeRoot: object): SandboxManager;

package/src/dist/tweaker/TweakerPriority.d.ts

@@ -0,0 +1 @@
+export {};

package/src/dist/tweaker/core.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Checks if a given object is now a tree node.
+ *
+ * @param value Value to check.
+ * @returns true if it is a tree node, false otherwise.
+ */
+export declare function isTreeNode(value: unknown): value is object;
+/**
+ * Asserts a given object is now a tree node, or throws otherwise.
+ *
+ * @param value Value to check.
+ * @param argName Argument name, part of the thrown error description.
+ */
+export declare function assertIsTreeNode(value: unknown, argName?: string): asserts value is object;

package/src/dist/tweaker/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./core";
+export * from "./tweak";

package/src/dist/tweaker/registerDefaultTweakers.d.ts

@@ -0,0 +1 @@
+export {};

package/src/dist/tweaker/tweak.d.ts

@@ -0,0 +1,22 @@
+import type { AnyStandardType, TypeToData } from "../types/schemas";
+/**
+ * Turns an object (array, plain object) into a tree node,
+ * which then can accept calls to `getParent`, `getSnapshot`, etc.
+ * If a tree node is passed it will return the passed argument directly.
+ * Additionally this method will use the type passed to check the value
+ * conforms to the type when model auto type checking is enabled.
+ *
+ * @param type Type checker.
+ * @param value Object to turn into a tree node.
+ * @returns The object as a tree node.
+ */
+export declare function toTreeNode<TType extends AnyStandardType, V extends TypeToData<TType>>(type: TType, value: V): V;
+/**
+ * Turns an object (array, plain object) into a tree node,
+ * which then can accept calls to `getParent`, `getSnapshot`, etc.
+ * If a tree node is passed it will return the passed argument directly.
+ *
+ * @param value Object to turn into a tree node.
+ * @returns The object as a tree node.
+ */
+export declare function toTreeNode<T extends object>(value: T): T;

package/src/dist/tweaker/tweakArray.d.ts

@@ -0,0 +1 @@
+export {};

package/src/dist/tweaker/tweakFrozen.d.ts

@@ -0,0 +1 @@
+export {};

package/src/dist/tweaker/tweakModel.d.ts

@@ -0,0 +1 @@
+export {};

package/src/dist/tweaker/tweakPlainObject.d.ts

@@ -0,0 +1 @@
+export {};

package/src/dist/tweaker/typeChecking.d.ts

@@ -0,0 +1 @@
+export {};

package/src/dist/tweaker/withoutTypeChecking.d.ts

@@ -0,0 +1,2 @@
+export declare function withoutTypeChecking(fn: () => void): void;
+export declare function isTypeCheckingAllowed(): boolean;