@jbrowse/mobx-state-tree 5.7.1 → 5.8.7

package/esm/types/utility-types/resilient.js

@@ -1,118 +0,0 @@
-import { BaseType } from "../../core/type/type.js";
-import { assertIsType, fail, isStateTreeNode, isType, typeCheckSuccess } from "../../internal.js";
-class Resilient extends BaseType {
-    _subtype;
-    _fallbackType;
-    _createFallbackSnapshot;
-    get flags() {
-        return this._subtype.flags;
-    }
-    constructor(_subtype, _fallbackType, _createFallbackSnapshot) {
-        super(`resilient(${_subtype.name})`);
-        this._subtype = _subtype;
-        this._fallbackType = _fallbackType;
-        this._createFallbackSnapshot = _createFallbackSnapshot;
-    }
-    describe() {
-        return `resilient(${this._subtype.describe()})`;
-    }
-    _instantiateFallback(parent, subpath, environment, originalSnapshot, originalError) {
-        let fallbackSnapshot;
-        try {
-            fallbackSnapshot = this._createFallbackSnapshot(originalError, originalSnapshot);
-        }
-        catch (e) {
-            throw fail(`resilient: createFallbackSnapshot threw while handling error for '${this._subtype.name}': ${originalError}. createFallbackSnapshot error: ${e}`);
-        }
-        try {
-            return this._fallbackType.instantiate(parent, subpath, environment, fallbackSnapshot);
-        }
-        catch (e) {
-            throw fail(`resilient: fallback type '${this._fallbackType.name}' failed to instantiate while handling error for '${this._subtype.name}': ${originalError}. Fallback error: ${e}`);
-        }
-    }
-    instantiate(parent, subpath, environment, initialValue) {
-        if (isStateTreeNode(initialValue)) {
-            return this._subtype.instantiate(parent, subpath, environment, initialValue);
-        }
-        try {
-            return this._subtype.instantiate(parent, subpath, environment, initialValue);
-        }
-        catch (e) {
-            return this._instantiateFallback(parent, subpath, environment, initialValue, e);
-        }
-    }
-    reconcile(current, newValue, parent, subpath) {
-        if (isStateTreeNode(newValue)) {
-            return this._subtype.reconcile(current, newValue, parent, subpath);
-        }
-        if (this._fallbackType.isAssignableFrom(current.type)) {
-            try {
-                return this._subtype.instantiate(parent, subpath, undefined, newValue);
-            }
-            catch (e) {
-                return this._fallbackType.reconcile(current, this._createFallbackSnapshot(e, newValue), parent, subpath);
-            }
-        }
-        try {
-            return this._subtype.reconcile(current, newValue, parent, subpath);
-        }
-        catch (e) {
-            current.die();
-            return this._instantiateFallback(parent, subpath, undefined, newValue, e);
-        }
-    }
-    isValidSnapshot(_value, _context) {
-        return typeCheckSuccess();
-    }
-    is(thing) {
-        if (isType(thing)) {
-            return (this._subtype.isAssignableFrom(thing) ||
-                this._fallbackType.isAssignableFrom(thing));
-        }
-        try {
-            if (this._subtype.is(thing)) {
-                return true;
-            }
-        }
-        catch (_e) {
-            // subtype.is() may throw (e.g. union dispatcher)
-        }
-        try {
-            return this._fallbackType.is(thing);
-        }
-        catch (_e) {
-            return false;
-        }
-    }
-    isAssignableFrom(type) {
-        return (this._subtype.isAssignableFrom(type) ||
-            this._fallbackType.isAssignableFrom(type));
-    }
-    getSubTypes() {
-        return [this._subtype, this._fallbackType];
-    }
-    getSnapshot(node) {
-        return node.snapshot;
-    }
-}
-/**
- * `types.resilient` - Wraps a type so that instantiation errors are caught
- * and a fallback type is used instead. This is useful for loading data that
- * may contain unknown or invalid subtrees (e.g., plugin types that are not
- * installed) without crashing the entire state tree.
- *
- * The `createFallbackSnapshot` callback receives the caught error and the
- * original snapshot, and must return a valid snapshot for the fallback type.
- *
- * @param type The type to wrap.
- * @param fallbackType The fallback type to use when instantiation fails.
- * @param createFallbackSnapshot Callback that produces a fallback snapshot from the error and original snapshot.
- * @returns A resilient type.
- */
-export function resilient(type, fallbackType, createFallbackSnapshot) {
-    assertIsType(type, 1);
-    assertIsType(fallbackType, 2);
-    return new Resilient(type, fallbackType, createFallbackSnapshot);
-}
-//# sourceMappingURL=resilient.js.map

