@jbrowse/mobx-state-tree 6.5.1 → 6.6.0

package/CHANGELOG.md

@@ -1,3 +1,73 @@
+## [6.6.0](https://github.com/GMOD/mobx-state-tree/compare/v6.5.2...v6.6.0) (2026-09-24)
+
+### Bug Fixes
+
+- Stop overwriting the wrapped type's create ([f8a73dc](https://github.com/GMOD/mobx-state-tree/commit/f8a73dc2f1963828ac51d8bf7ef3ee18d2bb416a))
+- Invalidate references whose target leaves with an ancestor ([fb1a8ee](https://github.com/GMOD/mobx-state-tree/commit/fb1a8ee3d2b73e4793737b8061ad2fa1ddf088aa))
+
+### Documentation
+
+- ADRs for the guard and processor-typing decisions; refresh CLAUDE.md ([a6a1776](https://github.com/GMOD/mobx-state-tree/commit/a6a17769cf715b8a2a8807e110ceedcda34680af))
+
+### Refactoring
+
+- Chain snapshot processors only where there are two ([133a750](https://github.com/GMOD/mobx-state-tree/commit/133a75096a5a266ac31cfd75730e9cd35fdae135))
+- Dedupe the node lifecycle and drop dead weight ([0f3f682](https://github.com/GMOD/mobx-state-tree/commit/0f3f68216b84d2080793f8b141ea4033d2c6f528))
+
+### Types
+
+- Infer enumeration members, export what public signatures name ([ba784a6](https://github.com/GMOD/mobx-state-tree/commit/ba784a6bbc750bc3e361273330d0be054264202e))
+- Variadic signatures in place of the generated overloads ([c8d062d](https://github.com/GMOD/mobx-state-tree/commit/c8d062d14fadc99c93dfd2c05fb2dd444f813227))
+- Snapshot processors pass through keys they do not own ([bc6c747](https://github.com/GMOD/mobx-state-tree/commit/bc6c7479f5b362c94db5d81de00afaad88c87d56))
+- IsArrayType/isMapType/isModelType stop narrowing unsoundly ([540e9f7](https://github.com/GMOD/mobx-state-tree/commit/540e9f74a5878d8c817dbc3521c42ef6a984ab0b))
+
+## [6.5.2](https://github.com/GMOD/mobx-state-tree/compare/v6.3.1...v6.5.2) (2026-09-19)
+
+### Bug Fixes
+
+- Reconcile through the loaded type instead of recreating the node ([3741894](https://github.com/GMOD/mobx-state-tree/commit/37418940fe11bc243b77d389f8e6e95cf77d2abe))
+
+### Chores
+
+- Delete the union overload generator, dead since the variadic signatures ([0591a1a](https://github.com/GMOD/mobx-state-tree/commit/0591a1a58e5cd200b0329c4c169973d434498057))
+- Create a GitHub release on publish, with git-cliff changelog notes ([3f1e16f](https://github.com/GMOD/mobx-state-tree/commit/3f1e16f455066ee8aabc975ea7bb72e328e3ad00))
+- One workflow, and no run without a reason ([920ee52](https://github.com/GMOD/mobx-state-tree/commit/920ee5280f315b3c3d44d3e7506c0744dbe5638d))
+- Enforce prettier, and keep it away from generated files ([801c920](https://github.com/GMOD/mobx-state-tree/commit/801c9204bed084e3a7031bcfa54cf19acb36e0f7))
+- Pin the toolchain the way the sibling GMOD repos do ([28ec9b0](https://github.com/GMOD/mobx-state-tree/commit/28ec9b0c4a00da23dfedbafe6c8b747d82e933c2))
+- Check every pull request, whatever its base ([b0d8421](https://github.com/GMOD/mobx-state-tree/commit/b0d8421adbec70859f7fa3a74b9e00266cd5cecd))
+
+### Documentation
+
+- Update stale mst-reflection note in CLAUDE.md ([b3daf01](https://github.com/GMOD/mobx-state-tree/commit/b3daf010bb4e6bad2fe688d55de16473774dec14))
+- Scale caveat on ADR 0005 — 262 hydrated schemas is an upper bound ([9c2fccc](https://github.com/GMOD/mobx-state-tree/commit/9c2fccc065a021eb4bafd6d6cc1e9386dea3522f))
+
+### Features
+
+- Late-bound membership via a members thunk, plus a name option ([af4084d](https://github.com/GMOD/mobx-state-tree/commit/af4084d35a40783c9af5fce6ee7c18b155e8b12f))
+- Extend types.compose to 11 model parts ([854d3f2](https://github.com/GMOD/mobx-state-tree/commit/854d3f2c6dd8bb13c0be28eb9ce0a8390bcf0992))
+
+### Performance Improvements
+
+- Hoist ModelType closure fields; stripDefault and union quick-match fast paths ([37a27ce](https://github.com/GMOD/mobx-state-tree/commit/37a27ce992a9e65d92b711129f1e92e6e2ec42bc))
+- Intern no-options unions on their member-identity tuple ([f0c516f](https://github.com/GMOD/mobx-state-tree/commit/f0c516f410cea8a42f68f50b497d627ee0cc5e6b))
+
+### Refactoring
+
+- Dead-code and consistency sweep ([7c14475](https://github.com/GMOD/mobx-state-tree/commit/7c1447565f470dc440622ee01a7e2a2395b0b11d))
+- Default BaseType.describe to the type name; drop nine equivalent overrides ([837350e](https://github.com/GMOD/mobx-state-tree/commit/837350e2ee9c38e80cf51ef288f5a09178eaad9a))
+
+### Tests
+
+- Stop the timer test rounding its way to a failure ([b24bcf5](https://github.com/GMOD/mobx-state-tree/commit/b24bcf5ef25bd927624c7cecba7ef1aed43f4732))
+- Fix what typechecking the suite turns up ([982bf00](https://github.com/GMOD/mobx-state-tree/commit/982bf00d3cfbd5d4c08e9f07fcd498b09d7f54d6))
+- Typecheck the test suite in CI ([d785a10](https://github.com/GMOD/mobx-state-tree/commit/d785a10bceef5e424dfba1ba97b92c0f3037e63b))
+
+### Types
+
+- Guard signatures, variadic union(), readonly validation results, stricter tsconfig ([43b086e](https://github.com/GMOD/mobx-state-tree/commit/43b086e1612a90e9264c99bfdc52710aab3fba38))
+- Restore generic-member inference with a leading 2-arity overload ([4759372](https://github.com/GMOD/mobx-state-tree/commit/475937291d73861f05492f369c425cf4c8d59dd1))
+- Allow a zero-arg create() when the type defaults its own snapshot ([800ce20](https://github.com/GMOD/mobx-state-tree/commit/800ce2098a91933a040cb557af4ceee4a79baf9a))
+
 ## [6.5.1](https://github.com/GMOD/mobx-state-tree/compare/v6.5.0...v6.5.1) (2026-08-22)
 
 ### Chores

package/dist/index.d.ts

@@ -339,7 +339,9 @@ declare function tryResolve<T = any>(target: IAnyStateTreeNode, path: string): T
 declare function getRelativePath(base: IAnyStateTreeNode, target: IAnyStateTreeNode): string;
 /**
  * Returns a deep copy of the given state tree node as new tree.
- * Shorthand for `snapshot(x) = getType(x).create(getSnapshot(x))`
+ * Like `getType(x).create(getSnapshot(x))`, except that a node wrapped in a
+ * `types.snapshotProcessor` is recreated through the processor, which
+ * `getType(x)` (the wrapped type) would skip.
  *
  * _Tip: clone will create a literal copy, including the same identifiers. To modify identifiers etc. during cloning, don't use clone but take a snapshot of the tree, modify it, and create new instance_
  *
@@ -515,13 +517,7 @@ declare function castToReferenceSnapshot<I>(instance: I): Extract<I, IAnyStateTr
  */
 declare function getNodeId(target: IAnyStateTreeNode): number;
 
-type HookSubscribers = {
-    [Hook.afterAttach]: (node: AnyNode, hook: Hook) => void;
-    [Hook.afterCreate]: (node: AnyNode, hook: Hook) => void;
-    [Hook.afterCreationFinalization]: (node: AnyNode, hook: Hook) => void;
-    [Hook.beforeDestroy]: (node: AnyNode, hook: Hook) => void;
-    [Hook.beforeDetach]: (node: AnyNode, hook: Hook) => void;
-};
+type HookSubscriber = (subject: AnyNode, hook: Hook) => void;
 /**
  * @internal
  * @hidden
@@ -544,8 +540,16 @@ declare abstract class BaseNode<C, S, T> {
     set state(val: NodeLifeCycle);
     private _hookSubscribers?;
     protected abstract fireHook(name: Hook): void;
-    protected fireInternalHook(name: Hook): void;
-    registerHook<H extends Hook>(hook: H, hookHandler: HookSubscribers[H]): IDisposer;
+    protected fireInternalHook(name: Hook, subject?: AnyNode): void;
+    /**
+     * Detaching a node takes its whole subtree out of the tree, but only the
+     * detached node's parent changes, so only it fires `beforeDetach` for real.
+     * Internal subscribers below it (reference watchers on a target) still need
+     * to know their node is leaving.
+     */
+    notifyDetachOf(subject: AnyObjectNode): void;
+    isWithin(ancestor: AnyNode): boolean;
+    registerHook(hook: Hook, hookHandler: HookSubscriber): IDisposer;
     private _parent;
     get parent(): AnyObjectNode | null;
     constructor(type: IAnyType, parent: AnyObjectNode | null, subpath: string, environment: any);
@@ -562,7 +566,7 @@ declare abstract class BaseNode<C, S, T> {
     get isAlive(): boolean;
     get isDetaching(): boolean;
     get observableIsAlive(): boolean;
-    abstract die(): void;
+    die(): void;
     abstract finalizeCreation(): void;
     protected baseFinalizeCreation(whenFinalized?: () => void): void;
     abstract finalizeDeath(): void;
@@ -598,6 +602,7 @@ declare class ObjectNode<C, S, T> extends BaseNode<C, S, T> {
     isProtectionEnabled: boolean;
     middlewares?: IMiddleware[];
     hasSnapshotPostProcessor: boolean;
+    snapshotProcessorType?: IAnyType;
     private _applyPatches?;
     applyPatches(patches: ReadonlyArray<IJsonPatch>): void;
     private _applySnapshot?;
@@ -617,6 +622,8 @@ declare class ObjectNode<C, S, T> extends BaseNode<C, S, T> {
     createObservableInstance(fireHooks?: boolean): void;
     get root(): AnyObjectNode;
     clearParent(): void;
+    notifyDetachOf(subject: AnyObjectNode): void;
+    private notifyChildrenOfDetach;
     setParent(newParent: AnyObjectNode, subpath: string): void;
     protected fireHook(name: Hook): void;
     private _snapshotUponDeath?;
@@ -649,7 +656,6 @@ declare class ObjectNode<C, S, T> extends BaseNode<C, S, T> {
     finalizeCreation(): void;
     detach(): void;
     private preboot;
-    die(): void;
     aboutToDie(): void;
     finalizeDeath(): void;
     onSnapshot(onChange: (snapshot: S) => void): IDisposer;
@@ -665,13 +671,7 @@ declare class ObjectNode<C, S, T> extends BaseNode<C, S, T> {
     private _addSnapshotReaction;
     private _removeSnapshotReaction;
     private _internalEvents?;
-    private _internalEventsHasSubscribers;
-    private _internalEventsRegister;
-    private _internalEventsHas;
-    private _internalEventsUnregister;
-    private _internalEventsEmit;
-    private _internalEventsClear;
-    private _internalEventsClearAll;
+    private internalEvents;
 }
 /**
  * @internal
@@ -735,9 +735,12 @@ interface IType<C, S, T> {
     /** @hidden */
     readonly [$type]: undefined;
     /**
-     * Friendly type name.
+     * Friendly type name. Read-only: types are shared (unions built from the
+     * same members are the same object), so renaming one renames it everywhere.
+     * Name a type where it is built instead — `types.model(name, ...)`,
+     * `.named()`, or the `name` option of `union`/`snapshotProcessor`.
      */
-    name: string;
+    readonly name: string;
     /**
      * Name of the identifier attribute or null if none.
      */
@@ -997,6 +1000,24 @@ declare abstract class ComplexType<C, S, T> extends BaseType<C, S, T, ObjectNode
  * @returns `true` if the value is a type.
  */
 declare function isType(value: unknown): value is IAnyType;
+/**
+ * The one type a wrapper hands everything to: what an `optional`,
+ * `stripDefault`, `refinement`, `snapshotProcessor` or (resolved) `late`
+ * wraps. `undefined` for any other type, including a union or a `resilient`,
+ * which pick a type per value.
+ *
+ * Resolves a `late` type's definition if it has not been read yet.
+ */
+declare function getWrappedType(type: IAnyType): IAnyType | undefined;
+/**
+ * Strips every wrapper {@link getWrappedType} sees through, down to the type
+ * that actually builds the value: for a complex type `T`,
+ * `getType(T.create(snapshot)) === unwrapType(T)`.
+ *
+ * `types.model({ xs: types.array(X) }).properties.xs`, for instance, is an
+ * `optional` whose unwrapped type is the array type.
+ */
+declare function unwrapType(type: IAnyType): IAnyType;
 
 interface IActionTrackingMiddlewareHooks<T> {
     filter?: (call: IMiddlewareEvent) => boolean;
@@ -1574,12 +1595,15 @@ interface IMSTMap<IT extends IAnyType> {
  */
 declare function map<IT extends IAnyType>(subtype: IT): IMapType<IT>;
 /**
- * Returns if a given value represents a map type.
- *
- * @param type
- * @returns `true` if it is a map type.
+ * Returns if a type is a map type, or wraps or unions one. For the map type
+ * itself, use {@link asMapType}.
  */
-declare function isMapType<Items extends IAnyType = IAnyType>(type: IAnyType): type is IMapType<Items>;
+declare function isMapType(type: IAnyType): boolean;
+/**
+ * The map type `type` builds its values with, seeing through the wrappers
+ * {@link unwrapType} does, or `undefined` if that is not a map type.
+ */
+declare function asMapType(type: IAnyType): IMapType<IAnyType> | undefined;
 
 /** @hidden */
 interface IMSTArray<IT extends IAnyType> extends IObservableArray<IT["Type"]> {
@@ -1597,7 +1621,7 @@ interface IMSTArray<IT extends IAnyType> extends IObservableArray<IT["Type"]> {
 }
 /** @hidden */
 interface IArrayType<IT extends IAnyType> extends IType<readonly IT["CreationType"][] | undefined, IT["SnapshotType"][], IMSTArray<IT>> {
-    hooks(hooks: IHooksGetter<IMSTArray<IAnyType>>): IArrayType<IT>;
+    hooks(hooks: IHooksGetter<IMSTArray<IT>>): IArrayType<IT>;
     /** the element type of the array */
     getChildType(): IAnyType;
 }
@@ -1627,12 +1651,15 @@ interface IArrayType<IT extends IAnyType> extends IType<readonly IT["CreationTyp
  */
 declare function array<IT extends IAnyType>(subtype: IT): IArrayType<IT>;
 /**
- * Returns if a given value represents an array type.
- *
- * @param type
- * @returns `true` if the type is an array type.
+ * Returns if a type is an array type, or wraps or unions one. For the array
+ * type itself, use {@link asArrayType}.
+ */
+declare function isArrayType(type: IAnyType): boolean;
+/**
+ * The array type `type` builds its values with, seeing through the wrappers
+ * {@link unwrapType} does, or `undefined` if that is not an array type.
  */
-declare function isArrayType<Items extends IAnyType = IAnyType>(type: IAnyType): type is IArrayType<Items>;
+declare function asArrayType(type: IAnyType): IArrayType<IAnyType> | undefined;
 
 /** @hidden */
 interface ModelProperties {
@@ -1693,6 +1720,16 @@ type ExtractCFromProps<P extends ModelProperties> = {
  */
 type _OverrideProps<PA extends ModelProperties, PB extends ModelProperties> = Omit<PA, keyof PB> & PB;
 /** @hidden */
+type _IsAny<T> = 0 extends 1 & T ? true : false;
+/**
+ * Snapshot processors own only the keys they were written for and pass the
+ * rest through, so a processor earlier in a model's chain also carries props
+ * added after it. Added props therefore replace their keys in a customized
+ * creation or snapshot type; an uncustomized one stays uncustomized.
+ * @hidden
+ */
+type _WithAddedKeys<Custom, Added> = _IsAny<Custom> extends true ? Custom : [Custom] extends [_NotCustomized] ? _NotCustomized : Omit<Custom, keyof Added> & Added;
+/** @hidden */
 type ModelCreationType<PC> = MaybeEmpty<{
     [P in DefinablePropsNames<PC>]: PC[P];
 }> & Partial<PC>;
@@ -1723,7 +1760,7 @@ interface ModelActions {
 interface IModelType<PROPS extends ModelProperties, OTHERS, CustomC = _NotCustomized, CustomS = _NotCustomized> extends IType<ModelCreationType2<PROPS, CustomC>, ModelSnapshotType2<PROPS, CustomS>, ModelInstanceType<PROPS, OTHERS>> {
     readonly properties: PROPS;
     named(newName: string): IModelType<PROPS, OTHERS, CustomC, CustomS>;
-    props<PROPS2 extends ModelPropertiesDeclaration>(props: PROPS2): IModelType<_OverrideProps<PROPS, ModelPropertiesDeclarationToProperties<PROPS2>>, OTHERS, CustomC, CustomS>;
+    props<PROPS2 extends ModelPropertiesDeclaration>(props: PROPS2): IModelType<_OverrideProps<PROPS, ModelPropertiesDeclarationToProperties<PROPS2>>, OTHERS, _WithAddedKeys<CustomC, ModelCreationType<ExtractCFromProps<ModelPropertiesDeclarationToProperties<PROPS2>>>>, _WithAddedKeys<CustomS, ModelSnapshotType<ModelPropertiesDeclarationToProperties<PROPS2>>>>;
     views<V extends object>(fn: (self: Instance<this>) => V): IModelType<PROPS, OTHERS & V, CustomC, CustomS>;
     actions<A extends ModelActions>(fn: (self: Instance<this>) => A): IModelType<PROPS, OTHERS & A, CustomC, CustomS>;
     volatile<TP extends object>(fn: (self: Instance<this>) => TP): IModelType<PROPS, OTHERS & TP, CustomC, CustomS>;
@@ -1743,30 +1780,54 @@ interface IAnyModelType extends IModelType<any, any, any, any> {
 declare function model<P extends ModelPropertiesDeclaration = {}>(name: string, properties?: P): IModelType<ModelPropertiesDeclarationToProperties<P>, {}>;
 declare function model<P extends ModelPropertiesDeclaration = {}>(properties?: P): IModelType<ModelPropertiesDeclarationToProperties<P>, {}>;
 /** @hidden */
-type _CustomJoin<A, B> = A extends _NotCustomized ? B : A & B;
-declare function compose<PA extends ModelProperties, OA, FCA, FSA, PB extends ModelProperties, OB, FCB, FSB>(name: string, A: IModelType<PA, OA, FCA, FSA>, B: IModelType<PB, OB, FCB, FSB>): IModelType<_OverrideProps<PA, PB>, OA & OB, _CustomJoin<FCA, FCB>, _CustomJoin<FSA, FSB>>;
-declare function compose<PA extends ModelProperties, OA, FCA, FSA, PB extends ModelProperties, OB, FCB, FSB>(A: IModelType<PA, OA, FCA, FSA>, B: IModelType<PB, OB, FCB, FSB>): IModelType<_OverrideProps<PA, PB>, OA & OB, _CustomJoin<FCA, FCB>, _CustomJoin<FSA, FSB>>;
-declare function compose<PA extends ModelProperties, OA, FCA, FSA, PB extends ModelProperties, OB, FCB, FSB, PC extends ModelProperties, OC, FCC, FSC>(name: string, A: IModelType<PA, OA, FCA, FSA>, B: IModelType<PB, OB, FCB, FSB>, C: IModelType<PC, OC, FCC, FSC>): IModelType<_OverrideProps<_OverrideProps<PA, PB>, PC>, OA & OB & OC, _CustomJoin<FCA, _CustomJoin<FCB, FCC>>, _CustomJoin<FSA, _CustomJoin<FSB, FSC>>>;
-declare function compose<PA extends ModelProperties, OA, FCA, FSA, PB extends ModelProperties, OB, FCB, FSB, PC extends ModelProperties, OC, FCC, FSC>(A: IModelType<PA, OA, FCA, FSA>, B: IModelType<PB, OB, FCB, FSB>, C: IModelType<PC, OC, FCC, FSC>): IModelType<_OverrideProps<_OverrideProps<PA, PB>, PC>, OA & OB & OC, _CustomJoin<FCA, _CustomJoin<FCB, FCC>>, _CustomJoin<FSA, _CustomJoin<FSB, FSC>>>;
-declare function compose<PA extends ModelProperties, OA, FCA, FSA, PB extends ModelProperties, OB, FCB, FSB, PC extends ModelProperties, OC, FCC, FSC, PD extends ModelProperties, OD, FCD, FSD>(name: string, A: IModelType<PA, OA, FCA, FSA>, B: IModelType<PB, OB, FCB, FSB>, C: IModelType<PC, OC, FCC, FSC>, D: IModelType<PD, OD, FCD, FSD>): IModelType<_OverrideProps<_OverrideProps<_OverrideProps<PA, PB>, PC>, PD>, OA & OB & OC & OD, _CustomJoin<FCA, _CustomJoin<FCB, _CustomJoin<FCC, FCD>>>, _CustomJoin<FSA, _CustomJoin<FSB, _CustomJoin<FSC, FSD>>>>;
-declare function compose<PA extends ModelProperties, OA, FCA, FSA, PB extends ModelProperties, OB, FCB, FSB, PC extends ModelProperties, OC, FCC, FSC, PD extends ModelProperties, OD, FCD, FSD>(A: IModelType<PA, OA, FCA, FSA>, B: IModelType<PB, OB, FCB, FSB>, C: IModelType<PC, OC, FCC, FSC>, D: IModelType<PD, OD, FCD, FSD>): IModelType<_OverrideProps<_OverrideProps<_OverrideProps<PA, PB>, PC>, PD>, OA & OB & OC & OD, _CustomJoin<FCA, _CustomJoin<FCB, _CustomJoin<FCC, FCD>>>, _CustomJoin<FSA, _CustomJoin<FSB, _CustomJoin<FSC, FSD>>>>;
-declare function compose<PA extends ModelProperties, OA, FCA, FSA, PB extends ModelProperties, OB, FCB, FSB, PC extends ModelProperties, OC, FCC, FSC, PD extends ModelProperties, OD, FCD, FSD, PE extends ModelProperties, OE, FCE, FSE>(name: string, A: IModelType<PA, OA, FCA, FSA>, B: IModelType<PB, OB, FCB, FSB>, C: IModelType<PC, OC, FCC, FSC>, D: IModelType<PD, OD, FCD, FSD>, E: IModelType<PE, OE, FCE, FSE>): IModelType<_OverrideProps<_OverrideProps<_OverrideProps<_OverrideProps<PA, PB>, PC>, PD>, PE>, OA & OB & OC & OD & OE, _CustomJoin<FCA, _CustomJoin<FCB, _CustomJoin<FCC, _CustomJoin<FCD, FCE>>>>, _CustomJoin<FSA, _CustomJoin<FSB, _CustomJoin<FSC, _CustomJoin<FSD, FSE>>>>>;
-declare function compose<PA extends ModelProperties, OA, FCA, FSA, PB extends ModelProperties, OB, FCB, FSB, PC extends ModelProperties, OC, FCC, FSC, PD extends ModelProperties, OD, FCD, FSD, PE extends ModelProperties, OE, FCE, FSE>(A: IModelType<PA, OA, FCA, FSA>, B: IModelType<PB, OB, FCB, FSB>, C: IModelType<PC, OC, FCC, FSC>, D: IModelType<PD, OD, FCD, FSD>, E: IModelType<PE, OE, FCE, FSE>): IModelType<_OverrideProps<_OverrideProps<_OverrideProps<_OverrideProps<PA, PB>, PC>, PD>, PE>, OA & OB & OC & OD & OE, _CustomJoin<FCA, _CustomJoin<FCB, _CustomJoin<FCC, _CustomJoin<FCD, FCE>>>>, _CustomJoin<FSA, _CustomJoin<FSB, _CustomJoin<FSC, _CustomJoin<FSD, FSE>>>>>;
-declare function compose<PA extends ModelProperties, OA, FCA, FSA, PB extends ModelProperties, OB, FCB, FSB, PC extends ModelProperties, OC, FCC, FSC, PD extends ModelProperties, OD, FCD, FSD, PE extends ModelProperties, OE, FCE, FSE, PF extends ModelProperties, OF, FCF, FSF>(name: string, A: IModelType<PA, OA, FCA, FSA>, B: IModelType<PB, OB, FCB, FSB>, C: IModelType<PC, OC, FCC, FSC>, D: IModelType<PD, OD, FCD, FSD>, E: IModelType<PE, OE, FCE, FSE>, F: IModelType<PF, OF, FCF, FSF>): IModelType<_OverrideProps<_OverrideProps<_OverrideProps<_OverrideProps<_OverrideProps<PA, PB>, PC>, PD>, PE>, PF>, OA & OB & OC & OD & OE & OF, _CustomJoin<FCA, _CustomJoin<FCB, _CustomJoin<FCC, _CustomJoin<FCD, _CustomJoin<FCE, FCF>>>>>, _CustomJoin<FSA, _CustomJoin<FSB, _CustomJoin<FSC, _CustomJoin<FSD, _CustomJoin<FSE, FSF>>>>>>;
-declare function compose<PA extends ModelProperties, OA, FCA, FSA, PB extends ModelProperties, OB, FCB, FSB, PC extends ModelProperties, OC, FCC, FSC, PD extends ModelProperties, OD, FCD, FSD, PE extends ModelProperties, OE, FCE, FSE, PF extends ModelProperties, OF, FCF, FSF>(A: IModelType<PA, OA, FCA, FSA>, B: IModelType<PB, OB, FCB, FSB>, C: IModelType<PC, OC, FCC, FSC>, D: IModelType<PD, OD, FCD, FSD>, E: IModelType<PE, OE, FCE, FSE>, F: IModelType<PF, OF, FCF, FSF>): IModelType<_OverrideProps<_OverrideProps<_OverrideProps<_OverrideProps<_OverrideProps<PA, PB>, PC>, PD>, PE>, PF>, OA & OB & OC & OD & OE & OF, _CustomJoin<FCA, _CustomJoin<FCB, _CustomJoin<FCC, _CustomJoin<FCD, _CustomJoin<FCE, FCF>>>>>, _CustomJoin<FSA, _CustomJoin<FSB, _CustomJoin<FSC, _CustomJoin<FSD, _CustomJoin<FSE, FSF>>>>>>;
-declare function compose<PA extends ModelProperties, OA, FCA, FSA, PB extends ModelProperties, OB, FCB, FSB, PC extends ModelProperties, OC, FCC, FSC, PD extends ModelProperties, OD, FCD, FSD, PE extends ModelProperties, OE, FCE, FSE, PF extends ModelProperties, OF, FCF, FSF, PG extends ModelProperties, OG, FCG, FSG>(name: string, A: IModelType<PA, OA, FCA, FSA>, B: IModelType<PB, OB, FCB, FSB>, C: IModelType<PC, OC, FCC, FSC>, D: IModelType<PD, OD, FCD, FSD>, E: IModelType<PE, OE, FCE, FSE>, F: IModelType<PF, OF, FCF, FSF>, G: IModelType<PG, OG, FCG, FSG>): IModelType<_OverrideProps<_OverrideProps<_OverrideProps<_OverrideProps<_OverrideProps<_OverrideProps<PA, PB>, PC>, PD>, PE>, PF>, PG>, OA & OB & OC & OD & OE & OF & OG, _CustomJoin<FCA, _CustomJoin<FCB, _CustomJoin<FCC, _CustomJoin<FCD, _CustomJoin<FCE, _CustomJoin<FCF, FCG>>>>>>, _CustomJoin<FSA, _CustomJoin<FSB, _CustomJoin<FSC, _CustomJoin<FSD, _CustomJoin<FSE, _CustomJoin<FSF, FSG>>>>>>>;
-declare function compose<PA extends ModelProperties, OA, FCA, FSA, PB extends ModelProperties, OB, FCB, FSB, PC extends ModelProperties, OC, FCC, FSC, PD extends ModelProperties, OD, FCD, FSD, PE extends ModelProperties, OE, FCE, FSE, PF extends ModelProperties, OF, FCF, FSF, PG extends ModelProperties, OG, FCG, FSG>(A: IModelType<PA, OA, FCA, FSA>, B: IModelType<PB, OB, FCB, FSB>, C: IModelType<PC, OC, FCC, FSC>, D: IModelType<PD, OD, FCD, FSD>, E: IModelType<PE, OE, FCE, FSE>, F: IModelType<PF, OF, FCF, FSF>, G: IModelType<PG, OG, FCG, FSG>): IModelType<_OverrideProps<_OverrideProps<_OverrideProps<_OverrideProps<_OverrideProps<_OverrideProps<PA, PB>, PC>, PD>, PE>, PF>, PG>, OA & OB & OC & OD & OE & OF & OG, _CustomJoin<FCA, _CustomJoin<FCB, _CustomJoin<FCC, _CustomJoin<FCD, _CustomJoin<FCE, _CustomJoin<FCF, FCG>>>>>>, _CustomJoin<FSA, _CustomJoin<FSB, _CustomJoin<FSC, _CustomJoin<FSD, _CustomJoin<FSE, _CustomJoin<FSF, FSG>>>>>>>;
-declare function compose<PA extends ModelProperties, OA, FCA, FSA, PB extends ModelProperties, OB, FCB, FSB, PC extends ModelProperties, OC, FCC, FSC, PD extends ModelProperties, OD, FCD, FSD, PE extends ModelProperties, OE, FCE, FSE, PF extends ModelProperties, OF, FCF, FSF, PG extends ModelProperties, OG, FCG, FSG, PH extends ModelProperties, OH, FCH, FSH>(name: string, A: IModelType<PA, OA, FCA, FSA>, B: IModelType<PB, OB, FCB, FSB>, C: IModelType<PC, OC, FCC, FSC>, D: IModelType<PD, OD, FCD, FSD>, E: IModelType<PE, OE, FCE, FSE>, F: IModelType<PF, OF, FCF, FSF>, G: IModelType<PG, OG, FCG, FSG>, H: IModelType<PH, OH, FCH, FSH>): IModelType<_OverrideProps<_OverrideProps<_OverrideProps<_OverrideProps<_OverrideProps<_OverrideProps<_OverrideProps<PA, PB>, PC>, PD>, PE>, PF>, PG>, PH>, OA & OB & OC & OD & OE & OF & OG & OH, _CustomJoin<FCA, _CustomJoin<FCB, _CustomJoin<FCC, _CustomJoin<FCD, _CustomJoin<FCE, _CustomJoin<FCF, _CustomJoin<FCG, FCH>>>>>>>, _CustomJoin<FSA, _CustomJoin<FSB, _CustomJoin<FSC, _CustomJoin<FSD, _CustomJoin<FSE, _CustomJoin<FSF, _CustomJoin<FSG, FSH>>>>>>>>;
-declare function compose<PA extends ModelProperties, OA, FCA, FSA, PB extends ModelProperties, OB, FCB, FSB, PC extends ModelProperties, OC, FCC, FSC, PD extends ModelProperties, OD, FCD, FSD, PE extends ModelProperties, OE, FCE, FSE, PF extends ModelProperties, OF, FCF, FSF, PG extends ModelProperties, OG, FCG, FSG, PH extends ModelProperties, OH, FCH, FSH>(A: IModelType<PA, OA, FCA, FSA>, B: IModelType<PB, OB, FCB, FSB>, C: IModelType<PC, OC, FCC, FSC>, D: IModelType<PD, OD, FCD, FSD>, E: IModelType<PE, OE, FCE, FSE>, F: IModelType<PF, OF, FCF, FSF>, G: IModelType<PG, OG, FCG, FSG>, H: IModelType<PH, OH, FCH, FSH>): IModelType<_OverrideProps<_OverrideProps<_OverrideProps<_OverrideProps<_OverrideProps<_OverrideProps<_OverrideProps<PA, PB>, PC>, PD>, PE>, PF>, PG>, PH>, OA & OB & OC & OD & OE & OF & OG & OH, _CustomJoin<FCA, _CustomJoin<FCB, _CustomJoin<FCC, _CustomJoin<FCD, _CustomJoin<FCE, _CustomJoin<FCF, _CustomJoin<FCG, FCH>>>>>>>, _CustomJoin<FSA, _CustomJoin<FSB, _CustomJoin<FSC, _CustomJoin<FSD, _CustomJoin<FSE, _CustomJoin<FSF, _CustomJoin<FSG, FSH>>>>>>>>;
-declare function compose<PA extends ModelProperties, OA, FCA, FSA, PB extends ModelProperties, OB, FCB, FSB, PC extends ModelProperties, OC, FCC, FSC, PD extends ModelProperties, OD, FCD, FSD, PE extends ModelProperties, OE, FCE, FSE, PF extends ModelProperties, OF, FCF, FSF, PG extends ModelProperties, OG, FCG, FSG, PH extends ModelProperties, OH, FCH, FSH, PI extends ModelProperties, OI, FCI, FSI>(name: string, A: IModelType<PA, OA, FCA, FSA>, B: IModelType<PB, OB, FCB, FSB>, C: IModelType<PC, OC, FCC, FSC>, D: IModelType<PD, OD, FCD, FSD>, E: IModelType<PE, OE, FCE, FSE>, F: IModelType<PF, OF, FCF, FSF>, G: IModelType<PG, OG, FCG, FSG>, H: IModelType<PH, OH, FCH, FSH>, I: IModelType<PI, OI, FCI, FSI>): IModelType<_OverrideProps<_OverrideProps<_OverrideProps<_OverrideProps<_OverrideProps<_OverrideProps<_OverrideProps<_OverrideProps<PA, PB>, PC>, PD>, PE>, PF>, PG>, PH>, PI>, OA & OB & OC & OD & OE & OF & OG & OH & OI, _CustomJoin<FCA, _CustomJoin<FCB, _CustomJoin<FCC, _CustomJoin<FCD, _CustomJoin<FCE, _CustomJoin<FCF, _CustomJoin<FCG, _CustomJoin<FCH, FCI>>>>>>>>, _CustomJoin<FSA, _CustomJoin<FSB, _CustomJoin<FSC, _CustomJoin<FSD, _CustomJoin<FSE, _CustomJoin<FSF, _CustomJoin<FSG, _CustomJoin<FSH, FSI>>>>>>>>>;
-declare function compose<PA extends ModelProperties, OA, FCA, FSA, PB extends ModelProperties, OB, FCB, FSB, PC extends ModelProperties, OC, FCC, FSC, PD extends ModelProperties, OD, FCD, FSD, PE extends ModelProperties, OE, FCE, FSE, PF extends ModelProperties, OF, FCF, FSF, PG extends ModelProperties, OG, FCG, FSG, PH extends ModelProperties, OH, FCH, FSH, PI extends ModelProperties, OI, FCI, FSI>(A: IModelType<PA, OA, FCA, FSA>, B: IModelType<PB, OB, FCB, FSB>, C: IModelType<PC, OC, FCC, FSC>, D: IModelType<PD, OD, FCD, FSD>, E: IModelType<PE, OE, FCE, FSE>, F: IModelType<PF, OF, FCF, FSF>, G: IModelType<PG, OG, FCG, FSG>, H: IModelType<PH, OH, FCH, FSH>, I: IModelType<PI, OI, FCI, FSI>): IModelType<_OverrideProps<_OverrideProps<_OverrideProps<_OverrideProps<_OverrideProps<_OverrideProps<_OverrideProps<_OverrideProps<PA, PB>, PC>, PD>, PE>, PF>, PG>, PH>, PI>, OA & OB & OC & OD & OE & OF & OG & OH & OI, _CustomJoin<FCA, _CustomJoin<FCB, _CustomJoin<FCC, _CustomJoin<FCD, _CustomJoin<FCE, _CustomJoin<FCF, _CustomJoin<FCG, _CustomJoin<FCH, FCI>>>>>>>>, _CustomJoin<FSA, _CustomJoin<FSB, _CustomJoin<FSC, _CustomJoin<FSD, _CustomJoin<FSE, _CustomJoin<FSF, _CustomJoin<FSG, _CustomJoin<FSH, FSI>>>>>>>>>;
-/**
- * Returns if a given value represents a model type.
- *
- * @param type
- * @returns
+type _ComposableParts = readonly [
+    IAnyModelType,
+    IAnyModelType,
+    ...IAnyModelType[]
+];
+/**
+ * Props override left to right, as `compose` merges them at runtime.
+ * @hidden
+ */
+type _ComposedProps<Acc extends ModelProperties, Rest> = Rest extends readonly [IModelType<infer P, any, any, any>, ...infer Tail] ? _ComposedProps<_OverrideProps<Acc, P>, Tail> : Acc;
+/** @hidden */
+type _ComposedOthers<Parts> = Parts extends readonly [
+    IModelType<any, infer O, any, any>,
+    ...infer Tail
+] ? O & _ComposedOthers<Tail> : unknown;
+/**
+ * A composed part's snapshot processors are handed the whole snapshot but own
+ * only their part's keys, passing the other parts' through — the only way a
+ * part can process without knowing what it is composed with. So a part with a
+ * custom creation (`"C"`) or snapshot (`"S"`) type replaces its own props' keys
+ * in the merged type. `_NotCustomized` when no part customizes.
+ * @hidden
+ */
+type _ComposedCustom<Parts, Which extends "C" | "S", Acc, Customized extends boolean = false> = Parts extends readonly [
+    IModelType<infer P, any, infer C, infer S>,
+    ...infer Tail
+] ? (Which extends "C" ? C : S) extends _NotCustomized ? _ComposedCustom<Tail, Which, Acc, Customized> : _ComposedCustom<Tail, Which, Omit<Acc, keyof P> & (Which extends "C" ? C : S), true> : Customized extends true ? Acc : _NotCustomized;
+/** @hidden */
+type _ComposedModel<Props extends ModelProperties, Parts> = IModelType<Props, _ComposedOthers<Parts>, _ComposedCustom<Parts, "C", ModelCreationType<ExtractCFromProps<Props>>>, _ComposedCustom<Parts, "S", ModelSnapshotType<Props>>>;
+/** @hidden */
+/**
+ * A part typed `any` makes the composition `any`-shaped: inferring from `any`
+ * would yield the parameters' constraints instead, an empty model.
+ * @hidden
  */
-declare function isModelType<IT extends IAnyModelType = IAnyModelType>(type: IAnyType): type is IT;
+type _Composed<Parts extends _ComposableParts> = true extends _IsAny<Parts[number]> ? IAnyModelType : Parts extends readonly [IModelType<infer P, any, any, any>, ...infer Tail] ? _ComposedModel<_ComposedProps<P, Tail>, Parts> : never;
+declare function compose<Parts extends _ComposableParts>(name: string, ...parts: Parts): _Composed<Parts>;
+declare function compose<Parts extends _ComposableParts>(...parts: Parts): _Composed<Parts>;
+/**
+ * Returns if a type is a model type, or wraps or unions one. For the model
+ * type itself, use {@link asModelType}.
+ */
+declare function isModelType(type: IAnyType): boolean;
+/**
+ * The model type `type` builds its values with, seeing through the wrappers
+ * {@link unwrapType} does, or `undefined` if that is not a model type.
+ */
+declare function asModelType(type: IAnyType): IAnyModelType | undefined;
 /**
  * `extendInstance` - attaches additional actions, views and volatile state to an
  * already-created model instance, using the same instantiation machinery as
@@ -1796,11 +1857,9 @@ declare function extendInstance<T extends IAnyStateTreeNode>(instance: T, fn: (s
 /**
  * Returns if a given value represents a primitive type.
  *
- * Returns a plain `boolean`, not a `type is IT` predicate: with the parameter
- * typed as `IT`, narrowing to `IT` was a no-op in the positive branch while
- * collapsing the negative one to `never`, so `if (!isX(t)) { t.name }` failed
- * to compile. Guards with a distinct narrowing target (`isArrayType`,
- * `isMapType`, `isModelType`) keep their predicate.
+ * Like every `isXType` guard it reads the type's flags, which wrappers and
+ * unions inherit from what they hold, so it is also true for a type that wraps
+ * or unions one. Use {@link unwrapType} to get at the type itself.
  *
  * @param type
  * @returns
@@ -1835,11 +1894,9 @@ declare function literal<S extends Primitives>(value: S): ILiteralType<S>;
 /**
  * Returns if a given value represents a literal type.
  *
- * Returns a plain `boolean`, not a `type is IT` predicate: with the parameter
- * typed as `IT`, narrowing to `IT` was a no-op in the positive branch while
- * collapsing the negative one to `never`, so `if (!isX(t)) { t.name }` failed
- * to compile. Guards with a distinct narrowing target (`isArrayType`,
- * `isMapType`, `isModelType`) keep their predicate.
+ * Like every `isXType` guard it reads the type's flags, which wrappers and
+ * unions inherit from what they hold, so it is also true for a type that wraps
+ * or unions one. Use {@link unwrapType} to get at the type itself.
  *
  * @param type
  * @returns
@@ -1851,11 +1908,9 @@ declare function refinement<IT extends IAnyType>(type: IT, predicate: (snapshot:
 /**
  * Returns if a given value is a refinement type.
  *
- * Returns a plain `boolean`, not a `type is IT` predicate: with the parameter
- * typed as `IT`, narrowing to `IT` was a no-op in the positive branch while
- * collapsing the negative one to `never`, so `if (!isX(t)) { t.name }` failed
- * to compile. Guards with a distinct narrowing target (`isArrayType`,
- * `isMapType`, `isModelType`) keep their predicate.
+ * Like every `isXType` guard it reads the type's flags, which wrappers and
+ * unions inherit from what they hold, so it is also true for a type that wraps
+ * or unions one. Use {@link unwrapType} to get at the type itself.
  *
  * @param type
  * @returns
@@ -1864,8 +1919,8 @@ declare function isRefinementType(type: IAnyType): boolean;
 
 /** @hidden */
 type UnionStringArray<T extends readonly string[]> = T[number];
-declare function enumeration<T extends readonly string[]>(options: T): ISimpleType<UnionStringArray<T>>;
-declare function enumeration<T extends string>(name: string, options: T[]): ISimpleType<UnionStringArray<T[]>>;
+declare function enumeration<T extends string>(options: readonly T[]): ISimpleType<T>;
+declare function enumeration<T extends string>(name: string, options: readonly T[]): ISimpleType<T>;
 
 type ITypeDispatcher = (snapshot: any) => IAnyType;
 interface UnionOptions {
@@ -1905,24 +1960,18 @@ declare function union(dispatchOrType: UnionOptions | IAnyType, ...otherTypes: I
 /**
  * Returns if a given value represents a union type.
  *
- * Returns a plain `boolean`, not a `type is IT` predicate: with the parameter
- * typed as `IT`, narrowing to `IT` was a no-op in the positive branch while
- * collapsing the negative one to `never`, so `if (!isX(t)) { t.name }` failed
- * to compile. Guards with a distinct narrowing target (`isArrayType`,
- * `isMapType`, `isModelType`) keep their predicate.
+ * Like every `isXType` guard it reads the type's flags, which wrappers and
+ * unions inherit from what they hold, so it is also true for a type that wraps
+ * or unions one. Use {@link unwrapType} to get at the type itself.
  *
  * @param type
  * @returns
  */
 declare function isUnionType(type: IAnyType): boolean;
 /**
- * Returns the member types of a union.
- *
- * Wrapper types (`optional`, `refinement`, `late`) inherit the union flag from
- * the type they wrap, so `isUnionType` is true for e.g. an optional-of-union,
- * but their `getSubTypes()` reports the single wrapped type rather than the
- * union's members. This drills through those wrappers until the union's member
- * array surfaces.
+ * Returns the member types of a union, seeing through the wrappers
+ * {@link unwrapType} does: `isUnionType` is also true for e.g. an
+ * optional-of-union.
  *
  * @param type a type for which `isUnionType` is true
  * @returns the array of member types of the underlying union
@@ -1944,11 +1993,9 @@ declare function optional<IT extends IAnyType, OptionalVals extends ValidOptiona
 /**
  * Returns if a value represents an optional type.
  *
- * Returns a plain `boolean`, not a `type is IT` predicate: with the parameter
- * typed as `IT`, narrowing to `IT` was a no-op in the positive branch while
- * collapsing the negative one to `never`, so `if (!isX(t)) { t.name }` failed
- * to compile. Guards with a distinct narrowing target (`isArrayType`,
- * `isMapType`, `isModelType`) keep their predicate.
+ * Like every `isXType` guard it reads the type's flags, which wrappers and
+ * unions inherit from what they hold, so it is also true for a type that wraps
+ * or unions one. Use {@link unwrapType} to get at the type itself.
  *
  * @param type
  * @returns
@@ -1997,11 +2044,9 @@ declare function late<T extends IAnyType>(name: string, type: () => T): T;
 /**
  * Returns if a given value represents a late type.
  *
- * Returns a plain `boolean`, not a `type is IT` predicate: with the parameter
- * typed as `IT`, narrowing to `IT` was a no-op in the positive branch while
- * collapsing the negative one to `never`, so `if (!isX(t)) { t.name }` failed
- * to compile. Guards with a distinct narrowing target (`isArrayType`,
- * `isMapType`, `isModelType`) keep their predicate.
+ * Like every `isXType` guard it reads the type's flags, which wrappers and
+ * unions inherit from what they hold, so it is also true for a type that wraps
+ * or unions one. Use {@link unwrapType} to get at the type itself.
  *
  * @param type
  * @returns
@@ -2020,11 +2065,9 @@ declare function frozen<T = any>(): IType<T, T, T>;
 /**
  * Returns if a given value represents a frozen type.
  *
- * Returns a plain `boolean`, not a `type is IT` predicate: with the parameter
- * typed as `IT`, narrowing to `IT` was a no-op in the positive branch while
- * collapsing the negative one to `never`, so `if (!isX(t)) { t.name }` failed
- * to compile. Guards with a distinct narrowing target (`isArrayType`,
- * `isMapType`, `isModelType`) keep their predicate.
+ * Like every `isXType` guard it reads the type's flags, which wrappers and
+ * unions inherit from what they hold, so it is also true for a type that wraps
+ * or unions one. Use {@link unwrapType} to get at the type itself.
  *
  * @param type
  * @returns
@@ -2061,11 +2104,9 @@ declare function reference<IT extends IAnyComplexType>(subType: IT, options?: Re
 /**
  * Returns if a given value represents a reference type.
  *
- * Returns a plain `boolean`, not a `type is IT` predicate: with the parameter
- * typed as `IT`, narrowing to `IT` was a no-op in the positive branch while
- * collapsing the negative one to `never`, so `if (!isX(t)) { t.name }` failed
- * to compile. Guards with a distinct narrowing target (`isArrayType`,
- * `isMapType`, `isModelType`) keep their predicate.
+ * Like every `isXType` guard it reads the type's flags, which wrappers and
+ * unions inherit from what they hold, so it is also true for a type that wraps
+ * or unions one. Use {@link unwrapType} to get at the type itself.
  *
  * @param type
  * @returns
@@ -2083,11 +2124,9 @@ declare function safeReference<IT extends IAnyComplexType>(subType: IT, options?
 /**
  * Returns if a given value represents an identifier type.
  *
- * Returns a plain `boolean`, not a `type is IT` predicate: with the parameter
- * typed as `IT`, narrowing to `IT` was a no-op in the positive branch while
- * collapsing the negative one to `never`, so `if (!isX(t)) { t.name }` failed
- * to compile. Guards with a distinct narrowing target (`isArrayType`,
- * `isMapType`, `isModelType`) keep their predicate.
+ * Like every `isXType` guard it reads the type's flags, which wrappers and
+ * unions inherit from what they hold, so it is also true for a type that wraps
+ * or unions one. Use {@link unwrapType} to get at the type itself.
  *
  * @param type
  * @returns
@@ -2210,5 +2249,5 @@ declare const types: {
     resilient: typeof resilient;
 };
 
-export { addDisposer, addMiddleware, applyAction, applyPatch, applySnapshot, cannotDetermineSubtype, cast, castFlowReturn, castToReferenceSnapshot, castToSnapshot, clone, createActionTrackingMiddleware, createActionTrackingMiddleware2, decorate, destroy, detach, escapeJsonPath, extendInstance, flow, getChildType, getEnv, getIdentifier, getLivelinessChecking, getMembers, getNodeId, getParent, getParentOfType, getPath, getPathParts, getPropertyMembers, getRelativePath, getRoot, getRunningActionContext, getSnapshot, getType, getUnionSubtypes, hasParent, hasParentOfType, isActionContextChildOf, isActionContextThisOrChildOf, isAlive, isArrayType, isFrozenType, isIdentifierType, isLateType, isLiteralType, isMapType, isModelType, isOptionalType, isPrimitiveType, isProtected, isReferenceType, isRefinementType, isRoot, isStateTreeNode, isType, isUnionType, isValidReference, joinJsonPath, onAction, onPatch, onSnapshot, protect, recordActions, recordPatches, resolveIdentifier, resolvePath, setDevMode, setLivelinessChecking, setLivelynessChecking, setTypeChecking, splitJsonPath, types as t, toGenerator, toGeneratorFunction, tryReference, tryResolve, typecheck, types, unescapeJsonPath, unprotect, walk };
-export type { $EmptyObjectBrand, CustomTypeOptions, IActionContext, IActionRecorder, IActionTrackingMiddleware2Call, IActionTrackingMiddleware2Hooks, IActionTrackingMiddlewareHooks, IAnyComplexType, IAnyModelType, IAnyStateTreeNode, IAnyType, IArrayType, IComplexType, IDisposer, IJsonPatch, ILiteralType, IMSTArray, IMSTMap, IMapType, IMaybe, IMaybeIType, IMaybeNull, IMiddlewareEvent, IMiddlewareEventType, IMiddlewareHandler, IModelReflectionData, IModelReflectionPropertiesData, IModelType, IOptionalIType, IPatchRecorder, IReferenceType, IReversibleJsonPatch, ISerializedActionCall, ISimpleType, ISnapshotProcessor, ISnapshotProcessors, IStateTreeNode, IType, ITypeUnion, Instance, LivelinessMode, LivelynessMode, ModelActions, ModelCreationType, ModelCreationType2, ModelInstanceType, ModelInstanceTypeProps, ModelPrimitive, ModelProperties, ModelPropertiesDeclaration, ModelPropertiesDeclarationToProperties, ModelSnapshotType, ModelSnapshotType2, OnReferenceInvalidated, OnReferenceInvalidatedEvent, OptionalDefaultValueOrFunction, ReferenceIdentifier, ReferenceOptions, ReferenceOptionsGetSet, ReferenceOptionsOnInvalidated, SnapshotIn, SnapshotOrInstance, SnapshotOut, TypeOfValue, TypeOrStateTreeNodeToStateTreeNode, UnionOptions, UnionStringArray, ValidOptionalValue, ValidOptionalValues, _CustomCSProcessor, _CustomJoin, _CustomOrOther, _NotCustomized };
+export { addDisposer, addMiddleware, applyAction, applyPatch, applySnapshot, asArrayType, asMapType, asModelType, cannotDetermineSubtype, cast, castFlowReturn, castToReferenceSnapshot, castToSnapshot, clone, createActionTrackingMiddleware, createActionTrackingMiddleware2, decorate, destroy, detach, escapeJsonPath, extendInstance, flow, getChildType, getEnv, getIdentifier, getLivelinessChecking, getMembers, getNodeId, getParent, getParentOfType, getPath, getPathParts, getPropertyMembers, getRelativePath, getRoot, getRunningActionContext, getSnapshot, getType, getUnionSubtypes, getWrappedType, hasParent, hasParentOfType, isActionContextChildOf, isActionContextThisOrChildOf, isAlive, isArrayType, isFrozenType, isIdentifierType, isLateType, isLiteralType, isMapType, isModelType, isOptionalType, isPrimitiveType, isProtected, isReferenceType, isRefinementType, isRoot, isStateTreeNode, isType, isUnionType, isValidReference, joinJsonPath, onAction, onPatch, onSnapshot, protect, recordActions, recordPatches, resolveIdentifier, resolvePath, setDevMode, setLivelinessChecking, setLivelynessChecking, setTypeChecking, splitJsonPath, types as t, toGenerator, toGeneratorFunction, tryReference, tryResolve, typecheck, types, unescapeJsonPath, unprotect, unwrapType, walk };
+export type { $EmptyObjectBrand, CustomTypeOptions, IActionContext, IActionRecorder, IActionTrackingMiddleware2Call, IActionTrackingMiddleware2Hooks, IActionTrackingMiddlewareHooks, IAnyComplexType, IAnyModelType, IAnyStateTreeNode, IAnyType, IArrayType, IComplexType, IDisposer, IHooks, IHooksGetter, IJsonPatch, ILiteralType, IMSTArray, IMSTMap, IMapType, IMaybe, IMaybeIType, IMaybeNull, IMiddlewareEvent, IMiddlewareEventType, IMiddlewareHandler, IModelReflectionData, IModelReflectionPropertiesData, IModelType, IOptionalIType, IPatchRecorder, IReferenceType, IResilientType, IReversibleJsonPatch, ISerializedActionCall, ISimpleType, ISnapshotProcessor, ISnapshotProcessors, IStateTreeNode, IType, ITypeUnion, IValidationContext, IValidationContextEntry, IValidationError, IValidationResult, Instance, LivelinessMode, LivelynessMode, ModelActions, ModelCreationType, ModelCreationType2, ModelInstanceType, ModelInstanceTypeProps, ModelPrimitive, ModelProperties, ModelPropertiesDeclaration, ModelPropertiesDeclarationToProperties, ModelSnapshotType, ModelSnapshotType2, OnReferenceInvalidated, OnReferenceInvalidatedEvent, OptionalDefaultValueOrFunction, ReferenceIdentifier, ReferenceOptions, ReferenceOptionsGetSet, ReferenceOptionsOnInvalidated, SnapshotIn, SnapshotOrInstance, SnapshotOut, TypeOfValue, TypeOrStateTreeNodeToStateTreeNode, UnionOptions, UnionStringArray, ValidOptionalValue, ValidOptionalValues, _CustomCSProcessor, _CustomOrOther, _NotCustomized };