@jbrowse/mobx-state-tree 5.6.3 → 5.6.6

package/dist/types/utility-types/refinement.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.refinement = refinement;
+exports.isRefinementType = isRefinementType;
+const internal_ts_1 = require("../../internal.js");
+const utils_ts_1 = require("../../utils.js");
+class Refinement extends internal_ts_1.BaseType {
+    _subtype;
+    _predicate;
+    _message;
+    get flags() {
+        return this._subtype.flags | internal_ts_1.TypeFlags.Refinement;
+    }
+    constructor(name, _subtype, _predicate, _message) {
+        super(name);
+        this._subtype = _subtype;
+        this._predicate = _predicate;
+        this._message = _message;
+    }
+    describe() {
+        return this.name;
+    }
+    instantiate(parent, subpath, environment, initialValue) {
+        // create the child type
+        return this._subtype.instantiate(parent, subpath, environment, initialValue);
+    }
+    isAssignableFrom(type) {
+        return this._subtype.isAssignableFrom(type);
+    }
+    isValidSnapshot(value, context) {
+        const subtypeErrors = this._subtype.validate(value, context);
+        if (subtypeErrors.length > 0) {
+            return subtypeErrors;
+        }
+        const snapshot = (0, internal_ts_1.isStateTreeNode)(value)
+            ? (0, internal_ts_1.getStateTreeNode)(value).snapshot
+            : value;
+        if (!this._predicate(snapshot)) {
+            return (0, internal_ts_1.typeCheckFailure)(context, value, this._message(value));
+        }
+        return (0, internal_ts_1.typeCheckSuccess)();
+    }
+    reconcile(current, newValue, parent, subpath) {
+        return this._subtype.reconcile(current, newValue, parent, subpath);
+    }
+    getSubTypes() {
+        return this._subtype;
+    }
+}
+/**
+ * `types.refinement` - Creates a type that is more specific than the base type, e.g. `types.refinement(types.string, value => value.length > 5)` to create a type of strings that can only be longer then 5.
+ *
+ * @param name
+ * @param type
+ * @param predicate
+ * @returns
+ */
+function refinement(...args) {
+    const name = typeof args[0] === "string"
+        ? args.shift()
+        : (0, internal_ts_1.isType)(args[0])
+            ? args[0].name
+            : null;
+    const type = args[0];
+    const predicate = args[1];
+    const message = args[2]
+        ? args[2]
+        : (_v) => "Value does not respect the refinement predicate";
+    // ensures all parameters are correct
+    (0, internal_ts_1.assertIsType)(type, [1, 2]);
+    (0, utils_ts_1.assertIsString)(name, 1);
+    (0, utils_ts_1.assertIsFunction)(predicate, [2, 3]);
+    (0, utils_ts_1.assertIsFunction)(message, [3, 4]);
+    return new Refinement(name, type, predicate, message);
+}
+/**
+ * Returns if a given value is a refinement type.
+ *
+ * @param type
+ * @returns
+ */
+function isRefinementType(type) {
+    return (type.flags & internal_ts_1.TypeFlags.Refinement) > 0;
+}
+//# sourceMappingURL=refinement.js.map

package/dist/types/utility-types/refinement.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"refinement.js","sourceRoot":"","sources":["../../../src/types/utility-types/refinement.ts"],"names":[],"mappings":"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"}

package/dist/types/utility-types/resilient.d.ts

@@ -0,0 +1,18 @@
+import { type IAnyType, type IType } from "../../internal.ts";
+export interface IResilientType<IT extends IAnyType, FT extends IAnyType> extends IType<IT["CreationType"] | FT["CreationType"], IT["SnapshotType"] | FT["SnapshotType"], IT["TypeWithoutSTN"] | FT["TypeWithoutSTN"]> {
+}
+/**
+ * `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 declare function resilient<IT extends IAnyType, FT extends IAnyType>(type: IT, fallbackType: FT, createFallbackSnapshot: (error: unknown, snapshot: any) => FT["CreationType"]): IResilientType<IT, FT>;

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

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resilient = resilient;
+const internal_ts_1 = require("../../internal.js");
+class Resilient extends internal_ts_1.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 (0, internal_ts_1.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 (0, internal_ts_1.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 ((0, internal_ts_1.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 ((0, internal_ts_1.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 (0, internal_ts_1.typeCheckSuccess)();
+    }
+    is(thing) {
+        if ((0, internal_ts_1.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.
+ */
+function resilient(type, fallbackType, createFallbackSnapshot) {
+    (0, internal_ts_1.assertIsType)(type, 1);
+    (0, internal_ts_1.assertIsType)(fallbackType, 2);
+    return new Resilient(type, fallbackType, createFallbackSnapshot);
+}
+//# sourceMappingURL=resilient.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"resilient.js","sourceRoot":"","sources":["../../../src/types/utility-types/resilient.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,63 @@
+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/dist/types/utility-types/snapshotProcessor.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.snapshotProcessor = snapshotProcessor;
+const internal_ts_1 = require("../../internal.js");
+/** @hidden */
+const $preProcessorFailed = Symbol("$preProcessorFailed");
+class SnapshotProcessor extends internal_ts_1.BaseType {
+    _subtype;
+    _processors;
+    get flags() {
+        return this._subtype.flags | internal_ts_1.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 internal_ts_1.ObjectNode) {
+            node.hasSnapshotPostProcessor = !!this._processors.postProcessor;
+        }
+        const oldGetSnapshot = node.getSnapshot;
+        node.getSnapshot = () => this.postProcessSnapshot(oldGetSnapshot.call(node), node);
+        if (!(0, internal_ts_1.isUnionType)(this._subtype)) {
+            node.getReconciliationType = () => {
+                return this;
+            };
+        }
+    }
+    instantiate(parent, subpath, environment, initialValue) {
+        const processedInitialValue = (0, internal_ts_1.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, (0, internal_ts_1.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 (0, internal_ts_1.typeCheckFailure)(context, value, "Failed to preprocess value");
+        }
+        return this._subtype.validate(processedSn, context);
+    }
+    getSubTypes() {
+        return this._subtype;
+    }
+    is(thing) {
+        const value = (0, internal_ts_1.isType)(thing)
+            ? this._subtype
+            : (0, internal_ts_1.isStateTreeNode)(thing)
+                ? (0, internal_ts_1.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 internal_ts_1.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
+ */
+function snapshotProcessor(type, processors, name) {
+    (0, internal_ts_1.assertIsType)(type, 1);
+    if ((0, internal_ts_1.devMode)()) {
+        if (processors.postProcessor &&
+            typeof processors.postProcessor !== "function") {
+            // istanbul ignore next
+            throw (0, internal_ts_1.fail)("postSnapshotProcessor must be a function");
+        }
+        if (processors.preProcessor &&
+            typeof processors.preProcessor !== "function") {
+            // istanbul ignore next
+            throw (0, internal_ts_1.fail)("preSnapshotProcessor must be a function");
+        }
+    }
+    return new SnapshotProcessor(type, processors, name);
+}
+//# sourceMappingURL=snapshotProcessor.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"snapshotProcessor.js","sourceRoot":"","sources":["../../../src/types/utility-types/snapshotProcessor.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,77 @@
+import { type AnyObjectNode, BaseType, 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;