package/esm/types/utility-types/resilient.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"resilient.js","sourceRoot":"","sources":["../../../src/types/utility-types/resilient.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseType } from \"../../core/type/type.ts\"\nimport {\n  type AnyObjectNode,\n  type ExtractNodeType,\n  type IAnyType,\n  type IType,\n  type IValidationContext,\n  type IValidationResult,\n  assertIsType,\n  fail,\n  isStateTreeNode,\n  isType,\n  typeCheckSuccess\n} from \"../../internal.ts\"\n\nclass Resilient<IT extends IAnyType, FT extends IAnyType> extends BaseType<\n  IT[\"CreationType\"] | FT[\"CreationType\"],\n  IT[\"SnapshotType\"] | FT[\"SnapshotType\"],\n  IT[\"TypeWithoutSTN\"] | FT[\"TypeWithoutSTN\"],\n  ExtractNodeType<IT> | ExtractNodeType<FT>\n> {\n  get flags() {\n    return this._subtype.flags\n  }\n\n  constructor(\n    private readonly _subtype: IT,\n    private readonly _fallbackType: FT,\n    private readonly _createFallbackSnapshot: (\n      error: unknown,\n      snapshot: any\n    ) => FT[\"CreationType\"]\n  ) {\n    super(`resilient(${_subtype.name})`)\n  }\n\n  describe() {\n    return `resilient(${this._subtype.describe()})`\n  }\n\n  private _instantiateFallback(\n    parent: AnyObjectNode | null,\n    subpath: string,\n    environment: any,\n    originalSnapshot: any,\n    originalError: unknown\n  ): this[\"N\"] {\n    let fallbackSnapshot: FT[\"CreationType\"]\n    try {\n      fallbackSnapshot = this._createFallbackSnapshot(\n        originalError,\n        originalSnapshot\n      )\n    } catch (e) {\n      throw fail(\n        `resilient: createFallbackSnapshot threw while handling error for '${this._subtype.name}': ${originalError}. createFallbackSnapshot error: ${e}`\n      )\n    }\n    try {\n      return this._fallbackType.instantiate(\n        parent,\n        subpath,\n        environment,\n        fallbackSnapshot\n      ) as this[\"N\"]\n    } catch (e) {\n      throw fail(\n        `resilient: fallback type '${this._fallbackType.name}' failed to instantiate while handling error for '${this._subtype.name}': ${originalError}. Fallback error: ${e}`\n      )\n    }\n  }\n\n  instantiate(\n    parent: AnyObjectNode | null,\n    subpath: string,\n    environment: any,\n    initialValue: this[\"C\"] | this[\"T\"]\n  ): this[\"N\"] {\n    if (isStateTreeNode(initialValue)) {\n      return this._subtype.instantiate(\n        parent,\n        subpath,\n        environment,\n        initialValue\n      ) as this[\"N\"]\n    }\n    try {\n      return this._subtype.instantiate(\n        parent,\n        subpath,\n        environment,\n        initialValue\n      ) as this[\"N\"]\n    } catch (e) {\n      return this._instantiateFallback(\n        parent,\n        subpath,\n        environment,\n        initialValue,\n        e\n      )\n    }\n  }\n\n  reconcile(\n    current: this[\"N\"],\n    newValue: this[\"C\"] | this[\"T\"],\n    parent: AnyObjectNode,\n    subpath: string\n  ): this[\"N\"] {\n    if (isStateTreeNode(newValue)) {\n      return this._subtype.reconcile(\n        current,\n        newValue,\n        parent,\n        subpath\n      ) as this[\"N\"]\n    }\n    if (this._fallbackType.isAssignableFrom(current.type)) {\n      try {\n        return this._subtype.instantiate(\n          parent,\n          subpath,\n          undefined,\n          newValue\n        ) as this[\"N\"]\n      } catch (e) {\n        return this._fallbackType.reconcile(\n          current,\n          this._createFallbackSnapshot(e, newValue),\n          parent,\n          subpath\n        ) as this[\"N\"]\n      }\n    }\n    try {\n      return this._subtype.reconcile(\n        current,\n        newValue,\n        parent,\n        subpath\n      ) as this[\"N\"]\n    } catch (e) {\n      current.die()\n      return this._instantiateFallback(parent, subpath, undefined, newValue, e)\n    }\n  }\n\n  isValidSnapshot(\n    _value: this[\"C\"],\n    _context: IValidationContext\n  ): IValidationResult {\n    return typeCheckSuccess()\n  }\n\n  is(thing: any): thing is any {\n    if (isType(thing)) {\n      return (\n        this._subtype.isAssignableFrom(thing) ||\n        this._fallbackType.isAssignableFrom(thing)\n      )\n    }\n    try {\n      if (this._subtype.is(thing)) {\n        return true\n      }\n    } catch (_e) {\n      // subtype.is() may throw (e.g. union dispatcher)\n    }\n    try {\n      return this._fallbackType.is(thing)\n    } catch (_e) {\n      return false\n    }\n  }\n\n  isAssignableFrom(type: IAnyType) {\n    return (\n      this._subtype.isAssignableFrom(type) ||\n      this._fallbackType.isAssignableFrom(type)\n    )\n  }\n\n  getSubTypes() {\n    return [this._subtype, this._fallbackType]\n  }\n\n  getSnapshot(node: this[\"N\"]): this[\"S\"] {\n    return node.snapshot\n  }\n}\n\nexport interface IResilientType<\n  IT extends IAnyType,\n  FT extends IAnyType\n> extends IType<\n  IT[\"CreationType\"] | FT[\"CreationType\"],\n  IT[\"SnapshotType\"] | FT[\"SnapshotType\"],\n  IT[\"TypeWithoutSTN\"] | FT[\"TypeWithoutSTN\"]\n> {}\n\n/**\n * `types.resilient` - Wraps a type so that instantiation errors are caught\n * and a fallback type is used instead. This is useful for loading data that\n * may contain unknown or invalid subtrees (e.g., plugin types that are not\n * installed) without crashing the entire state tree.\n *\n * The `createFallbackSnapshot` callback receives the caught error and the\n * original snapshot, and must return a valid snapshot for the fallback type.\n *\n * @param type The type to wrap.\n * @param fallbackType The fallback type to use when instantiation fails.\n * @param createFallbackSnapshot Callback that produces a fallback snapshot from the error and original snapshot.\n * @returns A resilient type.\n */\nexport function resilient<IT extends IAnyType, FT extends IAnyType>(\n  type: IT,\n  fallbackType: FT,\n  createFallbackSnapshot: (error: unknown, snapshot: any) => FT[\"CreationType\"]\n): IResilientType<IT, FT> {\n  assertIsType(type, 1)\n  assertIsType(fallbackType, 2)\n  return new Resilient(type, fallbackType, createFallbackSnapshot)\n}\n"]}

package/esm/types/utility-types/snapshotProcessor.d.ts

@@ -1,63 +0,0 @@
-import { type IAnyType, type Instance, type IType } from "../../internal.ts";
-/** @hidden */
-declare const $mstNotCustomized: unique symbol;
-/** @hidden */
-export interface _NotCustomized {
-    readonly [$mstNotCustomized]: undefined;
-}
-/** @hidden */
-export type _CustomOrOther<Custom, Other> = Custom extends _NotCustomized ? Other : Custom;
-/**
- * A type that has its snapshots processed.
- */
-export interface ISnapshotProcessor<IT extends IAnyType, CustomC, CustomS> extends IType<_CustomOrOther<CustomC, IT["CreationType"]>, _CustomOrOther<CustomS, IT["SnapshotType"]>, IT["TypeWithoutSTN"]> {
-}
-/**
- * Snapshot processors.
- */
-export interface ISnapshotProcessors<IT extends IAnyType, CustomC, CustomS> {
-    /**
-     * Function that transforms an input snapshot.
-     */
-    preProcessor?(snapshot: CustomC): IT["CreationType"];
-    /**
-     * Function that transforms an output snapshot.
-     * @param snapshot
-     */
-    postProcessor?(snapshot: IT["SnapshotType"], node: Instance<IT>): CustomS;
-}
-/**
- * `types.snapshotProcessor` - Runs a pre/post snapshot processor before/after serializing a given type.
- *
- * Example:
- * ```ts
- * const Todo1 = types.model({ text: types.string })
- * // in the backend the text type must be null when empty
- * interface BackendTodo {
- *     text: string | null
- * }
- *
- * const Todo2 = types.snapshotProcessor(Todo1, {
- *     // from snapshot to instance
- *     preProcessor(snapshot: BackendTodo) {
- *         return {
- *             text: sn.text || "";
- *         }
- *     },
- *
- *     // from instance to snapshot
- *     postProcessor(snapshot, node): BackendTodo {
- *         return {
- *             text: !sn.text ? null : sn.text
- *         }
- *     }
- * })
- * ```
- *
- * @param type Type to run the processors over.
- * @param processors Processors to run.
- * @param name Type name, or undefined to inherit the inner type one.
- * @returns
- */
-export declare function snapshotProcessor<IT extends IAnyType, CustomC = _NotCustomized, CustomS = _NotCustomized>(type: IT, processors: ISnapshotProcessors<IT, CustomC, CustomS>, name?: string): ISnapshotProcessor<IT, CustomC, CustomS>;
-export {};

