mobx-keystone 2.1.0 → 2.3.0

package/dist/types/actionMiddlewares/undoMiddleware.d.ts

@@ -77,16 +77,8 @@ export interface UndoEventGroup {
     readonly events: ReadonlyArray<UndoEventWithoutAttachedState>;
 }
 declare const UndoStore_base: import('..')._Model<unknown, {
-    undoEvents: import('..').OptionalModelProp<Frozen<UndoEvent>[]> & {
-        $storedValueType: Frozen<UndoEvent>[];
-        $storedCreationValueType: Frozen<UndoEvent>[] | null | undefined;
-        $typedFromSnapshotOverride: import('..').SnapshotInOfFrozen<Frozen<UndoEvent>>[] | null | undefined;
-    };
-    redoEvents: import('..').OptionalModelProp<Frozen<UndoEvent>[]> & {
-        $storedValueType: Frozen<UndoEvent>[];
-        $storedCreationValueType: Frozen<UndoEvent>[] | null | undefined;
-        $typedFromSnapshotOverride: import('..').SnapshotInOfFrozen<Frozen<UndoEvent>>[] | null | undefined;
-    };
+    undoEvents: import('..').TypedOptionalModelProp<import('..').ArrayType<import('..').ModelType<Frozen<UndoEvent>>[]>>;
+    redoEvents: import('..').TypedOptionalModelProp<import('..').ArrayType<import('..').ModelType<Frozen<UndoEvent>>[]>>;
 }, {
     undoEvents?: ReadonlyArray<UndoEvent | FrozenData<UndoEvent>>;
     redoEvents?: ReadonlyArray<UndoEvent | FrozenData<UndoEvent>>;

package/dist/types/modelShared/modelDecorator.d.ts

@@ -1,6 +1,5 @@
 import { AnyDataModel } from '../dataModel/BaseDataModel';
 import { AnyModel } from '../model/BaseModel';
-import { ModelClass } from '../modelShared/BaseModelShared';
 import { AnyFunction } from '../utils/AnyFunction';
 /**
  * Decorator that marks this class (which MUST inherit from the `Model` or `DataModel` abstract classes)
@@ -9,7 +8,10 @@ import { AnyFunction } from '../utils/AnyFunction';
  * @param name Unique name for the model type. Note that this name must be unique for your whole
  * application, so it is usually a good idea to use some prefix unique to your application domain.
  */
-export declare const model: (name: string) => <MC extends ModelClass<AnyModel | AnyDataModel>>(clazz: MC, _context?: ClassDecoratorContext<MC>) => MC;
+export declare const model: (name: string) => <MC extends ModelDecoratorTarget>(clazz: MC, _context?: ClassDecoratorContext<MC>) => MC;
+type ModelDecoratorTarget = (new (...args: any) => any) & {
+    prototype: AnyModel | AnyDataModel;
+};
 /**
  * Marks a class (which MUST inherit from the `Model` abstract class)
  * as a model and decorates some of its methods/properties.
@@ -23,3 +25,4 @@ export declare const model: (name: string) => <MC extends ModelClass<AnyModel |
 export declare function decoratedModel<M, MC extends abstract new (...ags: any) => M>(name: string | undefined, clazz: MC, decorators: {
     [k in keyof M]?: AnyFunction | ReadonlyArray<AnyFunction>;
 }): MC;
+export {};

package/dist/types/modelShared/prop.d.ts

@@ -1,6 +1,6 @@
 import { SnapshotInOf, SnapshotOutOf } from '../snapshot/SnapshotOf';
 import { AnyStandardType } from '../types/schemas';
-import { Flatten, IsNeverType, IsOptionalValue } from '../utils/types';
+import { IsNeverType, IsOptionalValue, SimplifyObject } from '../utils/types';
 /**
  * @ignore
  */
@@ -44,16 +44,16 @@ export interface ModelProp<TPropValue, TPropCreationValue, TTransformedValue, TT
      * Adds a setter to the property. The setter will be named `set${CapitalizedPropName}`
      * and will be available in the model instance.
      */
-    withSetter(): ModelProp<TPropValue, TPropCreationValue, TTransformedValue, TTransformedCreationValue, TIsRequired, TIsId, string, TFromSnapshotOverride, TToSnapshotOverride>;
+    withSetter(): ModelPropWithSetter<this>;
     /**
      * Adds a setter with a transform to the property. The setter will be named `set${CapitalizedPropName}`
      * and will be available in the model instance.
      */
-    withSetter(valueTransform: ModelPropSetterValueTransform<TTransformedValue>): ModelProp<TPropValue, TPropCreationValue, TTransformedValue, TTransformedCreationValue, TIsRequired, TIsId, string, TFromSnapshotOverride, TToSnapshotOverride>;
+    withSetter(valueTransform: ModelPropSetterValueTransform<TTransformedValue>): ModelPropWithSetter<this>;
     /**
      * @deprecated Setter methods are preferred.
      */
-    withSetter(mode: "assign"): ModelProp<TPropValue, TPropCreationValue, TTransformedValue, TTransformedCreationValue, TIsRequired, TIsId, string, TFromSnapshotOverride, TToSnapshotOverride>;
+    withSetter(mode: "assign"): ModelPropWithSetter<this>;
     /**
      * Sets a transform for the property instance value.
      *
@@ -66,7 +66,7 @@ export interface ModelProp<TPropValue, TPropCreationValue, TTransformedValue, TT
      * @param transform Transform to be used.
      * @returns
      */
-    withTransform<TTV>(transform: ModelPropTransform<NonNullable<TPropValue>, TTV>): ModelProp<TPropValue, TPropCreationValue, TTV | Extract<TPropValue, null | undefined>, TTV | Extract<TPropCreationValue, null | undefined>, TIsRequired, TIsId, THasSetter, TFromSnapshotOverride, TToSnapshotOverride>;
+    withTransform<TTV>(transform: ModelPropTransform<NonNullable<TPropValue>, TTV>): ModelPropWithTransform<this, TTV>;
     /**
      * Sets snapshot processors for this property.
      *
@@ -79,8 +79,24 @@ export interface ModelProp<TPropValue, TPropCreationValue, TTransformedValue, TT
     withSnapshotProcessor<FS = TFromSnapshotOverride, TS = TToSnapshotOverride, This extends AnyModelProp = this>(processor: {
         fromSnapshot?: (sn: FS) => ModelPropFromSnapshot<This>;
         toSnapshot?: (sn: ModelPropToSnapshot<This>) => TS;
-    }): ModelProp<TPropValue, TPropCreationValue, TTransformedValue, TTransformedCreationValue, TIsRequired, TIsId, THasSetter, FS, TS>;
+    }): ModelPropWithSnapshotProcessor<this, FS, TS>;
 }
+type ModelPropStoredMetadataKey = "$storedValueType" | "$storedCreationValueType";
+type ModelPropStoredMetadata<MP, K extends PropertyKey> = MP extends {
+    $storedValueType: unknown;
+} ? Pick<MP, Extract<keyof MP, K>> : {};
+/**
+ * The model property returned by `withSetter`.
+ */
+export type ModelPropWithSetter<MP extends AnyModelProp> = ModelProp<MP["$valueType"], MP["$creationValueType"], MP["$transformedValueType"], MP["$transformedCreationValueType"], MP["$isRequired"], MP["$isId"], string, MP["$fromSnapshotOverride"], MP["$toSnapshotOverride"]> & ModelPropStoredMetadata<MP, ModelPropStoredMetadataKey | "$typedFromSnapshotOverride">;
+/**
+ * The model property returned by `withTransform`.
+ */
+export type ModelPropWithTransform<MP extends AnyModelProp, TTV> = ModelProp<MP["$valueType"], MP["$creationValueType"], TTV | Extract<MP["$valueType"], null | undefined>, TTV | Extract<MP["$creationValueType"], null | undefined>, MP["$isRequired"], MP["$isId"], MP["$hasSetter"], MP["$fromSnapshotOverride"], MP["$toSnapshotOverride"]> & ModelPropStoredMetadata<MP, ModelPropStoredMetadataKey | "$typedFromSnapshotOverride">;
+/**
+ * The model property returned by `withSnapshotProcessor`.
+ */
+export type ModelPropWithSnapshotProcessor<MP extends AnyModelProp, FS, TS> = ModelProp<MP["$valueType"], MP["$creationValueType"], MP["$transformedValueType"], MP["$transformedCreationValueType"], MP["$isRequired"], MP["$isId"], MP["$hasSetter"], FS, TS> & ModelPropStoredMetadata<MP, ModelPropStoredMetadataKey>;
 /**
  * The snapshot in type of a model property.
  */
@@ -89,15 +105,9 @@ export type ModelPropFromSnapshot<MP extends AnyModelProp> = IsNeverType<ModelPr
  * The snapshot out type of a model property.
  */
 export type ModelPropToSnapshot<MP extends AnyModelProp> = IsNeverType<MP["$toSnapshotOverride"], SnapshotOutOf<ModelPropStoredValue<MP>>, MP["$toSnapshotOverride"]>;
-export type ModelPropStoredValue<MP extends AnyModelProp> = MP extends {
-    $storedValueType: infer TStoredValue;
-} ? TStoredValue : MP["$valueType"];
-export type ModelPropStoredCreationValue<MP extends AnyModelProp> = MP extends {
-    $storedCreationValueType: infer TStoredCreationValue;
-} ? TStoredCreationValue : MP["$creationValueType"];
-export type ModelPropFromSnapshotOverride<MP extends AnyModelProp> = MP extends {
-    $typedFromSnapshotOverride: infer TFromSnapshotOverride;
-} ? TFromSnapshotOverride : MP["$fromSnapshotOverride"];
+export type ModelPropStoredValue<MP extends AnyModelProp> = "$storedValueType" extends keyof MP ? MP["$storedValueType" & keyof MP] : MP["$valueType"];
+export type ModelPropStoredCreationValue<MP extends AnyModelProp> = "$storedCreationValueType" extends keyof MP ? MP["$storedCreationValueType" & keyof MP] : MP["$creationValueType"];
+export type ModelPropFromSnapshotOverride<MP extends AnyModelProp> = "$typedFromSnapshotOverride" extends keyof MP ? MP["$typedFromSnapshotOverride" & keyof MP] : MP["$fromSnapshotOverride"];
 /**
  * A model prop transform.
  */
@@ -131,39 +141,42 @@ export interface ModelProps {
 export type RequiredModelProps<MP extends ModelProps> = {
     [K in keyof MP]: MP[K]["$isRequired"] & K;
 }[keyof MP];
-export type ModelPropsToUntransformedData<MP extends ModelProps> = Flatten<{
+export type ModelPropsToUntransformedData<MP extends ModelProps> = {
     [k in keyof MP]: ModelPropStoredValue<MP[k]>;
-}>;
-export type ModelPropsToSnapshotData<MP extends ModelProps> = Flatten<{
+} & {};
+export type ModelPropsToSnapshotData<MP extends ModelProps> = {
     [k in keyof MP]: ModelPropToSnapshot<MP[k]> extends infer R ? R : never;
-}>;
+} & {};
 export type ModelPropsToUntransformedCreationData<MP extends ModelProps> = {
     [k in keyof MP]?: ModelPropStoredCreationValue<MP[k]>;
 } & {
     [k in RequiredModelProps<MP>]: ModelPropStoredCreationValue<MP[k]>;
 };
-export type ModelPropsToSnapshotCreationData<MP extends ModelProps> = Flatten<{
+export type ModelPropsToSnapshotCreationData<MP extends ModelProps> = SimplifyObject<{
     [k in keyof MP]?: ModelPropFromSnapshot<MP[k]> extends infer R ? R : never;
 } & {
-    [k in {
-        [K in keyof MP]: IsNeverType<ModelPropFromSnapshotOverride<MP[K]>, MP[K]["$isRequired"] & K, // no override
-        IsOptionalValue<ModelPropFromSnapshotOverride<MP[K]>, never, K>>;
-    }[keyof MP]]: ModelPropFromSnapshot<MP[k]> extends infer R ? R : never;
+    [k in SnapshotCreationRequiredKeys<MP>]: ModelPropFromSnapshot<MP[k]> extends infer R ? R : never;
 }>;
-export type ModelPropsToTransformedData<MP extends ModelProps> = Flatten<{
+type SnapshotCreationRequiredKeys<MP extends ModelProps> = {
+    [K in keyof MP]: IsNeverType<ModelPropFromSnapshotOverride<MP[K]>, MP[K]["$isRequired"] & K, IsOptionalValue<ModelPropFromSnapshotOverride<MP[K]>, never, K>>;
+}[keyof MP];
+export type ModelPropsToTransformedData<MP extends ModelProps> = {
     [k in keyof MP]: MP[k]["$transformedValueType"];
-}>;
+} & {};
 export type ModelPropsToTransformedCreationData<MP extends ModelProps> = {
     [k in keyof MP]?: MP[k]["$transformedCreationValueType"];
 } & {
     [k in RequiredModelProps<MP>]: MP[k]["$transformedCreationValueType"];
 };
-export type ModelPropsToSetter<MP extends ModelProps> = Flatten<{
+export type ModelPropsToSetter<MP extends ModelProps> = {
     [k in keyof MP as MP[k]["$hasSetter"] & `set${Capitalize<k & string>}`]: (value: MP[k]["$transformedValueType"]) => void;
-}>;
+} & {};
 export type ModelIdProp<T extends string = string> = ModelProp<T, T | undefined, T, T | undefined, never, // not required
 true>;
-type TypedModelIdProp<T extends string = string, THasSetter = never> = Omit<ModelProp<T, T | undefined, T, T | undefined, never, true, THasSetter>, "withSetter"> & {
+/**
+ * The type of `idProp`.
+ */
+export type TypedModelIdProp<T extends string = string, THasSetter = never> = Omit<ModelProp<T, T | undefined, T, T | undefined, never, true, THasSetter>, "withSetter"> & {
     /**
      * Enables generation of a setter method for the ID prop (`setId` for `id`, `setCustomId` for `customId`).
      */

package/dist/types/ref/Ref.d.ts

@@ -3,10 +3,7 @@ declare const Ref_base: import('..')._Model<unknown, {
     /**
      * Reference id.
      */
-    id: import('..').MaybeOptionalModelProp<string> & {
-        $storedValueType: string;
-        $storedCreationValueType: string;
-    };
+    id: import('..').TypedMaybeOptionalModelProp<import('..').IdentityType<string>>;
 }, never, never>;
 /**
  * A reference model base type.

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

@@ -8,7 +8,7 @@ export type FrozenData<D> = {
     data: D;
 };
 export type SnapshotOutOfObject<T> = {
-    [k in keyof T]: SnapshotOutOf<T[k]> extends infer R ? R : never;
+    [k in keyof T]: SnapshotOutOf<T[k]>;
 };
 export type SnapshotOutOfModel<M extends AnyModel> = ModelToSnapshot<M>;
 export interface SnapshotOutOfFrozen<F extends Frozen<any>> extends FrozenData<F["data"]> {
@@ -25,9 +25,9 @@ export interface SnapshotOutOfArraySet<V> {
     [modelTypeKey]?: string;
     [modelIdKey]: string;
 }
-export 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 type SnapshotOutOf<T> = T extends object ? T extends AnyModel ? T extends ObjectMap<infer V> ? SnapshotOutOfObjectMap<V> : T extends ArraySet<infer V> ? SnapshotOutOfArraySet<V> : SnapshotOutOfModel<T> : T extends Frozen<any> ? SnapshotOutOfFrozen<T> : SnapshotOutOfObject<T> : T;
 export type SnapshotInOfObject<T> = {
-    [k in keyof T]: SnapshotInOf<T[k]> extends infer R ? R : never;
+    [k in keyof T]: SnapshotInOf<T[k]>;
 };
 export type SnapshotInOfModel<M extends AnyModel> = ModelFromSnapshot<M>;
 export interface SnapshotInOfFrozen<F extends Frozen<any>> extends FrozenData<F["data"]> {
@@ -44,4 +44,4 @@ export interface SnapshotInOfArraySet<V> {
     [modelTypeKey]?: string;
     [modelIdKey]: string;
 }
-export 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;
+export type SnapshotInOf<T> = T extends object ? T extends AnyModel ? T extends ObjectMap<infer V> ? SnapshotInOfObjectMap<V> : T extends ArraySet<infer V> ? SnapshotInOfArraySet<V> : SnapshotInOfModel<T> : T extends Frozen<any> ? SnapshotInOfFrozen<T> : SnapshotInOfObject<T> : T;

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

@@ -7,4 +7,4 @@ import { SnapshotInOf, SnapshotOutOf } from './SnapshotOf';
  * @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> | SnapshotOutOf<T>): void;
+export declare function applySnapshot<T extends object>(node: T, snapshot: NoInfer<SnapshotInOf<T> | SnapshotOutOf<T>>): void;

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

@@ -1,4 +1,4 @@
-import { AnyType, TypeToData, TypeToSnapshotIn } from '../types/schemas';
+import { AnyType, TypeToData, TypeToSnapshotIn, TypeToSnapshotOut } from '../types/schemas';
 import { SnapshotInOf, SnapshotOutOf } from './SnapshotOf';
 /**
  * From snapshot options.
@@ -18,7 +18,7 @@ export interface FromSnapshotOptions {
  * @param options Options.
  * @returns The deserialized object.
  */
-export declare function fromSnapshot<TType extends AnyType>(type: TType, snapshot: TypeToSnapshotIn<TType>, options?: Partial<FromSnapshotOptions>): TypeToData<TType>;
+export declare function fromSnapshot<TType extends AnyType>(type: TType, snapshot: NoInfer<TypeToSnapshotIn<TType> | TypeToSnapshotOut<TType>>, options?: Partial<FromSnapshotOptions>): TypeToData<TType>;
 /**
  * Deserializes a data structure from its snapshot form.
  *

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

@@ -9,7 +9,7 @@ import { SnapshotOutOf } from './SnapshotOf';
  * @param nodeOrPrimitive Data structure, including primtives.
  * @returns The snapshot.
  */
-export declare function getSnapshot<T extends AnyType>(type: T, nodeOrPrimitive: TypeToData<T>): TypeToSnapshotOut<T>;
+export declare function getSnapshot<T extends AnyType>(type: T, nodeOrPrimitive: NoInfer<TypeToData<T>>): TypeToSnapshotOut<T>;
 /**
  * Retrieves an immutable snapshot for a data structure.
  * Since returned snapshots are immutable they will respect shallow equality, this is,

package/dist/types/types/SnapshotTypeMismatchError.d.ts

@@ -7,7 +7,9 @@ export interface SnapshotTypeMismatchErrorData {
     modelTrail?: readonly string[];
 }
 /**
- * Thrown when a snapshot value does not match any of the expected types in a union (extends `MobxKeystoneError`).
+ * Thrown when a snapshot value does not match any of the expected types in a union, or when a
+ * model snapshot names a model (`$modelType`) that is not the expected model or a subclass of it
+ * (extends `MobxKeystoneError`).
  *
  * Use `instanceof SnapshotTypeMismatchError` to distinguish snapshot type-mismatch errors
  * from other `MobxKeystoneError` instances.

package/dist/types/types/index.d.ts

@@ -4,3 +4,4 @@ export * from './TypeCheckError';
 export * from './tProp';
 export { typeCheck } from './typeCheck';
 export * from './types';
+export type { CodecFromEncoded } from './utility/typesCodecCore';

package/dist/types/types/modelTypeMatching.d.ts

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

package/dist/types/types/schemas.d.ts

@@ -1,9 +1,8 @@
-import { O } from 'ts-toolbelt';
 import { AnyDataModel } from '../dataModel/BaseDataModel';
 import { AnyModel } from '../model/BaseModel';
 import { ModelClass } from '../modelShared/BaseModelShared';
 import { SnapshotInOf, SnapshotOutOf } from '../snapshot/SnapshotOf';
-import { IsOptionalValue } from '../utils/types';
+import { IsOptionalValue, SimplifyObject } from '../utils/types';
 export interface Type<Name, Data> {
     /** @ignore */
     $$type: Name;
@@ -22,14 +21,14 @@ export interface CodecType<Runtime, SnapshotIn = Runtime, SnapshotOut = Snapshot
     /** @ignore */
     $$storedData: StoredData;
 }
-type ArrayData<S extends readonly unknown[]> = number extends S["length"] ? Array<TypeToData<S[number]> extends infer R ? R : never> : {
-    [k in keyof S]: TypeToData<S[k]> extends infer R ? R : never;
+type ArrayData<S extends readonly unknown[]> = number extends S["length"] ? Array<TypeToData<S[number]>> : {
+    [k in keyof S]: TypeToData<S[k]>;
 };
-type ArraySnapshotInData<S extends readonly unknown[]> = number extends S["length"] ? Array<TypeToSnapshotIn<S[number]> extends infer R ? R : never> : {
-    [k in keyof S]: TypeToSnapshotIn<S[k]> extends infer R ? R : never;
+type ArraySnapshotInData<S extends readonly unknown[]> = number extends S["length"] ? Array<TypeToSnapshotIn<S[number]>> : {
+    [k in keyof S]: TypeToSnapshotIn<S[k]>;
 };
-type ArraySnapshotOutData<S extends readonly unknown[]> = number extends S["length"] ? Array<TypeToSnapshotOut<S[number]> extends infer R ? R : never> : {
-    [k in keyof S]: TypeToSnapshotOut<S[k]> extends infer R ? R : never;
+type ArraySnapshotOutData<S extends readonly unknown[]> = number extends S["length"] ? Array<TypeToSnapshotOut<S[number]>> : {
+    [k in keyof S]: TypeToSnapshotOut<S[k]>;
 };
 export interface ArrayType<S extends readonly unknown[]> extends Type<"array", ArrayData<S>> {
 }
@@ -48,33 +47,32 @@ export type UndefinablePropsNames<T> = {
  * Computes the optional keys for an object type schema.
  * @ignore
  */
-export type ObjectOptionalKeys<S> = UndefinablePropsNames<{
-    [k in keyof S]: TypeToDataOpt<S[k]> extends infer R ? R : never;
+export type ObjectOptionalKeys<S> = {
+    [K in keyof S]: IsOptionalValue<TypeToDataOpt<S[K]>, K, never>;
+}[keyof S];
+type ObjectData<S, OK = ObjectOptionalKeys<S>> = SimplifyObject<{
+    [k in keyof S as k extends OK ? never : k]: TypeToData<S[k]>;
+} & {
+    [k in keyof S as k extends OK ? k : never]?: TypeToData<S[k]>;
+}>;
+type ObjectSnapshotInData<S, OK = ObjectOptionalKeys<S>> = SimplifyObject<{
+    [k in keyof S as k extends OK ? never : k]: TypeToSnapshotIn<S[k]>;
+} & {
+    [k in keyof S as k extends OK ? k : never]?: TypeToSnapshotIn<S[k]>;
+}>;
+type ObjectSnapshotOutData<S, OK = ObjectOptionalKeys<S>> = SimplifyObject<{
+    [k in keyof S as k extends OK ? never : k]: TypeToSnapshotOut<S[k]>;
+} & {
+    [k in keyof S as k extends OK ? k : never]?: TypeToSnapshotOut<S[k]>;
 }>;
-type ObjectData<S> = O.Optional<{
-    [k in keyof S]: TypeToData<S[k]> extends infer R ? R : never;
-}, ObjectOptionalKeys<S>>;
-type ObjectSnapshotInData<S> = O.Optional<{
-    [k in keyof S]: TypeToSnapshotIn<S[k]> extends infer R ? R : never;
-}, ObjectOptionalKeys<S>>;
-type ObjectSnapshotOutData<S> = O.Optional<{
-    [k in keyof S]: TypeToSnapshotOut<S[k]> extends infer R ? R : never;
-}, ObjectOptionalKeys<S>>;
-type RecordData<S> = {
-    [k: string]: TypeToData<S> extends infer R ? R : never;
-};
-type RecordSnapshotInData<S> = {
-    [k: string]: TypeToSnapshotIn<S> extends infer D ? D : never;
-};
-type RecordSnapshotOutData<S> = {
-    [k: string]: TypeToSnapshotOut<S> extends infer D ? D : never;
-};
 export interface ObjectType<S> extends Type<"object", ObjectData<S>> {
 }
 export interface ObjectTypeFunction {
     (): ObjectOfTypes;
 }
-export interface RecordType<S> extends Type<"record", RecordData<S>> {
+export interface RecordType<S> extends Type<"record", {
+    [k: string]: TypeToData<S>;
+}> {
 }
 export type AnyStandardType = IdentityType<any> | ModelType<any> | CodecType<any, any> | ArrayType<any> | ObjectType<any> | RecordType<any> | ObjectTypeFunction;
 export type AnyType = null | undefined | AnyNonValueType;
@@ -85,14 +83,20 @@ type ConstructorToSnapshotData<S> = ConstructorToType<S, string>;
 type TypeToDataLeaf<S> = S extends ModelClass<infer M> ? M : S extends {
     $$data: infer D;
 } ? D : ConstructorToData<S>;
-type TypeToSnapshotLeaf<S, Dir extends "in" | "out"> = S extends ModelClass<infer M> ? Dir extends "in" ? SnapshotInOf<M> : SnapshotOutOf<M> : S extends {
-    $$data: infer D;
-} ? D : ConstructorToSnapshotData<S>;
-export type TypeToData<S> = S extends ObjectTypeFunction ? ObjectType<ReturnType<S>>["$$data"] extends infer R ? R : never : TypeToDataLeaf<S>;
-export type TypeToSnapshotIn<S> = S extends ObjectTypeFunction ? ObjectSnapshotInData<ReturnType<S>> extends infer R ? R : never : S extends CodecType<any, infer D, any> ? D : S extends ArrayType<infer A> ? ArraySnapshotInData<A> : S extends ObjectType<infer O> ? ObjectSnapshotInData<O> : S extends RecordType<infer R> ? RecordSnapshotInData<R> : S extends ModelType<infer M> ? SnapshotInOf<M> : TypeToSnapshotLeaf<S, "in">;
-export type TypeToSnapshotOut<S> = S extends ObjectTypeFunction ? ObjectSnapshotOutData<ReturnType<S>> extends infer R ? R : never : S extends CodecType<any, any, infer D> ? D : S extends ArrayType<infer A> ? ArraySnapshotOutData<A> : S extends ObjectType<infer O> ? ObjectSnapshotOutData<O> : S extends RecordType<infer R> ? RecordSnapshotOutData<R> : S extends ModelType<infer M> ? SnapshotOutOf<M> : TypeToSnapshotLeaf<S, "out">;
+type TypeToSnapshotLeaf<S, Dir extends "in" | "out"> = S extends ModelClass<infer M> ? Dir extends "in" ? SnapshotInOf<M> : SnapshotOutOf<M> : ConstructorToSnapshotData<S>;
+export type TypeToData<S> = S extends ObjectTypeFunction ? ObjectType<ReturnType<S>>["$$data"] : TypeToDataLeaf<S>;
+export type TypeToSnapshotIn<S> = S extends ObjectTypeFunction ? ObjectSnapshotInData<ReturnType<S>> : S extends {
+    $$type: infer K;
+} ? K extends "codec" ? S["$$snapshotIn" & keyof S] : S extends ArrayType<infer A> ? ArraySnapshotInData<A> : S extends ObjectType<infer O> ? ObjectSnapshotInData<O> : S extends RecordType<infer R> ? {
+    [k: string]: TypeToSnapshotIn<R>;
+} : S extends ModelType<infer M> ? SnapshotInOf<M> : S["$$data" & keyof S] : TypeToSnapshotLeaf<S, "in">;
+export type TypeToSnapshotOut<S> = S extends ObjectTypeFunction ? ObjectSnapshotOutData<ReturnType<S>> : S extends {
+    $$type: infer K;
+} ? K extends "codec" ? S["$$snapshotOut" & keyof S] : S extends ArrayType<infer A> ? ArraySnapshotOutData<A> : S extends ObjectType<infer O> ? ObjectSnapshotOutData<O> : S extends RecordType<infer R> ? {
+    [k: string]: TypeToSnapshotOut<R>;
+} : S extends ModelType<infer M> ? SnapshotOutOf<M> : S["$$data" & keyof S] : TypeToSnapshotLeaf<S, "out">;
 /** @ignore */
 export type TypeToDataOpt<S> = S extends {
-    $$data: infer D;
-} ? D & undefined : never;
+    $$data: unknown;
+} ? S["$$data"] & undefined : never;
 export {};

package/dist/types/types/tProp.d.ts

@@ -6,8 +6,14 @@ type StoredRequiredPropMetadata<TType extends AnyType> = {
     $storedValueType: TypeToStoredData<TType>;
     $storedCreationValueType: TypeToStoredData<TType>;
 };
-type TypedMaybeOptionalModelProp<TType extends AnyType> = MaybeOptionalModelProp<TypeToData<TType>> & StoredRequiredPropMetadata<TType>;
-type TypedOptionalModelProp<TType extends AnyType> = OptionalModelProp<TypeToData<TType>> & {
+/**
+ * A model property created by `tProp` without a default value.
+ */
+export type TypedMaybeOptionalModelProp<TType extends AnyType> = MaybeOptionalModelProp<TypeToData<TType>> & StoredRequiredPropMetadata<TType>;
+/**
+ * A model property created by `tProp` with a default value.
+ */
+export type TypedOptionalModelProp<TType extends AnyType> = OptionalModelProp<TypeToData<TType>> & {
     $storedValueType: TypeToStoredData<TType>;
     $storedCreationValueType: TypeToStoredData<TType> | null | undefined;
     $typedFromSnapshotOverride: TypeToSnapshotIn<TType> | null | undefined;
@@ -67,7 +73,7 @@ export declare function tProp(defaultValue: boolean): TypedOptionalModelProp<typ
  * @param defaultFn Default value generator function.
  * @returns
  */
-export declare function tProp<TType extends AnyType>(type: TType, defaultFn: () => TypeToData<TType>): TypedOptionalModelProp<TType>;
+export declare function tProp<TType extends AnyType>(type: TType, defaultFn: () => NoInfer<TypeToData<TType>>): TypedOptionalModelProp<TType>;
 /**
  * Defines a model property using array syntax as a shorthand for `types.or(...)`,
  * with an optional function to generate a default value if the input snapshot /
@@ -84,7 +90,7 @@ export declare function tProp<TType extends AnyType>(type: TType, defaultFn: ()
  * @param defaultFn Default value generator function.
  * @returns
  */
-export declare function tProp<TType extends ReadonlyArray<AnyType>>(type: TType, defaultFn: () => TypeToData<TType[number]>): TypedOptionalModelProp<TType[number]>;
+export declare function tProp<TType extends ReadonlyArray<AnyType>>(type: TType, defaultFn: () => NoInfer<TypeToData<TType[number]>>): TypedOptionalModelProp<TType[number]>;
 /**
  * Defines a model property, with an optional default value
  * if the input snapshot / model creation data is `null` or `undefined` and with an associated type checker.
@@ -102,7 +108,7 @@ export declare function tProp<TType extends ReadonlyArray<AnyType>>(type: TType,
  * @param defaultValue Default value generator function.
  * @returns
  */
-export declare function tProp<TType extends AnyType>(type: TType, defaultValue: TypeToData<TType>): TypedOptionalModelProp<TType>;
+export declare function tProp<TType extends AnyType>(type: TType, defaultValue: NoInfer<TypeToData<TType>>): TypedOptionalModelProp<TType>;
 /**
  * Defines a model property using array syntax as a shorthand for `types.or(...)`,
  * with an optional default value if the input snapshot / model creation data is
@@ -119,7 +125,7 @@ export declare function tProp<TType extends AnyType>(type: TType, defaultValue:
  * @param defaultValue Default value.
  * @returns
  */
-export declare function tProp<TType extends ReadonlyArray<AnyType>>(type: TType, defaultValue: TypeToData<TType[number]>): TypedOptionalModelProp<TType[number]>;
+export declare function tProp<TType extends ReadonlyArray<AnyType>>(type: TType, defaultValue: NoInfer<TypeToData<TType[number]>>): TypedOptionalModelProp<TType[number]>;
 /**
  * Defines a model property with no default value and an associated type checker.
  *

package/dist/types/types/types.d.ts

@@ -49,9 +49,9 @@ export declare const types: {
     objectMap: typeof typesObjectMap;
     arraySet: typeof typesArraySet;
     tuple: typeof typesTuple;
-    bigint: import('./utility/typesCodecCore').CodecFromEncoded<StringConstructor, bigint>;
-    dateAsTimestamp: import('./utility/typesCodecCore').CodecFromEncoded<NumberConstructor, Date>;
-    dateAsIsoString: import('./utility/typesCodecCore').CodecFromEncoded<StringConstructor, Date>;
+    bigint: import('.').CodecFromEncoded<StringConstructor, bigint>;
+    dateAsTimestamp: import('.').CodecFromEncoded<NumberConstructor, Date>;
+    dateAsIsoString: import('.').CodecFromEncoded<StringConstructor, Date>;
     /**
      * @deprecated Prefer `types.mapFromArray(...)` for runtime `Map` values.
      */
@@ -64,9 +64,9 @@ export declare const types: {
      * @deprecated Prefer `types.mapFromObject(...)` for runtime `Map` values.
      */
     mapObject<T extends AnyType>(valueType: T): import('./schemas').RecordType<T>;
-    mapFromObject<T extends AnyType>(valueType: T): import('./utility/typesCodecCore').CodecFromEncoded<import('./schemas').RecordType<T>, Map<string, import('./schemas').TypeToData<T>>>;
-    mapFromArray<TKeyType extends AnyType, TValueType extends AnyType>(keyType: TKeyType, valueType: TValueType): import('./utility/typesCodecCore').CodecFromEncoded<import('./schemas').ArrayType<import('./schemas').ArrayType<[TKeyType, TValueType]>[]>, Map<import('./schemas').TypeToData<TKeyType>, import('./schemas').TypeToData<TValueType>>>;
-    setFromArray<T extends AnyType>(valueType: T): import('./utility/typesCodecCore').CodecFromEncoded<import('./schemas').ArrayType<T[]>, Set<import('./schemas').TypeToData<T>> | import('mobx').ObservableSet<import('./schemas').TypeToData<T>>>;
+    mapFromObject<T extends AnyType>(valueType: T): import('.').CodecFromEncoded<import('./schemas').RecordType<T>, Map<string, import('./schemas').TypeToData<T>>>;
+    mapFromArray<TKeyType extends AnyType, TValueType extends AnyType>(keyType: TKeyType, valueType: TValueType): import('.').CodecFromEncoded<import('./schemas').ArrayType<import('./schemas').ArrayType<[TKeyType, TValueType]>[]>, Map<import('./schemas').TypeToData<TKeyType>, import('./schemas').TypeToData<TValueType>>>;
+    setFromArray<T extends AnyType>(valueType: T): import('.').CodecFromEncoded<import('./schemas').ArrayType<T[]>, Set<import('./schemas').TypeToData<T>> | import('mobx').ObservableSet<import('./schemas').TypeToData<T>>>;
     /**
      * @deprecated Prefer `types.dateAsIsoString` instead.
      */

package/dist/types/types/utility/typeToStoredData.d.ts

@@ -1,12 +1,16 @@
-import { O } from 'ts-toolbelt';
-import { ArrayType, CodecType, ObjectOptionalKeys, ObjectType, ObjectTypeFunction, RecordType, TypeToData } from '../schemas';
-type ArrayStoredData<S extends readonly unknown[]> = number extends S["length"] ? Array<TypeToStoredData<S[number]> extends infer R ? R : never> : {
-    [k in keyof S]: TypeToStoredData<S[k]> extends infer R ? R : never;
+import { SimplifyObject } from '../../utils/types';
+import { ArrayType, ObjectOptionalKeys, ObjectType, ObjectTypeFunction, RecordType, TypeToData } from '../schemas';
+type ArrayStoredData<S extends readonly unknown[]> = number extends S["length"] ? Array<TypeToStoredData<S[number]>> : {
+    [k in keyof S]: TypeToStoredData<S[k]>;
 };
-type ObjectStoredData<S> = O.Optional<{
-    [k in keyof S]: TypeToStoredData<S[k]> extends infer R ? R : never;
-}, ObjectOptionalKeys<S>>;
-export type TypeToStoredData<S> = S extends ObjectTypeFunction ? ObjectStoredData<ReturnType<S>> extends infer R ? R : never : S extends CodecType<any, any, any, infer D> ? D : S extends ArrayType<infer A> ? ArrayStoredData<A> : S extends ObjectType<infer O> ? ObjectStoredData<O> : S extends RecordType<infer R> ? {
-    [k: string]: TypeToStoredData<R> extends infer D ? D : never;
-} : TypeToData<S>;
+type ObjectStoredData<S, OK = ObjectOptionalKeys<S>> = SimplifyObject<{
+    [k in keyof S as k extends OK ? never : k]: TypeToStoredData<S[k]>;
+} & {
+    [k in keyof S as k extends OK ? k : never]?: TypeToStoredData<S[k]>;
+}>;
+export type TypeToStoredData<S> = S extends ObjectTypeFunction ? ObjectStoredData<ReturnType<S>> : S extends {
+    $$type: infer K;
+} ? K extends "codec" ? S["$$storedData" & keyof S] : S extends ArrayType<infer A> ? ArrayStoredData<A> : S extends ObjectType<infer O> ? ObjectStoredData<O> : S extends RecordType<infer R> ? {
+    [k: string]: TypeToStoredData<R>;
+} : TypeToData<S> : TypeToData<S>;
 export {};

package/dist/types/types/utility/typesCodecCore.d.ts

@@ -28,6 +28,9 @@ type CodecConfig<TEncodedType extends AnyType, TRuntime> = {
     encodedType: TEncodedType;
     is(value: unknown): value is TRuntime;
 } & ModelPropTransform<TypeToData<TEncodedType>, TRuntime>;
+/**
+ * A codec type whose snapshot and stored forms are those of its encoded type.
+ */
 export type CodecFromEncoded<TEncodedType extends AnyType, TRuntime> = CodecType<TRuntime, TypeToSnapshotIn<TEncodedType>, TypeToSnapshotOut<TEncodedType>, TypeToStoredData<TEncodedType>>;
 export declare const identityRuntimeAdapter: RuntimeAdapter<any, any>;
 /**

package/dist/types/utils/ModelPool.d.ts

@@ -9,5 +9,4 @@ export declare class ModelPool {
     constructor(root: object);
     release(): void;
     findModelByTypeAndId(modelType: string, modelId: string | undefined): AnyModel | undefined;
-    findModelForSnapshot(sn: any): AnyModel | undefined;
 }

package/dist/types/utils/types.d.ts

@@ -37,3 +37,9 @@ export type IsNeverType<T, IfNever, IfNotNever> = [T] extends [never] ? IfNever
 export type Flatten<T> = T extends Record<any, any> ? {
     [P in keyof T]: T[P];
 } : T;
+/**
+ * @ignore
+ */
+export type SimplifyObject<T> = {
+    [P in keyof T]: T[P];
+} & {};

package/dist/types/wrappers/ArraySet.d.ts

@@ -21,6 +21,7 @@ export declare class ArraySet<V> extends arraySetBase implements Set<V> {
     entries(): ReturnType<Set<V>["entries"]>;
     [Symbol.iterator](): ReturnType<Set<V>[typeof Symbol.iterator]>;
     readonly [Symbol.toStringTag] = "ArraySet";
+    private toSetLike;
     union<U>(other: ReadonlySetLike<U>): Set<V | U>;
     intersection<U>(other: ReadonlySetLike<U>): Set<V & U>;
     difference<U>(other: ReadonlySetLike<U>): Set<V>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mobx-keystone",
-  "version": "2.1.0",
+  "version": "2.3.0",
   "description": "A MobX powered state management solution based on data trees with first class support for TypeScript, snapshots, patches and much more",
   "keywords": [
     "mobx",
@@ -61,23 +61,23 @@
     "test:perf": "pnpm run build && pnpm run test:perf:run",
     "test:perf:run": "cd perf_bench && NODE_ENV=production TS_NODE_COMPILER=@typescript/typescript6 /usr/bin/time node --expose-gc --require ts-node/register ./report.ts",
     "memtest": "cd perf_bench && NODE_ENV=production TS_NODE_COMPILER=@typescript/typescript6 node --expose-gc --require ts-node/register ./memtest.ts",
-    "build-docs": "shx rm -rf api-docs && node --import ./scripts/typedoc-typescript6-register.mjs ./node_modules/typedoc/dist/cli.js --options ./typedocconfig.js src/index.ts && shx rm -rf ../../apps/site/generated-static/api && shx mkdir -p ../../apps/site/generated-static/api && shx cp -R ./api-docs/* ../../apps/site/generated-static/api"
+    "build-docs": "shx rm -rf ../../apps/site/generated-api && node --import ./scripts/typedoc-typescript6-register.mjs ./node_modules/typedoc/dist/cli.js --options ./typedocconfig.js src/index.ts"
   },
   "peerDependencies": {
     "mobx": "^7.0.0 || ^6.0.0 || ^5.0.0 || ^4.0.0"
   },
   "devDependencies": {
-    "@babel/core": "^8.0.1",
+    "@babel/core": "^8.0.6",
     "@babel/plugin-proposal-decorators": "^8.0.2",
     "@babel/plugin-transform-class-properties": "^8.0.1",
-    "@babel/plugin-transform-class-static-block": "^8.0.1",
-    "@babel/plugin-transform-typescript": "^8.0.1",
-    "@babel/preset-env": "^8.0.2",
+    "@babel/plugin-transform-class-static-block": "^8.0.5",
+    "@babel/plugin-transform-typescript": "^8.0.6",
+    "@babel/preset-env": "^8.0.6",
     "@swc/core": "^1.16.2",
     "@types/babel__core": "^7.20.5",
-    "@types/node": "^26.4.1",
+    "@types/node": "^26.6.2",
     "@typescript/typescript6": "^6.0.2",
-    "@vitest/coverage-v8": "^5.0.0",
+    "@vitest/coverage-v8": "^5.0.1",
     "expect-type": "^1.4.0",
     "mobx-v4": "npm:mobx@^4.15.7",
     "mobx-v5": "npm:mobx@^5.15.7",
@@ -86,10 +86,12 @@
     "shx": "^0.4.0",
     "ts-node": "^10.9.2",
     "typedoc": "^0.28.20",
+    "typedoc-docusaurus-theme": "^1.4.3",
+    "typedoc-plugin-markdown": "^4.13.1",
     "typescript": "^7.0.2",
-    "vite": "^8.2.2",
-    "vite-plugin-dts": "^5.1.0",
-    "vitest": "^5.0.0"
+    "vite": "^8.3.1",
+    "vite-plugin-dts": "^5.1.1",
+    "vitest": "^5.0.1"
   },
   "dependencies": {
     "fast-deep-equal": "^3.1.3",