package/esm/types/utility-types/snapshotProcessor.js

@@ -1,159 +0,0 @@
-import { BaseType, ComplexType } from "../../core/type/type.js";
-import { ObjectNode, TypeFlags, assertIsType, devMode, fail, getSnapshot, isStateTreeNode, isType, isUnionType, typeCheckFailure } from "../../internal.js";
-/** @hidden */
-const $preProcessorFailed = Symbol("$preProcessorFailed");
-class SnapshotProcessor extends BaseType {
-    _subtype;
-    _processors;
-    get flags() {
-        return this._subtype.flags | TypeFlags.SnapshotProcessor;
-    }
-    constructor(_subtype, _processors, name) {
-        super(name || _subtype.name);
-        this._subtype = _subtype;
-        this._processors = _processors;
-    }
-    describe() {
-        return `snapshotProcessor(${this._subtype.describe()})`;
-    }
-    preProcessSnapshot(sn) {
-        if (this._processors.preProcessor) {
-            return this._processors.preProcessor.call(null, sn);
-        }
-        return sn;
-    }
-    preProcessSnapshotSafe(sn) {
-        try {
-            return this.preProcessSnapshot(sn);
-        }
-        catch (_e) {
-            return $preProcessorFailed;
-        }
-    }
-    postProcessSnapshot(sn, node) {
-        if (this._processors.postProcessor) {
-            return this._processors.postProcessor.call(null, sn, node.storedValue);
-        }
-        return sn;
-    }
-    _fixNode(node) {
-        // the node has to use these methods rather than the original type ones
-        proxyNodeTypeMethods(node.type, this, "create");
-        if (node instanceof ObjectNode) {
-            node.hasSnapshotPostProcessor = !!this._processors.postProcessor;
-        }
-        const oldGetSnapshot = node.getSnapshot;
-        node.getSnapshot = () => this.postProcessSnapshot(oldGetSnapshot.call(node), node);
-        if (!isUnionType(this._subtype)) {
-            node.getReconciliationType = () => {
-                return this;
-            };
-        }
-    }
-    instantiate(parent, subpath, environment, initialValue) {
-        const processedInitialValue = isStateTreeNode(initialValue)
-            ? initialValue
-            : this.preProcessSnapshot(initialValue);
-        const node = this._subtype.instantiate(parent, subpath, environment, processedInitialValue);
-        this._fixNode(node);
-        return node;
-    }
-    reconcile(current, newValue, parent, subpath) {
-        const node = this._subtype.reconcile(current, isStateTreeNode(newValue) ? newValue : this.preProcessSnapshot(newValue), parent, subpath);
-        if (node !== current) {
-            this._fixNode(node);
-        }
-        return node;
-    }
-    getSnapshot(node, applyPostProcess = true) {
-        const sn = this._subtype.getSnapshot(node);
-        return applyPostProcess ? this.postProcessSnapshot(sn, node) : sn;
-    }
-    isValidSnapshot(value, context) {
-        const processedSn = this.preProcessSnapshotSafe(value);
-        if (processedSn === $preProcessorFailed) {
-            return typeCheckFailure(context, value, "Failed to preprocess value");
-        }
-        return this._subtype.validate(processedSn, context);
-    }
-    getSubTypes() {
-        return this._subtype;
-    }
-    is(thing) {
-        const value = isType(thing)
-            ? this._subtype
-            : isStateTreeNode(thing)
-                ? getSnapshot(thing, false)
-                : this.preProcessSnapshotSafe(thing);
-        if (value === $preProcessorFailed) {
-            return false;
-        }
-        return (this._subtype.validate(value, [{ path: "", type: this._subtype }])
-            .length === 0);
-    }
-    isAssignableFrom(type) {
-        return this._subtype.isAssignableFrom(type);
-    }
-    isMatchingSnapshotId(current, snapshot) {
-        if (!(this._subtype instanceof ComplexType)) {
-            return false;
-        }
-        const processedSn = this.preProcessSnapshot(snapshot);
-        return this._subtype.isMatchingSnapshotId(current, processedSn);
-    }
-}
-function proxyNodeTypeMethods(nodeType, snapshotProcessorType, ...methods) {
-    for (const method of methods) {
-        nodeType[method] = snapshotProcessorType[method].bind(snapshotProcessorType);
-    }
-}
-/**
- * `types.snapshotProcessor` - Runs a pre/post snapshot processor before/after serializing a given type.
- *
- * Example:
- * ```ts
- * const Todo1 = types.model({ text: types.string })
- * // in the backend the text type must be null when empty
- * interface BackendTodo {
- *     text: string | null
- * }
- *
- * const Todo2 = types.snapshotProcessor(Todo1, {
- *     // from snapshot to instance
- *     preProcessor(snapshot: BackendTodo) {
- *         return {
- *             text: sn.text || "";
- *         }
- *     },
- *
- *     // from instance to snapshot
- *     postProcessor(snapshot, node): BackendTodo {
- *         return {
- *             text: !sn.text ? null : sn.text
- *         }
- *     }
- * })
- * ```
- *
- * @param type Type to run the processors over.
- * @param processors Processors to run.
- * @param name Type name, or undefined to inherit the inner type one.
- * @returns
- */
-export function snapshotProcessor(type, processors, name) {
-    assertIsType(type, 1);
-    if (devMode()) {
-        if (processors.postProcessor &&
-            typeof processors.postProcessor !== "function") {
-            // istanbul ignore next
-            throw fail("postSnapshotProcessor must be a function");
-        }
-        if (processors.preProcessor &&
-            typeof processors.preProcessor !== "function") {
-            // istanbul ignore next
-            throw fail("preSnapshotProcessor must be a function");
-        }
-    }
-    return new SnapshotProcessor(type, processors, name);
-}
-//# sourceMappingURL=snapshotProcessor.js.map

package/esm/types/utility-types/snapshotProcessor.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"snapshotProcessor.js","sourceRoot":"","sources":["../../../src/types/utility-types/snapshotProcessor.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseType, ComplexType } from \"../../core/type/type.ts\"\nimport {\n  type AnyObjectNode,\n  type ExtractNodeType,\n  type IAnyType,\n  type Instance,\n  type IType,\n  type IValidationContext,\n  type IValidationResult,\n  ObjectNode,\n  TypeFlags,\n  assertIsType,\n  devMode,\n  fail,\n  getSnapshot,\n  isStateTreeNode,\n  isType,\n  isUnionType,\n  typeCheckFailure\n} from \"../../internal.ts\"\n\n/** @hidden */\ndeclare const $mstNotCustomized: unique symbol\n\n/** @hidden */\nconst $preProcessorFailed: unique symbol = Symbol(\"$preProcessorFailed\")\n\n/** @hidden */\n// tslint:disable-next-line:class-name\nexport interface _NotCustomized {\n  // only for typings\n  readonly [$mstNotCustomized]: undefined\n}\n/** @hidden */\nexport type _CustomOrOther<Custom, Other> = Custom extends _NotCustomized\n  ? Other\n  : Custom\n\nclass SnapshotProcessor<IT extends IAnyType, CustomC, CustomS> extends BaseType<\n  _CustomOrOther<CustomC, IT[\"CreationType\"]>,\n  _CustomOrOther<CustomS, IT[\"SnapshotType\"]>,\n  IT[\"TypeWithoutSTN\"],\n  ExtractNodeType<IT>\n> {\n  get flags() {\n    return this._subtype.flags | TypeFlags.SnapshotProcessor\n  }\n\n  constructor(\n    private readonly _subtype: IT,\n    private readonly _processors: ISnapshotProcessors<IT, CustomC, CustomS>,\n    name?: string\n  ) {\n    super(name || _subtype.name)\n  }\n\n  describe() {\n    return `snapshotProcessor(${this._subtype.describe()})`\n  }\n\n  private preProcessSnapshot(sn: this[\"C\"]): IT[\"CreationType\"] {\n    if (this._processors.preProcessor) {\n      return this._processors.preProcessor.call(null, sn)\n    }\n    return sn as any\n  }\n\n  private preProcessSnapshotSafe(\n    sn: this[\"C\"]\n  ): IT[\"CreationType\"] | typeof $preProcessorFailed {\n    try {\n      return this.preProcessSnapshot(sn)\n    } catch (_e) {\n      return $preProcessorFailed\n    }\n  }\n\n  private postProcessSnapshot(\n    sn: IT[\"SnapshotType\"],\n    node: this[\"N\"]\n  ): this[\"S\"] {\n    if (this._processors.postProcessor) {\n      return this._processors.postProcessor!.call(\n        null,\n        sn,\n        node.storedValue\n      ) as any\n    }\n    return sn\n  }\n\n  private _fixNode(node: this[\"N\"]): void {\n    // the node has to use these methods rather than the original type ones\n    proxyNodeTypeMethods(node.type, this, \"create\")\n\n    if (node instanceof ObjectNode) {\n      node.hasSnapshotPostProcessor = !!this._processors.postProcessor\n    }\n    const oldGetSnapshot = node.getSnapshot\n    node.getSnapshot = () =>\n      this.postProcessSnapshot(oldGetSnapshot.call(node), node) as any\n    if (!isUnionType(this._subtype)) {\n      node.getReconciliationType = () => {\n        return this\n      }\n    }\n  }\n\n  instantiate(\n    parent: AnyObjectNode | null,\n    subpath: string,\n    environment: any,\n    initialValue: this[\"C\"] | this[\"T\"]\n  ): this[\"N\"] {\n    const processedInitialValue = isStateTreeNode(initialValue)\n      ? initialValue\n      : this.preProcessSnapshot(initialValue)\n    const node = this._subtype.instantiate(\n      parent,\n      subpath,\n      environment,\n      processedInitialValue\n    ) as any\n    this._fixNode(node)\n    return node\n  }\n\n  reconcile(\n    current: this[\"N\"],\n    newValue: this[\"C\"] | this[\"T\"],\n    parent: AnyObjectNode,\n    subpath: string\n  ): this[\"N\"] {\n    const node = this._subtype.reconcile(\n      current,\n      isStateTreeNode(newValue) ? newValue : this.preProcessSnapshot(newValue),\n      parent,\n      subpath\n    ) as any\n    if (node !== current) {\n      this._fixNode(node)\n    }\n    return node\n  }\n\n  getSnapshot(node: this[\"N\"], applyPostProcess: boolean = true): this[\"S\"] {\n    const sn = this._subtype.getSnapshot(node)\n    return applyPostProcess ? this.postProcessSnapshot(sn, node) : sn\n  }\n\n  isValidSnapshot(\n    value: this[\"C\"],\n    context: IValidationContext\n  ): IValidationResult {\n    const processedSn = this.preProcessSnapshotSafe(value)\n    if (processedSn === $preProcessorFailed) {\n      return typeCheckFailure(context, value, \"Failed to preprocess value\")\n    }\n    return this._subtype.validate(processedSn, context)\n  }\n\n  getSubTypes() {\n    return this._subtype\n  }\n\n  is(thing: any): thing is any {\n    const value = isType(thing)\n      ? this._subtype\n      : isStateTreeNode(thing)\n        ? getSnapshot(thing, false)\n        : this.preProcessSnapshotSafe(thing)\n    if (value === $preProcessorFailed) {\n      return false\n    }\n    return (\n      this._subtype.validate(value, [{ path: \"\", type: this._subtype }])\n        .length === 0\n    )\n  }\n\n  isAssignableFrom(type: IAnyType): boolean {\n    return this._subtype.isAssignableFrom(type)\n  }\n\n  isMatchingSnapshotId(current: this[\"N\"], snapshot: this[\"C\"]): boolean {\n    if (!(this._subtype instanceof ComplexType)) {\n      return false\n    }\n    const processedSn = this.preProcessSnapshot(snapshot)\n    return this._subtype.isMatchingSnapshotId(current as any, processedSn)\n  }\n}\n\nfunction proxyNodeTypeMethods(\n  nodeType: any,\n  snapshotProcessorType: any,\n  ...methods: (keyof SnapshotProcessor<any, any, any>)[]\n) {\n  for (const method of methods) {\n    nodeType[method] = snapshotProcessorType[method].bind(snapshotProcessorType)\n  }\n}\n\n// public API\n\n/**\n * A type that has its snapshots processed.\n */\nexport interface ISnapshotProcessor<\n  IT extends IAnyType,\n  CustomC,\n  CustomS\n> extends IType<\n  _CustomOrOther<CustomC, IT[\"CreationType\"]>,\n  _CustomOrOther<CustomS, IT[\"SnapshotType\"]>,\n  IT[\"TypeWithoutSTN\"]\n> {}\n\n/**\n * Snapshot processors.\n */\nexport interface ISnapshotProcessors<IT extends IAnyType, CustomC, CustomS> {\n  /**\n   * Function that transforms an input snapshot.\n   */\n  preProcessor?(snapshot: CustomC): IT[\"CreationType\"]\n  /**\n   * Function that transforms an output snapshot.\n   * @param snapshot\n   */\n  postProcessor?(snapshot: IT[\"SnapshotType\"], node: Instance<IT>): CustomS\n}\n\n/**\n * `types.snapshotProcessor` - Runs a pre/post snapshot processor before/after serializing a given type.\n *\n * Example:\n * ```ts\n * const Todo1 = types.model({ text: types.string })\n * // in the backend the text type must be null when empty\n * interface BackendTodo {\n *     text: string | null\n * }\n *\n * const Todo2 = types.snapshotProcessor(Todo1, {\n *     // from snapshot to instance\n *     preProcessor(snapshot: BackendTodo) {\n *         return {\n *             text: sn.text || \"\";\n *         }\n *     },\n *\n *     // from instance to snapshot\n *     postProcessor(snapshot, node): BackendTodo {\n *         return {\n *             text: !sn.text ? null : sn.text\n *         }\n *     }\n * })\n * ```\n *\n * @param type Type to run the processors over.\n * @param processors Processors to run.\n * @param name Type name, or undefined to inherit the inner type one.\n * @returns\n */\nexport function snapshotProcessor<\n  IT extends IAnyType,\n  CustomC = _NotCustomized,\n  CustomS = _NotCustomized\n>(\n  type: IT,\n  processors: ISnapshotProcessors<IT, CustomC, CustomS>,\n  name?: string\n): ISnapshotProcessor<IT, CustomC, CustomS> {\n  assertIsType(type, 1)\n  if (devMode()) {\n    if (\n      processors.postProcessor &&\n      typeof processors.postProcessor !== \"function\"\n    ) {\n      // istanbul ignore next\n      throw fail(\"postSnapshotProcessor must be a function\")\n    }\n    if (\n      processors.preProcessor &&\n      typeof processors.preProcessor !== \"function\"\n    ) {\n      // istanbul ignore next\n      throw fail(\"preSnapshotProcessor must be a function\")\n    }\n  }\n\n  return new SnapshotProcessor(type, processors, name)\n}\n"]}

package/esm/types/utility-types/union.d.ts

@@ -1,78 +0,0 @@
-import { BaseType } from "../../core/type/type.ts";
-import { type AnyObjectNode, type IAnyType, type IModelType, type IType, type IValidationContext, type IValidationResult, type ModelCreationType2, type ModelInstanceType, type ModelProperties, type ModelSnapshotType2, TypeFlags, type _NotCustomized } from "../../internal.ts";
-export type ITypeDispatcher = (snapshot: any) => IAnyType;
-export interface UnionOptions {
-    eager?: boolean;
-    dispatcher?: ITypeDispatcher;
-}
-/**
- * @internal
- * @hidden
- */
-export declare class Union extends BaseType<any, any, any> {
-    private readonly _types;
-    private readonly _dispatcher?;
-    private readonly _eager;
-    get flags(): TypeFlags.Union;
-    constructor(name: string, _types: IAnyType[], options?: UnionOptions);
-    isAssignableFrom(type: IAnyType): boolean;
-    describe(): string;
-    instantiate(parent: AnyObjectNode | null, subpath: string, environment: any, initialValue: this["C"] | this["T"]): this["N"];
-    reconcile(current: this["N"], newValue: this["C"] | this["T"], parent: AnyObjectNode, subpath: string): this["N"];
-    private noMatchMessage;
-    determineType(value: this["C"] | this["T"], reconcileCurrentType: IAnyType | undefined): IAnyType | undefined;
-    private tryQuickMatch;
-    private tryMatchPrimitive;
-    private snapshotLooksLikeType;
-    isValidSnapshot(value: this["C"], context: IValidationContext): IValidationResult;
-    getSubTypes(): IAnyType[];
-}
-/**
- * Transform _NotCustomized | _NotCustomized... to _NotCustomized, _NotCustomized | A | B to A | B
- * @hidden
- */
-export type _CustomCSProcessor<T> = Exclude<T, _NotCustomized> extends never ? _NotCustomized : Exclude<T, _NotCustomized>;
-/** @hidden */
-export interface ITypeUnion<C, S, T> extends IType<_CustomCSProcessor<C>, _CustomCSProcessor<S>, T> {
-}
-export declare function union<PA extends ModelProperties, OA, FCA, FSA, PB extends ModelProperties, OB, FCB, FSB>(A: IModelType<PA, OA, FCA, FSA>, B: IModelType<PB, OB, FCB, FSB>): ITypeUnion<ModelCreationType2<PA, FCA> | ModelCreationType2<PB, FCB>, ModelSnapshotType2<PA, FSA> | ModelSnapshotType2<PB, FSB>, ModelInstanceType<PA, OA> | ModelInstanceType<PB, OB>>;
-export declare function union<PA extends ModelProperties, OA, FCA, FSA, PB extends ModelProperties, OB, FCB, FSB>(options: UnionOptions, A: IModelType<PA, OA, FCA, FSA>, B: IModelType<PB, OB, FCB, FSB>): ITypeUnion<ModelCreationType2<PA, FCA> | ModelCreationType2<PB, FCB>, ModelSnapshotType2<PA, FSA> | ModelSnapshotType2<PB, FSB>, ModelInstanceType<PA, OA> | ModelInstanceType<PB, OB>>;
-export declare function union<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>): ITypeUnion<ModelCreationType2<PA, FCA> | ModelCreationType2<PB, FCB> | ModelCreationType2<PC, FCC>, ModelSnapshotType2<PA, FSA> | ModelSnapshotType2<PB, FSB> | ModelSnapshotType2<PC, FSC>, ModelInstanceType<PA, OA> | ModelInstanceType<PB, OB> | ModelInstanceType<PC, OC>>;
-export declare function union<PA extends ModelProperties, OA, FCA, FSA, PB extends ModelProperties, OB, FCB, FSB, PC extends ModelProperties, OC, FCC, FSC>(options: UnionOptions, A: IModelType<PA, OA, FCA, FSA>, B: IModelType<PB, OB, FCB, FSB>, C: IModelType<PC, OC, FCC, FSC>): ITypeUnion<ModelCreationType2<PA, FCA> | ModelCreationType2<PB, FCB> | ModelCreationType2<PC, FCC>, ModelSnapshotType2<PA, FSA> | ModelSnapshotType2<PB, FSB> | ModelSnapshotType2<PC, FSC>, ModelInstanceType<PA, OA> | ModelInstanceType<PB, OB> | ModelInstanceType<PC, OC>>;
-export declare function union<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>): ITypeUnion<ModelCreationType2<PA, FCA> | ModelCreationType2<PB, FCB> | ModelCreationType2<PC, FCC> | ModelCreationType2<PD, FCD>, ModelSnapshotType2<PA, FSA> | ModelSnapshotType2<PB, FSB> | ModelSnapshotType2<PC, FSC> | ModelSnapshotType2<PD, FSD>, ModelInstanceType<PA, OA> | ModelInstanceType<PB, OB> | ModelInstanceType<PC, OC> | ModelInstanceType<PD, OD>>;
-export declare function union<PA extends ModelProperties, OA, FCA, FSA, PB extends ModelProperties, OB, FCB, FSB, PC extends ModelProperties, OC, FCC, FSC, PD extends ModelProperties, OD, FCD, FSD>(options: UnionOptions, A: IModelType<PA, OA, FCA, FSA>, B: IModelType<PB, OB, FCB, FSB>, C: IModelType<PC, OC, FCC, FSC>, D: IModelType<PD, OD, FCD, FSD>): ITypeUnion<ModelCreationType2<PA, FCA> | ModelCreationType2<PB, FCB> | ModelCreationType2<PC, FCC> | ModelCreationType2<PD, FCD>, ModelSnapshotType2<PA, FSA> | ModelSnapshotType2<PB, FSB> | ModelSnapshotType2<PC, FSC> | ModelSnapshotType2<PD, FSD>, ModelInstanceType<PA, OA> | ModelInstanceType<PB, OB> | ModelInstanceType<PC, OC> | ModelInstanceType<PD, OD>>;
-export declare function union<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>): ITypeUnion<ModelCreationType2<PA, FCA> | ModelCreationType2<PB, FCB> | ModelCreationType2<PC, FCC> | ModelCreationType2<PD, FCD> | ModelCreationType2<PE, FCE>, ModelSnapshotType2<PA, FSA> | ModelSnapshotType2<PB, FSB> | ModelSnapshotType2<PC, FSC> | ModelSnapshotType2<PD, FSD> | ModelSnapshotType2<PE, FSE>, ModelInstanceType<PA, OA> | ModelInstanceType<PB, OB> | ModelInstanceType<PC, OC> | ModelInstanceType<PD, OD> | ModelInstanceType<PE, OE>>;
-export declare function union<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>(options: UnionOptions, 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>): ITypeUnion<ModelCreationType2<PA, FCA> | ModelCreationType2<PB, FCB> | ModelCreationType2<PC, FCC> | ModelCreationType2<PD, FCD> | ModelCreationType2<PE, FCE>, ModelSnapshotType2<PA, FSA> | ModelSnapshotType2<PB, FSB> | ModelSnapshotType2<PC, FSC> | ModelSnapshotType2<PD, FSD> | ModelSnapshotType2<PE, FSE>, ModelInstanceType<PA, OA> | ModelInstanceType<PB, OB> | ModelInstanceType<PC, OC> | ModelInstanceType<PD, OD> | ModelInstanceType<PE, OE>>;
-export declare function union<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>): ITypeUnion<ModelCreationType2<PA, FCA> | ModelCreationType2<PB, FCB> | ModelCreationType2<PC, FCC> | ModelCreationType2<PD, FCD> | ModelCreationType2<PE, FCE> | ModelCreationType2<PF, FCF>, ModelSnapshotType2<PA, FSA> | ModelSnapshotType2<PB, FSB> | ModelSnapshotType2<PC, FSC> | ModelSnapshotType2<PD, FSD> | ModelSnapshotType2<PE, FSE> | ModelSnapshotType2<PF, FSF>, ModelInstanceType<PA, OA> | ModelInstanceType<PB, OB> | ModelInstanceType<PC, OC> | ModelInstanceType<PD, OD> | ModelInstanceType<PE, OE> | ModelInstanceType<PF, OF>>;
-export declare function union<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>(options: UnionOptions, 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>): ITypeUnion<ModelCreationType2<PA, FCA> | ModelCreationType2<PB, FCB> | ModelCreationType2<PC, FCC> | ModelCreationType2<PD, FCD> | ModelCreationType2<PE, FCE> | ModelCreationType2<PF, FCF>, ModelSnapshotType2<PA, FSA> | ModelSnapshotType2<PB, FSB> | ModelSnapshotType2<PC, FSC> | ModelSnapshotType2<PD, FSD> | ModelSnapshotType2<PE, FSE> | ModelSnapshotType2<PF, FSF>, ModelInstanceType<PA, OA> | ModelInstanceType<PB, OB> | ModelInstanceType<PC, OC> | ModelInstanceType<PD, OD> | ModelInstanceType<PE, OE> | ModelInstanceType<PF, OF>>;
-export declare function union<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>): ITypeUnion<ModelCreationType2<PA, FCA> | ModelCreationType2<PB, FCB> | ModelCreationType2<PC, FCC> | ModelCreationType2<PD, FCD> | ModelCreationType2<PE, FCE> | ModelCreationType2<PF, FCF> | ModelCreationType2<PG, FCG>, ModelSnapshotType2<PA, FSA> | ModelSnapshotType2<PB, FSB> | ModelSnapshotType2<PC, FSC> | ModelSnapshotType2<PD, FSD> | ModelSnapshotType2<PE, FSE> | ModelSnapshotType2<PF, FSF> | ModelSnapshotType2<PG, FSG>, ModelInstanceType<PA, OA> | ModelInstanceType<PB, OB> | ModelInstanceType<PC, OC> | ModelInstanceType<PD, OD> | ModelInstanceType<PE, OE> | ModelInstanceType<PF, OF> | ModelInstanceType<PG, OG>>;
-export declare function union<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>(options: UnionOptions, 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>): ITypeUnion<ModelCreationType2<PA, FCA> | ModelCreationType2<PB, FCB> | ModelCreationType2<PC, FCC> | ModelCreationType2<PD, FCD> | ModelCreationType2<PE, FCE> | ModelCreationType2<PF, FCF> | ModelCreationType2<PG, FCG>, ModelSnapshotType2<PA, FSA> | ModelSnapshotType2<PB, FSB> | ModelSnapshotType2<PC, FSC> | ModelSnapshotType2<PD, FSD> | ModelSnapshotType2<PE, FSE> | ModelSnapshotType2<PF, FSF> | ModelSnapshotType2<PG, FSG>, ModelInstanceType<PA, OA> | ModelInstanceType<PB, OB> | ModelInstanceType<PC, OC> | ModelInstanceType<PD, OD> | ModelInstanceType<PE, OE> | ModelInstanceType<PF, OF> | ModelInstanceType<PG, OG>>;
-export declare function union<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>): ITypeUnion<ModelCreationType2<PA, FCA> | ModelCreationType2<PB, FCB> | ModelCreationType2<PC, FCC> | ModelCreationType2<PD, FCD> | ModelCreationType2<PE, FCE> | ModelCreationType2<PF, FCF> | ModelCreationType2<PG, FCG> | ModelCreationType2<PH, FCH>, ModelSnapshotType2<PA, FSA> | ModelSnapshotType2<PB, FSB> | ModelSnapshotType2<PC, FSC> | ModelSnapshotType2<PD, FSD> | ModelSnapshotType2<PE, FSE> | ModelSnapshotType2<PF, FSF> | ModelSnapshotType2<PG, FSG> | ModelSnapshotType2<PH, FSH>, ModelInstanceType<PA, OA> | ModelInstanceType<PB, OB> | ModelInstanceType<PC, OC> | ModelInstanceType<PD, OD> | ModelInstanceType<PE, OE> | ModelInstanceType<PF, OF> | ModelInstanceType<PG, OG> | ModelInstanceType<PH, OH>>;
-export declare function union<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>(options: UnionOptions, 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>): ITypeUnion<ModelCreationType2<PA, FCA> | ModelCreationType2<PB, FCB> | ModelCreationType2<PC, FCC> | ModelCreationType2<PD, FCD> | ModelCreationType2<PE, FCE> | ModelCreationType2<PF, FCF> | ModelCreationType2<PG, FCG> | ModelCreationType2<PH, FCH>, ModelSnapshotType2<PA, FSA> | ModelSnapshotType2<PB, FSB> | ModelSnapshotType2<PC, FSC> | ModelSnapshotType2<PD, FSD> | ModelSnapshotType2<PE, FSE> | ModelSnapshotType2<PF, FSF> | ModelSnapshotType2<PG, FSG> | ModelSnapshotType2<PH, FSH>, ModelInstanceType<PA, OA> | ModelInstanceType<PB, OB> | ModelInstanceType<PC, OC> | ModelInstanceType<PD, OD> | ModelInstanceType<PE, OE> | ModelInstanceType<PF, OF> | ModelInstanceType<PG, OG> | ModelInstanceType<PH, OH>>;
-export declare function union<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>): ITypeUnion<ModelCreationType2<PA, FCA> | ModelCreationType2<PB, FCB> | ModelCreationType2<PC, FCC> | ModelCreationType2<PD, FCD> | ModelCreationType2<PE, FCE> | ModelCreationType2<PF, FCF> | ModelCreationType2<PG, FCG> | ModelCreationType2<PH, FCH> | ModelCreationType2<PI, FCI>, ModelSnapshotType2<PA, FSA> | ModelSnapshotType2<PB, FSB> | ModelSnapshotType2<PC, FSC> | ModelSnapshotType2<PD, FSD> | ModelSnapshotType2<PE, FSE> | ModelSnapshotType2<PF, FSF> | ModelSnapshotType2<PG, FSG> | ModelSnapshotType2<PH, FSH> | ModelSnapshotType2<PI, FSI>, ModelInstanceType<PA, OA> | ModelInstanceType<PB, OB> | ModelInstanceType<PC, OC> | ModelInstanceType<PD, OD> | ModelInstanceType<PE, OE> | ModelInstanceType<PF, OF> | ModelInstanceType<PG, OG> | ModelInstanceType<PH, OH> | ModelInstanceType<PI, OI>>;
-export declare function union<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>(options: UnionOptions, 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>): ITypeUnion<ModelCreationType2<PA, FCA> | ModelCreationType2<PB, FCB> | ModelCreationType2<PC, FCC> | ModelCreationType2<PD, FCD> | ModelCreationType2<PE, FCE> | ModelCreationType2<PF, FCF> | ModelCreationType2<PG, FCG> | ModelCreationType2<PH, FCH> | ModelCreationType2<PI, FCI>, ModelSnapshotType2<PA, FSA> | ModelSnapshotType2<PB, FSB> | ModelSnapshotType2<PC, FSC> | ModelSnapshotType2<PD, FSD> | ModelSnapshotType2<PE, FSE> | ModelSnapshotType2<PF, FSF> | ModelSnapshotType2<PG, FSG> | ModelSnapshotType2<PH, FSH> | ModelSnapshotType2<PI, FSI>, ModelInstanceType<PA, OA> | ModelInstanceType<PB, OB> | ModelInstanceType<PC, OC> | ModelInstanceType<PD, OD> | ModelInstanceType<PE, OE> | ModelInstanceType<PF, OF> | ModelInstanceType<PG, OG> | ModelInstanceType<PH, OH> | ModelInstanceType<PI, OI>>;
-export declare function union<CA, SA, TA, CB, SB, TB>(A: IType<CA, SA, TA>, B: IType<CB, SB, TB>): ITypeUnion<CA | CB, SA | SB, TA | TB>;
-export declare function union<CA, SA, TA, CB, SB, TB>(options: UnionOptions, A: IType<CA, SA, TA>, B: IType<CB, SB, TB>): ITypeUnion<CA | CB, SA | SB, TA | TB>;
-export declare function union<CA, SA, TA, CB, SB, TB, CC, SC, TC>(A: IType<CA, SA, TA>, B: IType<CB, SB, TB>, C: IType<CC, SC, TC>): ITypeUnion<CA | CB | CC, SA | SB | SC, TA | TB | TC>;
-export declare function union<CA, SA, TA, CB, SB, TB, CC, SC, TC>(options: UnionOptions, A: IType<CA, SA, TA>, B: IType<CB, SB, TB>, C: IType<CC, SC, TC>): ITypeUnion<CA | CB | CC, SA | SB | SC, TA | TB | TC>;
-export declare function union<CA, SA, TA, CB, SB, TB, CC, SC, TC, CD, SD, TD>(A: IType<CA, SA, TA>, B: IType<CB, SB, TB>, C: IType<CC, SC, TC>, D: IType<CD, SD, TD>): ITypeUnion<CA | CB | CC | CD, SA | SB | SC | SD, TA | TB | TC | TD>;
-export declare function union<CA, SA, TA, CB, SB, TB, CC, SC, TC, CD, SD, TD>(options: UnionOptions, A: IType<CA, SA, TA>, B: IType<CB, SB, TB>, C: IType<CC, SC, TC>, D: IType<CD, SD, TD>): ITypeUnion<CA | CB | CC | CD, SA | SB | SC | SD, TA | TB | TC | TD>;
-export declare function union<CA, SA, TA, CB, SB, TB, CC, SC, TC, CD, SD, TD, CE, SE, TE>(A: IType<CA, SA, TA>, B: IType<CB, SB, TB>, C: IType<CC, SC, TC>, D: IType<CD, SD, TD>, E: IType<CE, SE, TE>): ITypeUnion<CA | CB | CC | CD | CE, SA | SB | SC | SD | SE, TA | TB | TC | TD | TE>;
-export declare function union<CA, SA, TA, CB, SB, TB, CC, SC, TC, CD, SD, TD, CE, SE, TE>(options: UnionOptions, A: IType<CA, SA, TA>, B: IType<CB, SB, TB>, C: IType<CC, SC, TC>, D: IType<CD, SD, TD>, E: IType<CE, SE, TE>): ITypeUnion<CA | CB | CC | CD | CE, SA | SB | SC | SD | SE, TA | TB | TC | TD | TE>;
-export declare function union<CA, SA, TA, CB, SB, TB, CC, SC, TC, CD, SD, TD, CE, SE, TE, CF, SF, TF>(A: IType<CA, SA, TA>, B: IType<CB, SB, TB>, C: IType<CC, SC, TC>, D: IType<CD, SD, TD>, E: IType<CE, SE, TE>, F: IType<CF, SF, TF>): ITypeUnion<CA | CB | CC | CD | CE | CF, SA | SB | SC | SD | SE | SF, TA | TB | TC | TD | TE | TF>;
-export declare function union<CA, SA, TA, CB, SB, TB, CC, SC, TC, CD, SD, TD, CE, SE, TE, CF, SF, TF>(options: UnionOptions, A: IType<CA, SA, TA>, B: IType<CB, SB, TB>, C: IType<CC, SC, TC>, D: IType<CD, SD, TD>, E: IType<CE, SE, TE>, F: IType<CF, SF, TF>): ITypeUnion<CA | CB | CC | CD | CE | CF, SA | SB | SC | SD | SE | SF, TA | TB | TC | TD | TE | TF>;
-export declare function union<CA, SA, TA, CB, SB, TB, CC, SC, TC, CD, SD, TD, CE, SE, TE, CF, SF, TF, CG, SG, TG>(A: IType<CA, SA, TA>, B: IType<CB, SB, TB>, C: IType<CC, SC, TC>, D: IType<CD, SD, TD>, E: IType<CE, SE, TE>, F: IType<CF, SF, TF>, G: IType<CG, SG, TG>): ITypeUnion<CA | CB | CC | CD | CE | CF | CG, SA | SB | SC | SD | SE | SF | SG, TA | TB | TC | TD | TE | TF | TG>;
-export declare function union<CA, SA, TA, CB, SB, TB, CC, SC, TC, CD, SD, TD, CE, SE, TE, CF, SF, TF, CG, SG, TG>(options: UnionOptions, A: IType<CA, SA, TA>, B: IType<CB, SB, TB>, C: IType<CC, SC, TC>, D: IType<CD, SD, TD>, E: IType<CE, SE, TE>, F: IType<CF, SF, TF>, G: IType<CG, SG, TG>): ITypeUnion<CA | CB | CC | CD | CE | CF | CG, SA | SB | SC | SD | SE | SF | SG, TA | TB | TC | TD | TE | TF | TG>;
-export declare function union<CA, SA, TA, CB, SB, TB, CC, SC, TC, CD, SD, TD, CE, SE, TE, CF, SF, TF, CG, SG, TG, CH, SH, TH>(A: IType<CA, SA, TA>, B: IType<CB, SB, TB>, C: IType<CC, SC, TC>, D: IType<CD, SD, TD>, E: IType<CE, SE, TE>, F: IType<CF, SF, TF>, G: IType<CG, SG, TG>, H: IType<CH, SH, TH>): ITypeUnion<CA | CB | CC | CD | CE | CF | CG | CH, SA | SB | SC | SD | SE | SF | SG | SH, TA | TB | TC | TD | TE | TF | TG | TH>;
-export declare function union<CA, SA, TA, CB, SB, TB, CC, SC, TC, CD, SD, TD, CE, SE, TE, CF, SF, TF, CG, SG, TG, CH, SH, TH>(options: UnionOptions, A: IType<CA, SA, TA>, B: IType<CB, SB, TB>, C: IType<CC, SC, TC>, D: IType<CD, SD, TD>, E: IType<CE, SE, TE>, F: IType<CF, SF, TF>, G: IType<CG, SG, TG>, H: IType<CH, SH, TH>): ITypeUnion<CA | CB | CC | CD | CE | CF | CG | CH, SA | SB | SC | SD | SE | SF | SG | SH, TA | TB | TC | TD | TE | TF | TG | TH>;
-export declare function union<CA, SA, TA, CB, SB, TB, CC, SC, TC, CD, SD, TD, CE, SE, TE, CF, SF, TF, CG, SG, TG, CH, SH, TH, CI, SI, TI>(A: IType<CA, SA, TA>, B: IType<CB, SB, TB>, C: IType<CC, SC, TC>, D: IType<CD, SD, TD>, E: IType<CE, SE, TE>, F: IType<CF, SF, TF>, G: IType<CG, SG, TG>, H: IType<CH, SH, TH>, I: IType<CI, SI, TI>): ITypeUnion<CA | CB | CC | CD | CE | CF | CG | CH | CI, SA | SB | SC | SD | SE | SF | SG | SH | SI, TA | TB | TC | TD | TE | TF | TG | TH | TI>;
-export declare function union<CA, SA, TA, CB, SB, TB, CC, SC, TC, CD, SD, TD, CE, SE, TE, CF, SF, TF, CG, SG, TG, CH, SH, TH, CI, SI, TI>(options: UnionOptions, A: IType<CA, SA, TA>, B: IType<CB, SB, TB>, C: IType<CC, SC, TC>, D: IType<CD, SD, TD>, E: IType<CE, SE, TE>, F: IType<CF, SF, TF>, G: IType<CG, SG, TG>, H: IType<CH, SH, TH>, I: IType<CI, SI, TI>): ITypeUnion<CA | CB | CC | CD | CE | CF | CG | CH | CI, SA | SB | SC | SD | SE | SF | SG | SH | SI, TA | TB | TC | TD | TE | TF | TG | TH | TI>;
-export declare function union(...types: IAnyType[]): IAnyType;
-export declare function union(dispatchOrType: UnionOptions | IAnyType, ...otherTypes: IAnyType[]): IAnyType;
-/**
- * Returns if a given value represents a union type.
- *
- * @param type
- * @returns
- */
-export declare function isUnionType<IT extends IAnyType>(type: IT): type is IT;